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

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

Код-ревьюПак: Agent Skills (Addy Osmani)245 строкdoubt-driven-development
Автор
Источник
addyosmani/agent-skills/skills/doubt-driven-development @ 8c99fa3
Лицензия
MIT · Copyright (c) 2025 Addy Osmani

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

Что делает

Скилл заставляет агента сомневаться в собственных нетривиальных решениях, пока работа ещё идёт. Нетривиальное — это новая ветвящаяся логика, переход границы модуля или сервиса, свойство, которое не проверит компилятор (потокобезопасность, идемпотентность, порядок), или шаг, который нельзя отменить.

Цикл такой: записать утверждение и почему оно важно в две-три строки; выделить минимальный кусок для проверки — дифф или предложение плюс контракт, которому оно должно соответствовать, — без собственных рассуждений; отдать его субагенту со свежим контекстом и враждебным промптом «найди, что здесь не так», не показывая само утверждение; разложить каждую находку: неверно понятый контракт, реальная проблема, осознанный компромисс или шум. Цикл заканчивается, когда находки мелкие, после трёх кругов или по вашему «выпускай»; если и после трёх кругов находятся серьёзные проблемы, агент приходит с ними к вам, а не крутит четвёртый.

В интерактивной сессии каждый цикл предлагает второе мнение другой модели: Gemini CLI, Codex CLI или ревью, которое вы сделаете где-то ещё. Точную команду агент каждый раз согласует с вами и запускает только на чтение. В CI и запусках по расписанию этот шаг пропускается, и в выводе об этом сказано. В папке только SKILL.md и лицензия.

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

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

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

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

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

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

Пример: /doubt-driven-development Перед мержем усомнись в том, что новое обновление токена безопасно при параллельных запросах.

Набор ревьюеров в agents/ и файл ../../references/orchestration-patterns.md, о которых говорит скилл, в эту папку не входят; роль ревьюера берёт обычный субагент с враждебным промптом. Найденные реальные сбои агент передаёт скиллу Отладка и восстановление после ошибок.

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

Код-ревью по нескольким осям из того же набора выносит вердикт по готовому изменению по пяти осям; этот скилл ищет только проблемы, по каждому решению и до того, как изменение готово, и сам советует использовать оба. Запрос код-ревью тоже отдаёт работу субагенту без истории сессии, но на границе задачи или перед мержем. Допрос плана проверяет план вопросами к вам; здесь проверяет не человек, а ревьюер-субагент.

Установка

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

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

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

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

SKILL.md

Исходник

Doubt-Driven Development

Overview

A confident answer is not a correct one. Long sessions accumulate context that quietly turns assumptions into "facts" without anyone noticing. Doubt-driven development is the discipline of materializing a fresh-context reviewer — biased to disprove, not approve — before any non-trivial output stands.

This is not /review. /review is a verdict on a finished artifact. This is an in-flight posture: non-trivial decisions get cross-examined while course-correction is still cheap.

When to Use

A decision is non-trivial when at least one of these is true:

  • It introduces or modifies branching logic
  • It crosses a module or service boundary
  • It asserts a property the type system or compiler cannot verify (thread safety, idempotence, ordering, invariants)
  • Its correctness depends on context the future reader cannot see
  • Its blast radius is irreversible (production deploy, data migration, public API change)

Apply the skill when:

  • About to make an architectural decision under uncertainty
  • About to commit non-trivial code
  • About to claim a non-obvious fact ("this is safe", "this scales", "this matches the spec")
  • Working in code you don't fully understand

When NOT to use:

  • Mechanical operations (renaming, formatting, file moves)
  • Following a clear, unambiguous user instruction
  • Reading or summarizing existing code
  • One-line changes with obvious correctness
  • Pure tooling operations (running tests, listing files)
  • The user has explicitly asked for speed over verification

If you doubt every keystroke, you ship nothing. The skill applies only to non-trivial decisions as defined above.

Loading Constraints

