Implementation

Implementation starts from closed decisions and an agent-ready SPEC.md. It keeps specification, provider backlog projection, concrete planning, implementation, review, and docs ingest as separate responsibilities.

• Use this when: the decision frontier is closed and the requested behavior is specified.
• It gives you: plan-derived worker waves, validation evidence, review findings, and durable docs closeout.
• It ends with: implemented scope, exact proof, resolved or reported blockers, and updated docs or a docs no-op.
• Wrapped phase/skills: $write-backlog, $create-plan, $implement-spec, $review-phase, optional $debugging-phase, and $docs-ingest-phase.

Starting Authority

create-spec compiles confirmed decisions before this flow begins. It asks no questions and returns readiness: agent-ready only after the provider-neutral spec is complete and retained at a stable source link. Missing decisions route upstream through spec-not-ready; implementation does not repair them by guessing.

When provider-visible delivery work is needed, write-backlog projects the spec into one capability epic and product-facing stories. It validates traceability, tracer-bullet completeness, and an acyclic blocker graph before it writes. The spec remains the authority, while backlog items remain provider projections.

Runtime Graph

Concrete Plan

create-plan translates the spec into tasks with dependencies, owned paths, required skills, validation, and shared integration owners. Files, commands, worker assignments, and execution order belong here rather than in the spec or backlog.

Worker Waves

implement-spec uses full-parallel worker waves. The parent launches every unblocked task whose write scope is disjoint from the others in that wave. Shared files receive one explicit owner, and dependent work waits for validated upstream evidence.

The parent owns wave construction, integration, shared artifacts, and final judgment. Scoped workers own implementation tasks and preserve changes outside their paths.

Flow

1. Confirm the spec reports readiness: agent-ready.
2. Run $write-backlog if the work needs provider-visible epics and stories.
3. Run $create-plan to produce the dependency graph, write scopes, and validation contract.
4. Run $implement-spec through unblocked worker waves.
5. Validate each task and the combined change at the highest useful observable seam.
6. Let $delivery-phase persist review_due and stop.
7. The operator explicitly invokes $review-phase; review returns retained review_routed and stops.
8. The operator explicitly resumes $delivery-phase. Delivery consumes the route and owns any repair, evidence-backed debugging, debt, documentation, or closeout transition. Fixes 1 and 2 return to review_due; fix 3 uses focused validation without review 4.
9. Run $docs-ingest-phase when durable knowledge changed, or record a docs no-op.

Checkpoints

Manual operation can inspect the spec, provider projection, plan, wave evidence, and review result between skills. These are operator choices rather than approval gates inside create-spec or write-backlog.

At the review gate, $delivery-phase persists review_due and stops. The operator explicitly invokes $review-phase; review returns retained review_routed and stops. The operator then explicitly resumes $delivery-phase from that retained evidence. Delivery never fires the explicit-only review skill itself.

Terminal Outcome

The final report names changed paths, worker-wave results, exact checks, browser or manual evidence, review status, docs ingest output, and remaining blockers.