implement-spec

Files (1)

• SKILL.md

SKILL.md (first lines)

# Implement Spec

Build the active spec to completion, one reviewable pass at a time. The spec is
the implementation plan; user constraints and accepted experimental evidence
remain binding when the architecture changes.

A pass (usually one slice) is a **commit checkpoint, not a stopping point.** The
job is the whole spec — every slice, every global TODO — not the first green
commit. Finishing a pass means starting the next one, not handing back to the
user. Only stop when the spec is fully implemented (or a genuine blocker needs a
decision only the user can make).

**Work in parallel wherever the graph allows.** Do not walk the ladder one slice
at a time when slices are independent. Read the spec's dependency graph as a
wavefront and **delegate independent passes to subagents that run concurrently**
(see Rules) — you orchestrate and integrate; only serialize what genuinely
depends on prior work.

## Workflow

1. Read the repo README, the spec README, and the next slice before editing.
   Load any skills named by the spec. Identify the current pickup point, global
   TODOs, required gates, and what must stay green. If a multi-slice spec lacks
   a live handoff prompt, add one before the first pass ends.
   For a validated spike, apply **Preserve the winner** below before editing.
2. Reconcile the plan with the current code. If the slice would preserve a
   development-only shim, duplicated type, weak wrapper, or obsolete path,
   replace it with the simpler architecture and update the spec handoff.
3. Implement one coherent pass: usually one slice, one vertical checkpoint, or
   one architecture correction. Keep the review surface small enough to audit.
4. Verify the actual contract. For behavior changes, run the focused tests
   first; for browser-visible work, use the real browser/harness and inspect
   screenshots so the subject is framed and readable, not merely nonblank.
   A visual CHANGE carries two extra proofs before you claim it: a
   byte/pixel diff against the pre-change baseline on the production route
   (static checks and re-anchored assertions all pass on a no-op — a
   palette pass once shipped "verified" while the production frame was
   byte-identical), and an unprimed
   [screenshot-critique](../../visual/screenshot-critique/SKILL.md) — at the
   user's reported framing when the pass answers their visual bug report —
   before declaring it fixed; the implementer's eyes are primed by the fix
   and repeatedly pass what fresh eyes catch.
   Never weaken an existing default gate or repin a failing contract without
   proving the old contract is wrong.
5. **Review the change list and clean up after every pass, before committing.**
   Read `git status`/`git diff --stat` line by line and account for every path:
   one-off probes, shot scripts, scratch files, `nohup.out`, ad-hoc screenshot
   dirs, and disposable SPIKE/debug notes never enter a commit — scratch stays
   out of the tree. Preserve frozen references, fixtures, and research evidence
   in the project's reference or spec assets area. A file without a durable
   purpose does not ship.
   Delegated agents leak these; the integrating reviewer re-checks the merged
   tree with the same eye.

   Sizing the pass — measuring what it cost and reworking it when the line count
   is out of proportion to the behaviour it delivers — belongs to the shape pass
   in step 6, under [refactor-clean](../refactor-clean/SKILL.md).
6. Run [review](../review/SKILL.md) at the end of every pass, before committing.
   It sequences the three closeout lenses — refactor-clean on the shape,
   code-review on the settled diff, write-docs on what the change touched — and
   you apply the fixes from all three. Long specs are where sediment compounds,
   so hold the shape pass to this pass's own output: dev-only shims, duplicated
   concepts, parallel abstractions, and compatibility wrappers it introduced
   collapse into the clean contract with one owner, so the code reads as designed
   today, not tacked on. Last, run
   [audit-decisions](../audit-decisions/SKILL.md) on the cleaned pass — a pure
   audit that appends every decision made where the spec was silent (your own,
   and each delegated subagent's when integrating) to the spec's decisions
   ledger (`specs/<feature>/decisions.md`) with verdicts, changing no code
   itself. You act on its findings: redo unsound decisions from the corrected
   ones it records, adopt the recorded provisional call on any user-only entry — the
   audit never blocks the run. Rerun the affected checks, then commit only the
   focused changes from this pass.
7. Update the spec README's "Next Agent Prompt": status, completed work, next
   pickup point, blockers, changed gates, and any architecture decision that
   changed the plan.
8. Run a **maintenance checkpoint** as part of the loop, not as endgame cleanup.
   Trigger it after a red pass, after every two or three slice commits, after a
   rebase/resume/compaction, before changing feature areas, when evidence
   invalidates the plan, when the handoff contradicts the TODO/graph, when the
   decisions ledger's entries cluster around one slice, or when the
   active prompt grows hard to scan. Long specs bloat repeatedly; cleanup is a
   normal pass, not a cosmetic chore.

   A checkpoint cleans both plan and code before more feature work:
   - Shorten the README handoff to one current pickup, one priority order, and
     one compact evidence ledger; move play-by-play into slice files or assets.
   - Correct completed/rejected/next markers; delete stale TODOs, stale
     acceptance claims, duplicated status sections, and obsolete prompts.
   - Re-rank remaining work so the next red/high-risk contract is explicit, and
     demote branches that are not on that path.
   - Reslice any still-red, overloaded, or foggy slice into smaller independently
     verifiable passes before implementing past it.
   - Delete or collapse scaffolding from earlier passes when it no longer owns a
     real contract.
   - If the work feels off-track, ask a fresh review/subagent to audit spec shape
     and priority order, then apply the fixes.

   Commit the checkpoint as its own focused pass when cleanup changes the spec,
   code shape, or handoff enough that future agents would otherwise inherit stale
   context. It is done only when a fresh agent can read the README handoff, TODO,
   and slice graph and choose the same next action without conversation history.
9. **Continue.** If any slice or global TODO is still open, go straight back to
   step 1 for the next one — same session, no pause for acknowledgement. Keep
   looping until every TODO is closed.
10. **Run [review](../review/SKILL.md) once more over the whole spec.** The
   per-pass reviews each judged one slice against the code as it stood then; this
   one judges the finished feature. Scope it to the spec's full diff, not the last
   pass — that is the only scope where duplication spread across slices, a shape
   that only reads wrong once every slice has landed, and docs that describe
   increments instead of the feature are visible at all. Apply the fixes, rerun
   the gates, commit.
11. **Consolidate the decisions ledger, then close.** When the last slice lands, the
   `decisions.md` you've been appending to per pass is build-order sediment: entries
   banked early carry "provisional — revisit in slice N" verdicts that a later pass
   silently resolved, entries a later pass reverted still sit there, and the same
   decision may appear twice. The per-pass rule "banked is settled, never re-listed"
   is what let that drift accumulate — so the final consolidation is its deliberate
   exception. Before archiving, **rewrite `decisions.md` from scratch** as the final

From dzhng/skills, MIT.

More from dzhng/skills