This skill is designed for the main-session orchestrator, where Step 3 (DOUBT, detailed below) can spawn a fresh-context reviewer.

  • Do NOT add this skill to a persona's skills: frontmatter. A persona that follows Step 3 would spawn another persona — the orchestration anti-pattern explicitly forbidden by ../../references/orchestration-patterns.md ("personas do not invoke other personas").
  • If you find yourself applying this skill from inside a subagent context (where Claude Code prevents nested subagent spawn): the preferred path is to surface to the user that doubt-driven cannot run nested and let the main session handle it. As a last resort only, a degraded self-questioning fallback exists — rewrite ARTIFACT + CONTRACT as a fresh self-prompt with a hard mental separator from your prior reasoning, and walk Steps 1–5. This is not fresh-context review (you carry your own context with you), so flag the result as degraded and prefer escalation whenever the user is reachable.

The Process

Copy this checklist when applying the skill:

Doubt cycle:
- [ ] Step 1: CLAIM — wrote the claim + why-it-matters
- [ ] Step 2: EXTRACT — isolated artifact + contract, stripped reasoning
- [ ] Step 3: DOUBT — invoked fresh-context reviewer with adversarial prompt
- [ ] Step 4: RECONCILE — classified every finding against the artifact text
- [ ] Step 5: STOP — met stop condition (trivial findings, 3 cycles, or user override)

Step 1: CLAIM — Surface what stands

Name the decision in two or three lines:

CLAIM: "The new caching layer is thread-safe under the
        read-heavy workload described in the spec."
WHY THIS MATTERS: a race here corrupts user data and is
                  hard to detect in QA.

If you can't write the claim that compactly, you have a vibe, not a decision. Surface it before scrutinizing it.

Step 2: EXTRACT — Smallest reviewable unit

