Спецификация и PRD до начала работы

Пишет спецификацию до кода: выявляет допущения, описывает цель, команды, структуру, стиль, тесты и границы, а план, задачи и код начинает только после одобрения; есть карты модулей и дельта-спецификации. Для случаев, когда у новой фичи размытые требования.

ВайбкодингПак: Agent Skills (Addy Osmani)307 строкspec-driven-development
Автор
Источник
addyosmani/agent-skills/skills/spec-driven-development @ 8c99fa3
Лицензия
MIT · Copyright (c) 2025 Addy Osmani

Об этом скилле

Что делает

Скилл заставляет агента написать спецификацию раньше кода и проводит работу через четыре фазы — спецификация, план, задачи, реализация, — и каждую следующую открывает только ваше одобрение. В первой фазе агент выписывает свои допущения («веб-приложение, сессии на куках, PostgreSQL»), чтобы вы их поправили, превращает размытые просьбы в проверяемые критерии («быстрее» становится «LCP меньше 2,5 с») и пишет спецификацию из шести разделов: цель, команды, структура проекта, стиль кода, стратегия тестирования и границы («всегда» / «сначала спросить» / «никогда»). Шаблон добавляет критерии успеха, список Out of Scope (Deferred) и открытые вопросы. После этого агент останавливается и ждёт вашего одобрения, прежде чем планировать.

Две вещи отличают его от прочих. Фаза 0 — проверка рамок: если один запрос объединяет несколько независимо проверяемых возможностей, агент сначала выносит на ваше одобрение карту модулей — идентификаторы, зависимости, порядок сборки — и сохраняет её в spec/capability-map.md, а потом пишет по спецификации на модуль. И версии: в заголовке спецификации стоит V1, идеи, возникшие посреди работы, уходят в список отложенного, а изменение уже выпущенной фичи получает собственную дельта-спецификацию (SPEC-<change>.md рядом с SPEC.md), которую после выхода вливают в исходную. Если в проекте уже есть OpenSpec или другой инструмент для спецификаций, скилл сохраняет его формат.

В папке — SKILL.md и лицензия.

Когда включать и когда не надо

В начале проекта или фичи, при размытых требованиях, когда изменение задевает несколько модулей или займёт больше получаса, а также чтобы очертить V2 или изменение того, что уже выпущено.

Не нужен для правок в одну строку, опечаток и изменений, где требования ясны и самодостаточны.

Как поставить и вызвать

Команда установки ниже кладёт SKILL.md и лицензию. Агент сам подхватывает скилл по описанию, когда у новой работы ещё нет спецификации. Вызвать вручную:

  • Claude Code: /spec-driven-development или попросить скилл по имени.
  • Codex: $spec-driven-development.
  • Cursor: наберите / в чате Agent и выберите spec-driven-development.

Пример: /spec-driven-development Нужны приглашения в команду по email. Напиши спецификацию и дождись моего ревью.

План и задачи строятся по скиллу Разбивка работы на задачи, реализация — по скиллам Реализация тонкими срезами и TDD: красный, зелёный, рефакторинг, а Настройка контекста агента помогает подгружать нужные разделы спецификации. Поставьте их вместе, чтобы пройти весь путь.

Чем отличается от похожих

Спецификация перед кодом — облегчённый вариант: до пяти вопросов с ответами по умолчанию, затем одностраничная спецификация и план из 4–10 шагов за один заход. Спецификация из разговора вообще не задаёт вопросов: превращает уже обсуждённое в пользовательские истории и решения по реализации и публикует их в трекер, который настраивает авторский setup-matt-pocock-skills, или в тот, что вы укажете. Брейншторм перед работой тоже не пускает в код без вашего одобрения, но одобряете вы один дизайн-документ, к которому пришли в разговоре, а план пишет другой скилл. Интервью о задаче из того же набора нужно раньше, когда вы ещё не знаете, чего хотите, и передаёт этому скиллу подтверждённое намерение. Фазы с одобрением между ними, карты модулей, версии и дельта-спецификации есть только здесь.

Установка

Выполните одну команду — она сохранит SKILL.md и файлы, которые он использует, в папку скиллов агента. Claude Code и Codex подхватывают новый скилл без перезапуска; если скилл не появился, перезапустите агента.

Скилл написан на английском — агент поймёт его и ответит вам по-русски.

