implement

Implement

Turn an implementation plan into working, tested code, one thin slice at a time, keeping the build and existing tests green at every step. The bar: at any moment you could stop and the system is committable — nothing half-built, nothing red. This phase consumes the artifact from plan; it does not design the approach and does not open a PR. Decisions in the plan are settled — follow them; if one is wrong or missing, stop and surface it rather than quietly inventing a different design.

Process

1. Load the plan and review it critically. Read it end to end before touching code. If a task is ambiguous, a step is missing, or the approach looks wrong, raise it now — don't paper over a gap mid-implementation. Turn the plan's tasks into an ordered checklist of slices.
2. Load coding guidance. Read the repo's AGENTS.md when present, then read global guidance from ~/AGENTS.md or ~/.config/agents/AGENTS.md when present. Repo guidance takes precedence over global guidance. Treat these files as implementation constraints for scope, style, tests, errors, comments, and workflow; if a plan conflicts with them, stop and surface the conflict before coding.
3. Learn the repo's own commands. Read the Makefile, package.json scripts, or CI config to find the real build, typecheck, and test commands. Use those exact commands — never assume a toolchain the repo doesn't use.
4. Pick the smallest complete slice. A slice is the smallest change that is independently testable and leaves the system green — one task from the plan, often smaller. Do not start work on the default branch (main/master) without explicit consent.
5. Tracer-bullet TDD — one test ↔ one cycle. Write a single failing test for the slice's next behavior, watch it fail (red), write the minimum code to pass it (green), then refactor if needed. Never write all the tests up front, and never refactor while a test is red — get to green first. For a bug, use the Prove-It pattern: first write the reproduction test that fails because of the bug, then fix the code so it passes.
6. Verify the slice. Typecheck and run the targeted test files; confirm the slice's new test passes and no existing test regressed. The slice isn't done until the system is green again.
7. Commit the green slice. Commit a coherent, working increment (follow the repo's commit conventions). Keep the commit to this slice — don't fold in unrelated changes.
8. Next slice. Repeat 4–7 until every task in the plan is done. Hold scope: implement the plan, not adjacent improvements you notice along the way (note them for later).
9. Final verification. Run the full build and test suite once. This is implement's own green self-check, not the formal quality gate — validate independently runs the repo's full ordered gates and owns the authoritative go/no-go. Report what was built and which verifications passed. Stop here — implementation is complete; a separate workflow handles review and the PR.