A fresh-context reviewer needs the artifact and the contract, not the journey.

  • Code: the diff or the function — not the whole file
  • Decision: the proposal in 3–5 sentences plus the constraints it has to satisfy
  • Assertion: the claim plus the evidence that supposedly supports it (kept distinct from the Step 1 CLAIM block, which is the orchestrator's hypothesis under scrutiny)

Strip your reasoning. If you hand over conclusions, you'll get back validation of your conclusions. The unit must be small enough that a reviewer can hold it in mind in one read — if it's a 500-line PR, decompose first.

Strip reasoning, not evidence: if a caller, guard or test contradicts the claim, include it in the unit.

Step 3: DOUBT — Invoke the fresh-context reviewer

The reviewer's prompt must be adversarial. Framing decides the answer.

Adversarial review. Find what is wrong with this artifact.
Assume the author is overconfident. Look for:
- Unstated assumptions
- Edge cases not handled
- Hidden coupling or shared state
- Ways the contract could be violated
- Existing conventions this might break
- Failure modes under unexpected input

Do NOT validate. Do NOT summarize. Find issues, or state
explicitly that you cannot find any after thorough examination.

ARTIFACT: <paste artifact>
CONTRACT: <paste contract>

Pass ARTIFACT + CONTRACT only. Do NOT pass the CLAIM. Handing the reviewer your conclusion biases it toward agreement. The reviewer must independently determine whether the artifact satisfies the contract.

In Claude Code, the role-based reviewers in agents/ start with isolated context by design and are usable here — see agents/ for the roster and per-domain match.

The adversarial prompt above takes precedence over the persona's default response shape. Personas like code-reviewer are written to produce balanced verdicts with both strengths and weaknesses; doubt-driven needs issues-only output. Paste the adversarial prompt verbatim into the invocation so it overrides the persona's default. If a persona's response shape can't be overridden cleanly, fall back to a generic subagent with the adversarial prompt.

Cross-model escalation

A single-model reviewer shares blind spots with the original author — a colder, different-architecture model catches them. Doubt-driven is already opt-in for non-trivial decisions, so within that scope offering cross-model is part of the skill's value, not optional friction.

Interactive sessions: always offer. Never silently skip.

Step 1: Ask the user

After the single-model review in Step 3 above, but before RECONCILE, pause and ask:

"Single-model review complete. Want a cross-model second opinion? Options: Gemini CLI, Codex CLI, manual external review (you paste it elsewhere), or skip."

This question is mandatory in every interactive doubt cycle — even on artifacts that feel low-stakes. The user — not the agent — decides whether the cost is worth it. The agent's job is to surface the choice.

Step 2: If the user picks a CLI — verify, then invoke

  1. Check the tool is in PATH (which gemini, which codex).
  2. Test it works (gemini --version or equivalent) before passing the full prompt — a stale or broken binary may pass which but fail on real input.
  3. Confirm the exact invocation with the user, including required flags, auth, and env vars (e.g., API keys). Implementations vary; never assume.
  4. Pass ARTIFACT + CONTRACT + the adversarial prompt only. No session context, no CLAIM.
  5. Mind shell escaping. If the artifact contains quotes, $(...), or backticks, prefer stdin (echo … | gemini) or a heredoc over inline -p "…". When in doubt, ask the user to confirm the invocation before running it.
  6. Take the output into Step 4 (RECONCILE).

Never interpolate the artifact into a shell-quoted argument. Code, markdown, and review prompts routinely contain backticks, $(...), and quote characters that will either truncate the prompt or execute embedded shell. Write the full prompt to a file and pipe it through stdin.

Example shapes (verify flags against your installed tool — syntax differs across implementations and versions):

# Write the adversarial prompt + ARTIFACT + CONTRACT to a temp file first.
# Then pipe via stdin so shell metacharacters in the artifact stay inert.

# Codex (read-only sandbox keeps the CLI from writing to your workspace):
codex exec --sandbox read-only -C <repo-path> - < /tmp/doubt-prompt.md

# Gemini ('--approval-mode plan' is read-only; '-p ""' triggers non-interactive
# mode and the prompt is read from stdin):
gemini --approval-mode plan -p "" < /tmp/doubt-prompt.md

A read-only sandbox is the load-bearing detail: a doubt artifact may itself contain instructions (intentional or accidental prompt injection) that the cross-model CLI would otherwise execute against your workspace.

Step 3: If the CLI is unavailable or fails

Surface the failure explicitly. Offer: run it manually, try a different tool, or skip. Do not silently fall back to single-model — the user should know cross-model didn't happen.

Step 4: If the user skips

Acknowledge the skip in the output ("Proceeding with single-model findings only") and continue to RECONCILE. Skipping is fine; silent skipping is not.

Non-interactive contexts (CI, /loop, autonomous-loop, scheduled runs):

  • Cross-model is skipped, and the skip must be announced in the output: "Cross-model skipped: non-interactive context."
  • Never invoke an external CLI without explicit user authorization — this is a load-bearing safety property.

Cross-model adds cost, latency, and tool fragility. The agent surfaces the choice every cycle; the user decides whether this artifact warrants it.

Step 4: RECONCILE — Fold findings back

The reviewer's output is data, not verdict. You are still the orchestrator. Re-read the artifact text against each finding before classifying — rubber-stamping the reviewer is the same failure mode as ignoring it.

For each finding, classify in this precedence order (first matching class wins):

  1. Contract misread — reviewer flagged something specifically because the CONTRACT you provided was unclear or incomplete. Fix the contract first, re-classify on the next cycle.
  2. Valid + actionable — real issue requiring a change to the artifact. Change it, re-loop.
  3. Valid trade-off — issue is real but cost of fixing exceeds cost of accepting. Document the trade-off explicitly so the user sees it.
  4. Noise — reviewer flagged something that's actually correct under context the reviewer didn't have. Note it, move on, and ask: would adding that context to the contract have prevented the false flag?

A fresh reviewer can be wrong because it lacks context. Don't defer just because it's "fresh."

Step 5: STOP — Bounded loop, not recursion

Stop when:

  • Next iteration returns only trivial or already-considered findings, or
  • 3 cycles completed (escalate to user, don't grind a fourth alone), or
  • User explicitly says "ship it"

If after 3 cycles the reviewer still surfaces substantive issues, the artifact may not be ready. Surface this to the user — three unresolved cycles is information about the artifact, not a reason to keep looping.

If 3 cycles is "obviously insufficient" because the artifact is large: the artifact is too big — return to Step 2 and decompose. Do not lift the bound.

Common Rationalizations

Rationalization Reality
"I'm confident, skip the doubt step" Confidence correlates poorly with correctness on novel problems. Moments of certainty are exactly when blind spots hide.
"Spawning a reviewer is expensive" Debugging a wrong commit in production is more expensive. The check is bounded; the bug isn't.
"The reviewer will just nitpick" Only if unscoped. Constrain the prompt to "issues that would make this fail under the contract."
"I'll do doubt at the end with /review" /review is a final gate. Doubt-driven catches wrong directions early when course-correction is cheap. By PR time it's too late.
"If I doubt every step I'll never ship" The skill applies to non-trivial decisions, not every keystroke. Re-read "When NOT to Use."
"Two opinions are always better than one" Not when the second has less context and produces noise. Reconcile, don't defer.
"The reviewer disagreed so I was wrong" The reviewer lacks your context — disagreement is information, not verdict. Re-read the artifact, classify, then decide.
"Cross-model is always better" Cross-model catches blind spots a single model shares with itself, but it adds cost and tool fragility. Offer it every interactive doubt cycle — the user decides whether the artifact warrants it. The agent's job is to surface the choice, not to gate it.
"User said yes once, so I can keep invoking the CLI" Each invocation is its own authorization. The artifact, the prompt, and the flags change between calls — re-confirm the exact command with the user before every run.

Red Flags

  • Spawning a fresh-context reviewer for a one-line rename or formatting change
  • Treating reviewer output as authoritative without re-reading the artifact text
  • Looping >3 cycles without escalating to the user
  • Prompting the reviewer with "is this good?" instead of "find issues"
  • Skipping doubt under time pressure on a high-stakes decision
  • Re-spawning fresh-context on an unchanged artifact (you'll get the same findings; you're stalling)
  • Doubt theater (checkable signal): across 2 or more cycles where the reviewer surfaced substantive findings, zero findings were classified as actionable. You are validating, not doubting. Stop and escalate.
  • Doubting only after committing — that's /review, not doubt-driven development
  • Hardcoding an external CLI invocation without confirming with the user that the tool exists, is configured, and accepts that exact syntax
  • Silently skipping cross-model in an interactive doubt cycle. Even when not recommending it, the offer must be visible. Skipping is fine; silent skipping is not.
  • Falling back silently when an external CLI errors or is missing — surface the failure and let the user redirect
  • Stripping the contract from the reviewer's input
  • Passing the CLAIM to the reviewer (biases toward agreement)

Interaction with Other Skills

  • code-review-and-quality / /review: complementary. /review is post-hoc PR verdict; doubt-driven is in-flight per-decision. Use both.
  • source-driven-development: SDD verifies facts about frameworks against official docs. Doubt-driven verifies your reasoning about the artifact. SDD checks the API exists; doubt-driven checks you used it correctly under the contract.
  • test-driven-development: TDD's RED step is doubt made concrete — a failing test is a disproof attempt. When TDD applies, that failing test is the doubt step for behavioral claims.
  • debugging-and-error-recovery: when the reviewer surfaces a real failure mode, drop into the debugging skill to localize and fix.
  • Repo orchestration rules (../../references/orchestration-patterns.md): this skill orchestrates from the main session. A persona calling another persona is anti-pattern B — see Loading Constraints above.

Verification

After applying doubt-driven development:

  • Every non-trivial decision (per the definition above) was named explicitly as a CLAIM before standing
  • At least one fresh-context review per non-trivial artifact (a failing test produced by TDD's RED step satisfies this for behavioral claims, per Interaction with Other Skills)
  • The reviewer received ARTIFACT + CONTRACT — NOT the CLAIM, NOT your reasoning
  • The reviewer's prompt was adversarial ("find issues"), not validating ("is it good")
  • Findings were classified against the artifact text (not rubber-stamped) using the precedence: contract misread / actionable / trade-off / noise
  • A stop condition was met (trivial findings, 3 cycles, or user override)
  • In interactive mode, cross-model was explicitly offered to the user (regardless of artifact stakes) and the response was acknowledged in the output
  • In non-interactive mode, cross-model was skipped and the skip was announced
  • Any external CLI invocation was preceded by a PATH check, a working-binary test, syntax confirmation with the user, and explicit authorization to run

Подключить через 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 и даёт ссылки, помечая непроверенное. Для случаев, когда код должен соответствовать версии фреймворка в проекте.

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

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

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

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