Claude Code — macOS, Linux
curl -fsSL --create-dirs -o ~/.claude/skills/spec-driven-development/SKILL.md https://anymodel.org/en/skills/addy-osmani/spec-driven-development/SKILL.md -o ~/.claude/skills/spec-driven-development/LICENSE https://anymodel.org/en/skills/addy-osmani/spec-driven-development/LICENSE
Codex, Cursor — macOS, Linux
curl -fsSL --create-dirs -o ~/.agents/skills/spec-driven-development/SKILL.md https://anymodel.org/en/skills/addy-osmani/spec-driven-development/SKILL.md -o ~/.agents/skills/spec-driven-development/LICENSE https://anymodel.org/en/skills/addy-osmani/spec-driven-development/LICENSE
Claude Code — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE') { $p = Join-Path "$HOME\.claude\skills\spec-driven-development" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/addy-osmani/spec-driven-development/$f" -UseBasicParsing -OutFile $p }
Codex, Cursor — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE') { $p = Join-Path "$HOME\.agents\skills\spec-driven-development" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/addy-osmani/spec-driven-development/$f" -UseBasicParsing -OutFile $p }

Другой агент: сохраните файл в его папку скиллов или дайте ему ссылку на файл: https://anymodel.org/en/skills/addy-osmani/spec-driven-development/SKILL.md

SKILL.md

Исходник

Spec-Driven Development

Overview

Write a structured specification before writing any code. The spec is the shared source of truth between you and the human engineer — it defines what we're building, why, and how we'll know it's done. Code without a spec is guessing.

When to Use

  • Starting a new project or feature
  • Requirements are ambiguous or incomplete
  • The change touches multiple files or modules
  • You're about to make an architectural decision
  • The task would take more than 30 minutes to implement

When NOT to use: Single-line fixes, typo corrections, or changes where requirements are unambiguous and self-contained.

The Gated Workflow

Spec-driven development has four phases, preceded by a scope check (Phase 0) that activates only when one request bundles several independently testable capabilities. Do not advance to the next phase until the current one is validated.

SPECIFY ──→ PLAN ──→ TASKS ──→ IMPLEMENT
   │          │        │          │
   ▼          ▼        ▼          ▼
 Human      Human    Human      Human
 reviews    reviews  reviews    reviews

Phase 0: Scope Check

Most requests describe one capability. If this one does, skip this phase and go straight to Specify — Phase 0 exists for the exception, not the rule, and it puts no hierarchy on single-capability features.

Detection. Decompose before specifying when a single requirement bundles several independently testable capabilities:

  • The requirement names distinct capabilities with their own consumers or data (e.g. identity, billing, notifications, reporting)
  • Acceptance criteria cluster into groups that could ship and be verified separately
  • One capability could be cut or replaced without rewriting the others' requirements

Propose a capability map before writing any spec. Small and reviewable — a module table plus a build order, not a project plan:

# Capability Map: [Initiative Name]

| Module id | Responsibility | Depends on |
|---|---|---|
| identity | Accounts, sessions, SSO | — |
| billing | Plans, invoices, payments | identity |
| notifications | Email and webhook fan-out | identity |
| reporting | Usage dashboards | billing, notifications |

Build order: identity → billing, notifications → reporting
  • Stable module ids. Kebab-case, chosen once, never renamed mid-initiative. Specs, plans, and downstream commands select work by these ids instead of guessing which spec is active.
  • Dependency direction, no cycles. Arrows point one way. If two modules each need the other, they are one module.
  • Interfaces live at the boundary. The map records that billing depends on identity; the contract between them belongs in the provider module's spec (see api-and-interface-design for designing it).

The map is gated like every phase. The human reviews module boundaries, dependency direction, and build order before any module spec is written. Getting the map wrong is expensive; reviewing ten lines is not.

Then recurse per module. Run Specify → Plan → Tasks → Implement for each module in dependency order. Each module gets its own spec, scoped to that module's objective, boundaries, and success criteria. Save the approved map as spec/capability-map.md and each module's spec alongside it in spec/, named by module id (spec/SPEC-identity.md, spec/SPEC-billing.md) — /build already accepts specs under spec/, and the root stays uncluttered — the map, not filename guessing, is the index of what exists.

Phase 1: Specify

Start with a high-level vision. Ask the human clarifying questions until requirements are concrete.

Surface assumptions immediately. Before writing any spec content, list what you're assuming:

ASSUMPTIONS I'M MAKING:
1. This is a web application (not native mobile)
2. Authentication uses session-based cookies (not JWT)
3. The database is PostgreSQL (based on existing Prisma schema)
4. We're targeting modern browsers only (no IE11)
→ Correct me now or I'll proceed with these.

Don't silently fill in ambiguous requirements. The spec's entire purpose is to surface misunderstandings before code gets written — assumptions are the most dangerous form of misunderstanding.

Write a spec document covering these six core areas:

  1. Objective — What are we building and why? Who is the user? What does success look like?

  2. Commands — Full executable commands with flags, not just tool names.

    Build: npm run build
    Test: npm test -- --coverage
    Lint: npm run lint -- --fix
    Dev: npm run dev
    
  3. Project Structure — Where source code lives, where tests go, where docs belong.

    src/           → Application source code
    src/components → React components
    src/lib        → Shared utilities
    tests/         → Unit and integration tests
    e2e/           → End-to-end tests
    docs/          → Documentation
    
  4. Code Style — One real code snippet showing your style beats three paragraphs describing it. Include naming conventions, formatting rules, and examples of good output.

  5. Testing Strategy — What framework, where tests live, coverage expectations, which test levels for which concerns.

  6. Boundaries — Three-tier system:

    • Always do: Run tests before commits, follow naming conventions, validate inputs
    • Ask first: Database schema changes, adding dependencies, changing CI config
    • Never do: Commit secrets, edit vendor directories, remove failing tests without approval

Spec template:

# Spec: [Project/Feature Name] — V[N]

