Skill: Implement a Planned Feature
This is the step after plan-feature. Research is done and a plan exists. Your job is to
turn that plan into a change that builds, runs end to end, and stays green, then to write it
up and put it on a branch.
You are the orchestrator. You do not write the whole feature yourself in one pass. You drive
the feature through phases and spin a narrow subagent for each phase, handing it full
context. You stay in the loop between phases, read each result, update the plan, and decide
the next move. This mirrors the subagent discipline in the agent-workflows-qa skill: every
fixer is followed by a reviewer, and every fix is followed by a retest.
Precondition: a plan workspace exists
The feature must already have a planning workspace from plan-feature:
docs/design/<project>/ with at least README.md, context.md, plan.md,
status.md, and research.md.
If there is no such workspace, stop. Run plan-feature first. Do not improvise a plan inside
this skill. status.md is the source of truth for progress and stays current through every
phase below.
The chain at a glance
plan-feature -> [ implement-feature ] -> write-pr-description (when you open the PR)
|
Phase 0 refresh the plan (status.md is truth)
Phase 1 implement (implementer subagent: smallest correct change)
Phase 2 review (reviewer subagent: root cause, no regression)
Phase 3 debug end to end (debug subagent, loop) -> debug-local-deployment skill
Phase 4 tests (test subagent, loop) -> agent-workflows-qa + agent-replay-test
Phase 5 document + PR draft (docs subagent) -> write-docs + write-pr-description (Context + Scope/risk + How to QA)
Phase 6 stacked branch (GitButler) -> but (publish Phase 5 PR body on push)
Keep the orchestration console current (when the effort has one)
If this work is tracked in an orchestration-console project (see the orchestration-console
skill), mirror progress to the console as you go, so the user reads status and answers decisions
from the dashboard instead of chat. The console never replaces the PR review flow; it links to
it. The hooks map onto the phases above:
- Start of every turn:
console pending --project <p> and act on the user's answers and
notes first, then console decision lock each one you acted on.
- Phase 0:
console task add one task per slice; console message what this run attempts.
- Phase 1:
console task set <slice> --status running --owner <impl-agent>.
- Phase 2: on changes requested, a
console message --ref task:<slice>.
- Phase 3-4: when a debug/test loop stalls and you would escalate to the user, raise a
console decision add (the stuck state + options + your rec) instead of burying it in chat.
This is the highest-value hook: it is exactly the "route / debug" decision that gets lost today.
- Phase 5:
console task set <slice> --status in-review --pr <url>.
- Phase 6: on push,
console message with the PR link.
Phase 0: Refresh the plan
Before any code changes, re-read the workspace and reconcile it with the code as it stands
now. Plans rot. The repo may have moved since the plan was written.
- Read
context.md, plan.md, research.md, and status.md.
- Verify the plan's file and symbol citations still exist. Where the code drifted, correct
the plan, do not code against a stale map.
- Cut the plan into the smallest shippable slices, each one independently reviewable and
testable. Record the slice list and the acceptance check for each in
plan.md.
- Update
status.md: what is done, what this run will attempt, known blockers.
End Phase 0 with a concrete slice to build and a written acceptance check for it.
Phase 1: Implement
Spin an implementer subagent per slice. Keep it narrow and give it everything it needs to
work cold:
- the slice goal and its acceptance check from
plan.md,
- the exact files and symbols to touch (from the refreshed plan),
- the repo conventions that apply (the relevant
AGENTS.md, the area skills),
- the rule: make the smallest correct change, match the surrounding code, do not refactor
next door, do not commit.
When the slice defines or changes an interface or contract — API params, wire fields, config
schema, tool definition, event payload — apply the design-interfaces skill first: classify
each field by its semantic role (data, config, policy, credentials, routing, metadata,
protocol context), not the feature it touches, and fix the shape before it ships. The
reviewer in Phase 2 checks the same lens on any contract the slice moved.
When the slice spans the API or SDK, the subagent runs ruff format then ruff check --fix
before reporting done. For frontend slices it runs pnpm lint-fix in web/. The subagent
returns a short diff summary and a self-check against the acceptance criterion. You read it.
You do not trust "done" without the check.
Phase 2: Review
Every implementation is followed by a review. Spin a reviewer subagent and hand it the diff
plus the slice goal. Its job is to confirm the change actually solves the slice, find
regressions, and catch the class of mistake a fixer working alone misses (a Dockerfile CMD
overridden by a compose command:, a default that looks right but is read from the wrong
layer, an edit that the dev stack will not hot-reload).
The reviewer reports: root cause addressed yes or no, regressions, and required changes. If it
asks for changes, loop back to Phase 1 with its notes. Do not advance with an open review.
Note on /code-review (ultrareview): the heavy cloud review is user-triggered and billed, and
you cannot launch it from here. When the change is large or risky, finish the subagent review,
then tell the user they can run /code-review ultra on the branch for a deeper pass.
Phase 3: Debug end to end (loop until it works)
A slice is not done when it compiles. It is done when it runs against the live stack. Spin a
debug subagent that drives the running deployment with the debug-local-deployment skill:
find the live port and compose project, reproduce the path through the playground UI and the
backend API, read the container logs, and confirm the slice does what the acceptance check
says.
Loop: run, observe, fix, re-run. Each iteration is a debug subagent that reports what it saw
and what it changed, followed by a reviewer when it changes code (Phase 2 still applies inside
the loop). Watch dev-mode reload rules: backend and frontend source hot-reload, but a changed
@agenta/* package or a new dependency needs a restart or rebuild. See
debug-local-deployment for the exact commands.
Exit the loop when the slice works end to end against the live stack. See the loop discipline
section below for when to stop trying and escalate instead.
Phase 4: Tests (loop until green across the matrix)
Now make it stay working. Spin a test subagent that improves coverage and runs the suite,
then loops until green. Use the real project test targets, never throwaway scripts.
For agent-workflows changes, the bar is the QA matrix from the agent-workflows-qa skill.
"Test with daytona / local pi / claude, using both the SDK and the UI" maps to its axes:
- Environment:
E1 service + in-process Pi, E2 service + Rivet local, E3 service +
Rivet Daytona, E4 local SDK script. E3 is the daytona cell. E1 or E2 is the local-pi
cell. E4 is the SDK path.
- Harness:
pi, agenta, claude. The claude cell needs an anthropic provider key in
the target project's vault, and claude always forces the Rivet backend.
- Surface: the SDK (E4, a script that pulls config and runs on the host) and the UI (the
playground, driven with the
mcp__chrome-devtools__* tools against the live deployment).
Force each capability with a token the model cannot guess (a constant inside a code tool, a
value from uname -m, a record only the MCP server has) so a pass proves the capability ran,
not just that the agent answered. Consult qa/matrix.md for which cells are valid before
testing one. Do not test cells that cannot exist.
When a matrix cell is green and worth keeping green, pin it with the agent-replay-test skill:
capture one real /run, redact the volatile fields, and write a replay test that exercises
the real SDK and service code against the recorded runner response with no live LLM. These run
cost-free in the default CI lane.
Loop until the suite is green and the targeted matrix cells pass. A capability that is
advertised but never actually invoked is a fail.
Phase 5: Document and pre-draft the PR body
When the feature works and stays green, write it up. Spin a docs subagent.
- Update
status.md to "landed" with what shipped and what was deferred.
- Update the living docs under
docs/design/<project>/ and, when the feature changes how a
user runs or configures the agent, the agent-workflows documentation/ pages. Use the
write-docs skill for Agenta voice and structure.
- If the slice moved an interface, wire field, endpoint, config field, default, harness/backend
value, or runtime behavior, run the
keep-docs-in-sync skill: it maps the change to every
doc that describes it (the documentation/ pages, the interface inventory page AND its index
row, the relevant AGENTS.md, skills) and enforces one source of truth. A contract change and
its docs land in the same PR. Do this inside the same docs subagent.
- Run a clarity pass with the
style-editing skill (Williams' principles: real characters as
subjects, active voice, old-before-new, cut the throat-clearing, land the strong word last).
- Carry anything you could not finish into
defer-todo format so it is not lost.
- Draft the PR body now, while the change is fresh. Use the
write-pr-description skill. The body MUST include: a Context section (the symptom + why), a Scope / risk section (what was not touched, what could regress), and a How to QA section with prerequisites, numbered steps, expected result, the exact test command to run, and edge cases. These are the things reviewers always ask for — they belong in the first draft, not after a review round.
Phase 6: Stacked branch (GitButler)
Put the work on its own lane. This repo runs GitButler, so use but, not raw git, and follow
the repo's gotchas.
but oplog snapshot -m "before <feature> branch" first. The workspace is usually dirty
with other lanes' work, so protect it.
but status to see the lanes and pick the parent to stack on.
but branch new <type>/<feature> --anchor <parent> to stack on that parent.
- Stage only this feature's files to the new lane with
but rub <path> <branch>, then
but commit <branch> --only -m "...". Never run a bare but commit, which sweeps every
unassigned change in the workspace into the lane.
- Stop there unless the user asks to push. When they do,
but push <branch> then
gh pr create --head <branch> --base <parent-or-main>. Use the PR body drafted in Phase 5
(via the write-pr-description skill). Confirm it includes Context, Scope / risk, and the
full How to QA section (prerequisites, steps, expected result, test command, edge cases)
before creating the PR. End commit messages and PR bodies with the session footer the repo
conventions require.
If a file is gitignored (a personal .claude/skills/* skill, for example), it will not enter
the lane. Commit the tracked deliverables and say plainly which files stayed local.
Multi-agent coordination (when others work in parallel)
This repo often has several agents in one GitButler working tree at once. To avoid tangling
GitButler and to keep local and remote in sync:
- Read
docs/design/agent-workflows/scratch/agent-coordination.md first and claim a dated row
for your task. Re-read it to see which files other lanes already own.
- Serialize every
but write behind the board's BUT-LOCK: take it, write, release it. Never
let two but mutations run at once across agents.
- Stage ONLY your task's files to your lane (
but rub <path> <lane>), then
but commit <lane> --only. Never a bare but commit — it sweeps every unassigned change in
the shared tree into your lane. Leave the shared agent-coordination.md edits unassigned.
- Do not edit a file another active agent is mid-change on. If your work and theirs must touch
the same file, sequence (let theirs land first); the board serializes commits, not live
edits, so concurrent same-file edits corrupt each other.
- Commit in small, frequent chunks and keep local and remote in sync: push your lane
(
but push <lane>) when a slice is done so origin matches your working tree, and update the
PR. Always leave a short "what changed" note (a PR comment, or a board row update) so the
next agent and the reviewer are not left re-diffing.
- Merge into the integration branch (
big-agents) only when explicitly told.
Subagent discipline
- Keep each subagent narrow and hand it full context: the goal, the files, the acceptance
check, the conventions. A subagent that has to guess produces work you have to redo.
- Every implementer or fixer is followed by a reviewer. Every fix is followed by a retest. No
exceptions.
- Run independent subagents in parallel (several review dimensions, several matrix cells), but
put a barrier where the next phase needs all of the prior results.
- You synthesize. Subagents return findings, you decide. Do not hand the wheel to a subagent
for a design call.
Loop discipline (do not spin forever)
The debug loop and the test loop can run away. Bound them.
- Set a cap before you start (for example three rounds). If a round makes no progress, stop
looping.
- When stuck, triage with the
agent-workflows-qa tree: fix-now only for a small change with
an obvious home and no design question; otherwise defer (write a defer-todo finding
with a clean repro) or escalate to the user (a repo restructure, a security surface, a
new config the user must decide). When in doubt between fix-now and defer, defer.
- Keep
status.md current at every turn so the next session, or the next agent, can pick up
cold.
Quick reference
| Phase |
Skill it leans on |
| 0 Refresh plan |
plan-feature workspace (docs/design/<project>/) |
| 1 Implement |
area AGENTS.md, area skills; design-interfaces (contract changes); ruff / pnpm lint-fix |
| 2 Review |
reviewer subagent; optional user-run /code-review ultra |
| 3 Debug e2e |
debug-local-deployment |
| 4 Tests |
agent-workflows-qa, agent-replay-test |
| 5 Document + PR draft |
keep-docs-in-sync (contract/interface changes), write-docs, style-editing, defer-todo, write-pr-description (with Context + Scope/risk + How to QA) |
| 6 Branch |
but (GitButler); publish the Phase 5 PR body on push |
1---2name: implement-feature3description: Drive a researched and planned feature to a landed, tested change. Use after plan-feature has produced a docs/design/<project>/ workspace and the user says "implement it", "build the plan", "run the plan", or "let's ship this". Orchestrates refresh-plan, implement, review, a debug-local-deployment loop, and a test loop across the daytona / local-pi / claude x SDK / UI matrix, then documentation and a GitButler stacked branch. The orchestrator stays in the loop and spins narrow subagents for each phase.4allowed-tools: Read, Edit, Write, Grep, Glob, Bash, Agent, Task5user-invocable: true6metadata:7 source: https://skillmd.com/skills/agenta-ai/implement-feature8---910# Skill: Implement a Planned Feature1112This is the step after `plan-feature`. Research is done and a plan exists. Your job is to13turn that plan into a change that builds, runs end to end, and stays green, then to write it14up and put it on a branch.1516You are the orchestrator. You do not write the whole feature yourself in one pass. You drive17the feature through phases and spin a narrow subagent for each phase, handing it full18context. You stay in the loop between phases, read each result, update the plan, and decide19the next move. This mirrors the subagent discipline in the `agent-workflows-qa` skill: every20fixer is followed by a reviewer, and every fix is followed by a retest.2122## Precondition: a plan workspace exists2324The feature must already have a planning workspace from `plan-feature`:2526- `docs/design/<project>/` with at least `README.md`, `context.md`, `plan.md`,27 `status.md`, and `research.md`.2829If there is no such workspace, stop. Run `plan-feature` first. Do not improvise a plan inside30this skill. `status.md` is the source of truth for progress and stays current through every31phase below.3233## The chain at a glance3435```36plan-feature -> [ implement-feature ] -> write-pr-description (when you open the PR)37 |38 Phase 0 refresh the plan (status.md is truth)39 Phase 1 implement (implementer subagent: smallest correct change)40 Phase 2 review (reviewer subagent: root cause, no regression)41 Phase 3 debug end to end (debug subagent, loop) -> debug-local-deployment skill42 Phase 4 tests (test subagent, loop) -> agent-workflows-qa + agent-replay-test43 Phase 5 document + PR draft (docs subagent) -> write-docs + write-pr-description (Context + Scope/risk + How to QA)44 Phase 6 stacked branch (GitButler) -> but (publish Phase 5 PR body on push)45```4647## Keep the orchestration console current (when the effort has one)4849If this work is tracked in an `orchestration-console` project (see the `orchestration-console`50skill), mirror progress to the console as you go, so the user reads status and answers decisions51from the dashboard instead of chat. The console never replaces the PR review flow; it links to52it. The hooks map onto the phases above:5354- **Start of every turn:** `console pending --project <p>` and act on the user's answers and55 notes first, then `console decision lock` each one you acted on.56- **Phase 0:** `console task add` one task per slice; `console message` what this run attempts.57- **Phase 1:** `console task set <slice> --status running --owner <impl-agent>`.58- **Phase 2:** on changes requested, a `console message --ref task:<slice>`.59- **Phase 3-4:** when a debug/test loop stalls and you would escalate to the user, raise a60 `console decision add` (the stuck state + options + your rec) instead of burying it in chat.61 This is the highest-value hook: it is exactly the "route / debug" decision that gets lost today.62- **Phase 5:** `console task set <slice> --status in-review --pr <url>`.63- **Phase 6:** on push, `console message` with the PR link.6465## Phase 0: Refresh the plan6667Before any code changes, re-read the workspace and reconcile it with the code as it stands68now. Plans rot. The repo may have moved since the plan was written.69701. Read `context.md`, `plan.md`, `research.md`, and `status.md`.712. Verify the plan's file and symbol citations still exist. Where the code drifted, correct72 the plan, do not code against a stale map.733. Cut the plan into the smallest shippable slices, each one independently reviewable and74 testable. Record the slice list and the acceptance check for each in `plan.md`.754. Update `status.md`: what is done, what this run will attempt, known blockers.7677End Phase 0 with a concrete slice to build and a written acceptance check for it.7879## Phase 1: Implement8081Spin an implementer subagent per slice. Keep it narrow and give it everything it needs to82work cold:8384- the slice goal and its acceptance check from `plan.md`,85- the exact files and symbols to touch (from the refreshed plan),86- the repo conventions that apply (the relevant `AGENTS.md`, the area skills),87- the rule: make the smallest correct change, match the surrounding code, do not refactor88 next door, do not commit.8990When the slice defines or changes an interface or contract — API params, wire fields, config91schema, tool definition, event payload — apply the `design-interfaces` skill first: classify92each field by its semantic role (data, config, policy, credentials, routing, metadata,93protocol context), not the feature it touches, and fix the shape before it ships. The94reviewer in Phase 2 checks the same lens on any contract the slice moved.9596When the slice spans the API or SDK, the subagent runs `ruff format` then `ruff check --fix`97before reporting done. For frontend slices it runs `pnpm lint-fix` in `web/`. The subagent98returns a short diff summary and a self-check against the acceptance criterion. You read it.99You do not trust "done" without the check.100101## Phase 2: Review102103Every implementation is followed by a review. Spin a reviewer subagent and hand it the diff104plus the slice goal. Its job is to confirm the change actually solves the slice, find105regressions, and catch the class of mistake a fixer working alone misses (a Dockerfile `CMD`106overridden by a compose `command:`, a default that looks right but is read from the wrong107layer, an edit that the dev stack will not hot-reload).108109The reviewer reports: root cause addressed yes or no, regressions, and required changes. If it110asks for changes, loop back to Phase 1 with its notes. Do not advance with an open review.111112Note on `/code-review` (ultrareview): the heavy cloud review is user-triggered and billed, and113you cannot launch it from here. When the change is large or risky, finish the subagent review,114then tell the user they can run `/code-review ultra` on the branch for a deeper pass.115116## Phase 3: Debug end to end (loop until it works)117118A slice is not done when it compiles. It is done when it runs against the live stack. Spin a119debug subagent that drives the running deployment with the `debug-local-deployment` skill:120find the live port and compose project, reproduce the path through the playground UI and the121backend API, read the container logs, and confirm the slice does what the acceptance check122says.123124Loop: run, observe, fix, re-run. Each iteration is a debug subagent that reports what it saw125and what it changed, followed by a reviewer when it changes code (Phase 2 still applies inside126the loop). Watch dev-mode reload rules: backend and frontend source hot-reload, but a changed127`@agenta/*` package or a new dependency needs a restart or rebuild. See128`debug-local-deployment` for the exact commands.129130Exit the loop when the slice works end to end against the live stack. See the loop discipline131section below for when to stop trying and escalate instead.132133## Phase 4: Tests (loop until green across the matrix)134135Now make it stay working. Spin a test subagent that improves coverage and runs the suite,136then loops until green. Use the real project test targets, never throwaway scripts.137138For agent-workflows changes, the bar is the QA matrix from the `agent-workflows-qa` skill.139"Test with daytona / local pi / claude, using both the SDK and the UI" maps to its axes:140141- **Environment**: `E1` service + in-process Pi, `E2` service + Rivet local, `E3` service +142 Rivet Daytona, `E4` local SDK script. E3 is the daytona cell. E1 or E2 is the local-pi143 cell. E4 is the SDK path.144- **Harness**: `pi`, `agenta`, `claude`. The claude cell needs an `anthropic` provider key in145 the target project's vault, and claude always forces the Rivet backend.146- **Surface**: the SDK (E4, a script that pulls config and runs on the host) and the UI (the147 playground, driven with the `mcp__chrome-devtools__*` tools against the live deployment).148149Force each capability with a token the model cannot guess (a constant inside a code tool, a150value from `uname -m`, a record only the MCP server has) so a pass proves the capability ran,151not just that the agent answered. Consult `qa/matrix.md` for which cells are valid before152testing one. Do not test cells that cannot exist.153154When a matrix cell is green and worth keeping green, pin it with the `agent-replay-test` skill:155capture one real `/run`, redact the volatile fields, and write a replay test that exercises156the real SDK and service code against the recorded runner response with no live LLM. These run157cost-free in the default CI lane.158159Loop until the suite is green and the targeted matrix cells pass. A capability that is160advertised but never actually invoked is a fail.161162## Phase 5: Document and pre-draft the PR body163164When the feature works and stays green, write it up. Spin a docs subagent.165166- Update `status.md` to "landed" with what shipped and what was deferred.167- Update the living docs under `docs/design/<project>/` and, when the feature changes how a168 user runs or configures the agent, the agent-workflows `documentation/` pages. Use the169 `write-docs` skill for Agenta voice and structure.170- If the slice moved an interface, wire field, endpoint, config field, default, harness/backend171 value, or runtime behavior, run the `keep-docs-in-sync` skill: it maps the change to every172 doc that describes it (the `documentation/` pages, the interface inventory page AND its index173 row, the relevant `AGENTS.md`, skills) and enforces one source of truth. A contract change and174 its docs land in the same PR. Do this inside the same docs subagent.175- Run a clarity pass with the `style-editing` skill (Williams' principles: real characters as176 subjects, active voice, old-before-new, cut the throat-clearing, land the strong word last).177- Carry anything you could not finish into `defer-todo` format so it is not lost.178- Draft the PR body now, while the change is fresh. Use the `write-pr-description` skill. The body MUST include: a **Context** section (the symptom + why), a **Scope / risk** section (what was not touched, what could regress), and a **How to QA** section with prerequisites, numbered steps, expected result, the exact test command to run, and edge cases. These are the things reviewers always ask for — they belong in the first draft, not after a review round.179180## Phase 6: Stacked branch (GitButler)181182Put the work on its own lane. This repo runs GitButler, so use `but`, not raw git, and follow183the repo's gotchas.1841851. `but oplog snapshot -m "before <feature> branch"` first. The workspace is usually dirty186 with other lanes' work, so protect it.1872. `but status` to see the lanes and pick the parent to stack on.1883. `but branch new <type>/<feature> --anchor <parent>` to stack on that parent.1894. Stage only this feature's files to the new lane with `but rub <path> <branch>`, then190 `but commit <branch> --only -m "..."`. Never run a bare `but commit`, which sweeps every191 unassigned change in the workspace into the lane.1925. Stop there unless the user asks to push. When they do, `but push <branch>` then193 `gh pr create --head <branch> --base <parent-or-main>`. Use the PR body drafted in Phase 5194 (via the `write-pr-description` skill). Confirm it includes Context, Scope / risk, and the195 full How to QA section (prerequisites, steps, expected result, test command, edge cases)196 before creating the PR. End commit messages and PR bodies with the session footer the repo197 conventions require.198199If a file is gitignored (a personal `.claude/skills/*` skill, for example), it will not enter200the lane. Commit the tracked deliverables and say plainly which files stayed local.201202## Multi-agent coordination (when others work in parallel)203204This repo often has several agents in one GitButler working tree at once. To avoid tangling205GitButler and to keep local and remote in sync:206207- Read `docs/design/agent-workflows/scratch/agent-coordination.md` first and claim a dated row208 for your task. Re-read it to see which files other lanes already own.209- Serialize every `but` write behind the board's BUT-LOCK: take it, write, release it. Never210 let two `but` mutations run at once across agents.211- Stage ONLY your task's files to your lane (`but rub <path> <lane>`), then212 `but commit <lane> --only`. Never a bare `but commit` — it sweeps every unassigned change in213 the shared tree into your lane. Leave the shared `agent-coordination.md` edits unassigned.214- Do not edit a file another active agent is mid-change on. If your work and theirs must touch215 the same file, sequence (let theirs land first); the board serializes commits, not live216 edits, so concurrent same-file edits corrupt each other.217- Commit in small, frequent chunks and keep local and remote in sync: push your lane218 (`but push <lane>`) when a slice is done so origin matches your working tree, and update the219 PR. Always leave a short "what changed" note (a PR comment, or a board row update) so the220 next agent and the reviewer are not left re-diffing.221- Merge into the integration branch (`big-agents`) only when explicitly told.222223## Subagent discipline224225- Keep each subagent narrow and hand it full context: the goal, the files, the acceptance226 check, the conventions. A subagent that has to guess produces work you have to redo.227- Every implementer or fixer is followed by a reviewer. Every fix is followed by a retest. No228 exceptions.229- Run independent subagents in parallel (several review dimensions, several matrix cells), but230 put a barrier where the next phase needs all of the prior results.231- You synthesize. Subagents return findings, you decide. Do not hand the wheel to a subagent232 for a design call.233234## Loop discipline (do not spin forever)235236The debug loop and the test loop can run away. Bound them.237238- Set a cap before you start (for example three rounds). If a round makes no progress, stop239 looping.240- When stuck, triage with the `agent-workflows-qa` tree: fix-now only for a small change with241 an obvious home and no design question; otherwise **defer** (write a `defer-todo` finding242 with a clean repro) or **escalate** to the user (a repo restructure, a security surface, a243 new config the user must decide). When in doubt between fix-now and defer, defer.244- Keep `status.md` current at every turn so the next session, or the next agent, can pick up245 cold.246247## Quick reference248249| Phase | Skill it leans on |250|---|---|251| 0 Refresh plan | `plan-feature` workspace (`docs/design/<project>/`) |252| 1 Implement | area `AGENTS.md`, area skills; `design-interfaces` (contract changes); `ruff` / `pnpm lint-fix` |253| 2 Review | reviewer subagent; optional user-run `/code-review ultra` |254| 3 Debug e2e | `debug-local-deployment` |255| 4 Tests | `agent-workflows-qa`, `agent-replay-test` |256| 5 Document + PR draft | `keep-docs-in-sync` (contract/interface changes), `write-docs`, `style-editing`, `defer-todo`, `write-pr-description` (with Context + Scope/risk + How to QA) |257| 6 Branch | `but` (GitButler); publish the Phase 5 PR body on push |