## Objective
[What we're building and why. User stories or acceptance criteria.]

## Tech Stack
[Framework, language, key dependencies with versions]

## Commands
[Build, test, lint, dev — full commands]

## Project Structure
[Directory layout with descriptions]

## Code Style
[Example snippet + key conventions]

## Testing Strategy
[Framework, test locations, coverage requirements, test levels]

## Boundaries
- Always: [...]
- Ask first: [...]
- Never: [...]

## Success Criteria
[How we'll know this is done — specific, testable conditions]

## Out of Scope (Deferred)
[Ideas explicitly excluded from this version — the V2 backlog. One line each: what, and why it's deferred.]

## Open Questions
[Anything unresolved that needs human input]

External spec tools: This workflow is format-agnostic. If the project already uses OpenSpec or another specification system, keep that system's artifact format and storage conventions instead of creating a duplicate SPEC.md. This skill owns the clarification, content, and approval gates; the external tool owns how the approved spec is represented.

Reframe instructions as success criteria. When receiving vague requirements, translate them into concrete conditions:

REQUIREMENT: "Make the dashboard faster"

REFRAMED SUCCESS CRITERIA:
- Dashboard LCP < 2.5s on 4G connection
- Initial data load completes in < 500ms
- No layout shift during load (CLS < 0.1)
→ Are these the right targets?

This lets you loop, retry, and problem-solve toward a clear goal rather than guessing what "faster" means.

Stop after writing the spec (CRITICAL). Once the spec is saved:

  1. Summarize it and list any Open Questions.
  2. Ask the human to approve it or request changes.
  3. STOP YOUR TURN IMMEDIATELY. Do NOT start Phase 2, invoke planning-and-task-breakdown, or write code in this turn. Planning starts only after the human approves the spec in a later turn.

Phase 2: Plan

With the validated spec, generate a technical implementation plan:

  1. Identify the major components and their dependencies
  2. Determine the implementation order (what must be built first)
  3. Note risks and mitigation strategies
  4. Identify what can be built in parallel vs. what must be sequential
  5. Define verification checkpoints between phases

Follow planning-and-task-breakdown for the dependency-graph mapping and vertical-slicing mechanics behind these steps; it is the canonical source. The bullets above are a lightweight summary; if they ever diverge, planning-and-task-breakdown takes precedence.

Output convention: Save the plan to tasks/plan.md and record the task list in the task list target defined by planning-and-task-breakdown (default tasks/todo.md; projects may designate an external tracker instead). Create tasks/ if it does not exist. Downstream commands (/build, etc.) expect these defaults.

The plan should be reviewable: the human should be able to read it and say "yes, that's the right approach" or "no, change X."

Phase 3: Tasks

Break the plan into discrete, implementable tasks:

  • Each task should be completable in a single focused session
  • Each task has explicit acceptance criteria
  • Each task includes a verification step (test, build, manual check)
  • Tasks are ordered by dependency, not by perceived importance
  • No task should require changing more than ~5 files

Follow planning-and-task-breakdown for the full task-sizing and dependency-ordering mechanics; it is the canonical source. The template below is a lightweight inline form; if they ever diverge, planning-and-task-breakdown takes precedence.

Task template:

- [ ] Task: [Description]
  - Acceptance: [What must be true when done]
  - Verify: [How to confirm — test command, build, manual check]
  - Files: [Which files will be touched]

Phase 4: Implement

Execute tasks one at a time following skills/incremental-implementation/SKILL.md (incremental-implementation) and skills/test-driven-development/SKILL.md (test-driven-development). Use skills/context-engineering/SKILL.md (context-engineering) to load the right spec sections and source files at each step rather than flooding the agent with the entire spec.

Keeping the Spec Alive

The spec is a living document, not a one-time artifact:

  • Update when decisions change — If you discover the data model needs to change, update the spec first, then implement.
  • Update when scope changes — Features added or cut should be reflected in the spec.
  • Commit the spec — The spec belongs in version control alongside the code.
  • Reference the spec in PRs — Link back to the spec section that each PR implements.

Spec Evolution: V1 Scoping and Follow-Up Changes

A spec describes one version of the work. New ideas and post-ship changes don't expand it — they queue behind it.

Scope each version explicitly

Label the spec with the version it describes, in the title (# Spec: Invoice Pipeline — V1). When a shipped delta is folded back in, bump the version — the label always states which version of the system the spec describes, and makes "that's a V2 idea" an objective call rather than a judgment made mid-build.

During Specify, ideas that won't make this version go under Out of Scope (Deferred) — captured, not lost. This makes the V1 boundary enforceable: during implementation, anything not in the spec's requirements is out, even if it's written in the same file under Deferred. When an idea arrives mid-build, park it in the Deferred list and keep going; re-scoping happens between versions, not during one.

Follow-up changes get a delta spec

Once a spec has shipped, a new requirement — swapping the storage engine, replacing a manual step with OCR, promoting a deferred V2 item — gets its own small spec rather than a hand-edit of the shipped one. A delta spec covers only what changes:

# Spec Delta: [Change Name]

Status: proposed

## Objective
[The change and why. Which deferred item or new requirement this implements.]

## Current Behavior
[What exists today — link the relevant section of the original spec.]

## New Behavior
[What will be true after the change.]

## Success Criteria
[Specific, testable conditions — including what must NOT change.]

## Boundaries
[Only deltas from the original spec's boundaries; everything else inherits.]

Save it alongside the original (e.g. SPEC-postgres-migration.md next to SPEC.md) and run it through the same gated workflow: human review, then plan, tasks, implement. Downstream commands know this convention — /build auto accepts a root-level SPEC-<change>.md as the spec for a follow-up change and treats it as a planning artifact in its clean-baseline check. Keep one change per delta spec — that keeps each plan/build cycle small and reviewable.

After the change ships, fold the outcome into the original spec (per Keeping the Spec Alive) so it stays the source of truth for what exists, and mark the delta implemented by changing its Status: line to Status: implemented. The original spec always describes the current system; delta specs describe transitions.

Common Rationalizations

Rationalization Reality
"This is simple, I don't need a spec" Simple tasks don't need long specs, but they still need acceptance criteria. A two-line spec is fine.
"I'll write the spec after I code it" That's documentation, not specification. The spec's value is in forcing clarity before code.
"The spec will slow us down" A 15-minute spec prevents hours of rework. Waterfall in 15 minutes beats debugging in 15 hours.
"Requirements will change anyway" That's why the spec is a living document. An outdated spec is still better than no spec.
"The user knows what they want" Even clear requests have implicit assumptions. The spec surfaces those assumptions.
"This idea is good, I'll fold it into the current spec" Mid-build scope growth is how V1 slips. Park it under Out of Scope (Deferred) — captured without expanding the current cycle.
"The feature already has a spec, I'll just edit it for the change" A shipped spec describes what exists. A delta spec keeps the change reviewable on its own; the original gets updated after the change ships, not before.
"It's one big feature; splitting it is overhead" If acceptance criteria cluster into independently testable groups, a monolithic spec forces every downstream task to reason over the whole contract. A ten-line capability map is the cheap alternative.
"I'll decompose during planning" Planning slices tasks within a spec. By then the oversized artifact already exists — module boundaries and dependency direction must be decided before the spec is written, not after.

Red Flags

  • Starting to write code without any written requirements
  • Asking "should I just start building?" before clarifying what "done" means
  • Implementing features not mentioned in any spec or task list
  • Making architectural decisions without documenting them
  • Skipping the spec because "it's obvious what to build"
  • V1 requirements growing mid-implementation as new ideas get written straight into the spec
  • Changing a shipped feature with no spec for the change because "the feature already has one"
  • Writing the spec and starting the plan or code in the same turn
  • One spec whose requirements span several independently testable capabilities
  • Module boundaries or build order decided implicitly during implementation because no capability map was approved up front

Verification

Before proceeding to implementation, confirm:

  • The spec covers all six core areas (a full spec; a delta spec covers only the areas the change affects — at minimum objective, success criteria, and boundary deltas — and inherits the rest from the original)
  • The human has reviewed and approved the spec
  • The turn ended after saving the spec; approval came in a later turn
  • Success criteria are specific and testable
  • Boundaries (Always/Ask First/Never) are defined
  • The spec is saved to a file in the repository
  • Ideas cut from this version are captured under Out of Scope (Deferred), not silently dropped or silently included
  • If this is a change to a shipped spec, it is a delta spec referencing the original, not a rewrite of it
  • If the request bundles several independently testable capabilities, a capability map (module ids, dependency direction, build order) was approved before any module spec was written
  • Every module spec traces to a module id in the approved map

Подключить через AnyModel API

Скилл работает на той модели, которую использует агент. Подключите Claude Code, Codex или Cursor к AnyModel и запускайте его на Claude, GPT, Gemini и других моделях по одному ключу — оплата за токены, без подписки.

Ещё из пака Agent Skills (Addy Osmani)

Доступность: аудит и исправления по WCAG 2.2

Делает аудит готового интерфейса по WCAG 2.2 AA: axe-core и pa11y, затем клавиатура, экранный чтец и контраст, и исправляет подтверждённые нарушения, начиная с семантического HTML. Для случаев, когда страницу нужно проверить на доступность перед выкладкой.

Проектирование API и интерфейсов

Делает проект API и интерфейсов модулей от контракта: одна форма ошибок, проверка на границах, только добавляющие изменения, пагинация и ключи идемпотентности. Для случаев, когда проектируются эндпоинты или меняется публичный интерфейс.

Тесты в браузере через Chrome DevTools MCP

Делает проверку изменений в настоящем Chrome через MCP-сервер Chrome DevTools: скриншоты, DOM, консоль, сеть и трейсы, а содержимое страницы считает недоверенным. Для случаев, когда разрабатывается или отлаживается что-то в браузере.

Настройка CI/CD

Делает пайплайн CI/CD с закреплённым порядком проверок от линтера до размера бандла, примерами на GitHub Actions, превью-деплоями, фича-флагами, поэтапной выкаткой и откатом. Для случаев, когда настраивается или чинится сборка и деплой.

Код-ревью по нескольким осям

Делает ревью изменения по пяти осям — корректность, читаемость, архитектура, безопасность, производительность, — проверяет тесты мутацией условия и помечает находки по уровню. Для случаев, когда ветку, пул-реквест или дифф пора сливать.

Упрощение кода

Делает работающий код проще для чтения, не меняя поведения: сначала выясняет, зачем он такой, потом упрощает по одному шагу с тестами после каждого. Для случаев, когда код работает, но читается тяжелее, чем мог бы.

Планка качества как контракт

Делает из планки качества проекта контракт: после короткого опроса записывает числа в CONSTRAINTS.md, привязывает их к инструментам и ловит в диффе пропущенные тесты и ослабленные пороги. Для случаев, когда планка нигде не записана.

Настройка контекста агента

Делает настройку контекста агента: шаблон файла правил, загрузка только нужных файлов и разделов спецификации, чистка длинной сессии и безопасный момент начать новую. Для случаев, когда начинается сессия или ответы агента портятся.

Отладка и восстановление после ошибок

Останавливает новую работу при поломке, воспроизводит и сужает сбой, чинит первопричину, добавляет регрессионный тест и не выполняет команды из текста ошибок. Для случаев, когда упал тест, сломалась сборка или перестало работать то, что работало.

Вывод из эксплуатации и миграции

Выводит из эксплуатации старые системы, API и фичи: решает, стоит ли, проверяет замену, переводит потребителей по одному, удаляет код при нулевом использовании, схему меняет через expand/contract. Для случаев, когда старое заменяют или переименовывают колонку.

Документация и ADR

Записывает решения в ADR по формату проекта, документирует API, README и changelog с упором на «почему», по истории git проверяет, не устарел ли документ. Для случаев, когда принято дорогое решение, меняется публичный API или документы разошлись с кодом.

Разработка через сомнение

Отдаёт нетривиальные решения субагенту со свежим контекстом, чтобы тот искал ошибки, сортирует находки, ограничивает цикл тремя кругами и предлагает мнение другой модели. Для случаев, когда ставки высоки: авторизация, миграции, необратимые операции.

Фронтенд-интерфейсы для продакшена

Строит компоненты и страницы на дизайн-системе проекта: композиция, простое состояние, WCAG 2.1 AA, mobile-first, состояния загрузки, пустого списка и ошибки, без ИИ-эстетики. Для случаев, когда создают или меняют пользовательский интерфейс.

Git-процесс и версионирование

Ведёт работу в git атомарными коммитами в коротких ветках: сообщения с типом, проверка секретов и тестов перед коммитом, worktree для параллельных агентов, semver, теги и changelog. Для случаев, когда коммитят, ветвятся, открывают PR или выпускают релиз.

Доработка сырой идеи

Доводит сырую идею за три фазы: уточняющие вопросы и пять-восемь вариантов, два-три направления с проверкой ценности, реализуемости и допущений, затем одностраничник с MVP и списком «Чего не делаем». Для случаев, когда идея расплывчата или план надо проверить.

Реализация тонкими срезами

Строит изменения тонкими срезами — вертикально, от контракта или от риска, — тестируя и коммитя каждый перед следующим, в рамках задачи, с feature-флагами и откатываемыми шагами. Для случаев, когда правка затрагивает несколько файлов или задача велика.

Интервью о задаче

Расспрашивает по одному вопросу с догадкой об ответе и оценкой уверенности, пока агент не сможет предсказать ответы, и до спецификации и кода получает подтверждённое намерение. Для случаев, когда в запросе неясно, для кого, зачем и что считать успехом.

Наблюдаемость: логи, метрики, трейсы

Встраивает в фичу JSON-логи с ID запроса, метрики RED и USE с ограниченными метками, трейсы OpenTelemetry и алерты по симптомам с ранбуками, а затем проверяет саму телеметрию. Для случаев, когда фича, фоновая задача или интеграция идёт в прод.

Оптимизация производительности

Ускоряет приложение по замерам: снимает базу, исправляет одно доказанное узкое место, перемеряет с учётом разброса и откатывает нейтральные правки; есть примеры для N+1, индексов, кэша и бандла. Для случаев, когда что-то тормозит или не влезает в бюджет.

Разбивка работы на задачи

Разбивает спецификацию на небольшие вертикальные задачи с критериями приёмки, проверками, размером, порядком и контрольными точками — в tasks/todo.md или в трекер. Для случаев, когда спецификация готова, а работа слишком велика для одного захода.

Защита кода от уязвимостей

Защищает код: модель угроз, правила «всегда», «сначала спросить», «никогда» и паттерны против инъекций, XSS, обхода доступа, SSRF, утечки секретов и опасных зависимостей. Для случаев, когда код принимает ввод, ведёт вход, хранит личные данные или зовёт LLM.

Подготовка к запуску в прод

Готовит запуск в прод: чек-лист перед выкаткой, фича-флаг с этапами от 5% до 100%, пороги для продолжения или отката, бюджет ошибок, письменный план отката и проверки в первый час. Для случаев, когда фича или крупное изменение вот-вот уйдёт в прод.

Код по официальной документации

Пишет код под фреймворк по официальной документации: берёт точные версии из файла зависимостей, открывает нужную страницу, следует описанному API и даёт ссылки, помечая непроверенное. Для случаев, когда код должен соответствовать версии фреймворка в проекте.

TDD: красный, зелёный, рефакторинг

Ведёт изменения по циклу «красный, зелёный, рефакторинг»: находит команды тестов проекта, пишет падающий тест первым, воспроизводит каждый баг тестом до исправления и задаёт правила для моков и имён. Для случаев, когда добавляется логика или чинится баг.