feature-implementation

Feature Implementation

The construction step of the per-feature loop: documents become code. tasks.md is the program; this skill is the interpreter. It executes the feature's tasks in order against technical-design.md (contracts, schema, components), ui-design.md + the design manifest (screens), and the live codebase — producing working, tested, committed code that replaces the skeleton's stubs, ending developer-done: every task checked, including the final verification task. The independent check is downstream (acceptance verification); this skill never grades its own homework alone.

Seven disciplines make it rock-solid. Each targets a named failure mode of agentic implementation:

1. The program is fixed; improvisation is escalation. Implement what tasks.md says, per the design documents. Reality will sometimes beat the design — that has two paths, never a third: small and design-consistent → fix and record; anything changing a contract, schema, or acceptance criterion → escalate to the design's amendment path (see references/failure-and-escalation.md). The design documents stay true, or they change through their owner. (Kills: quietly designing around divergence.)
2. Fresh-context safety — disk is the memory. Every iteration is executable in a brand-new session: read tasks.md (checkbox state = exact position), read the designs, read the code, do one task, update state on disk, commit. No iteration depends on chat history. (Kills: context loss mid-feature; enables loop orchestration.)
3. Done-when is demonstrated, never asserted. A checkbox flips only after the task's done-when actually ran and passed — the migration applied clean, the tests passed, the flow's E2E spec passed. And the anti-fake-green rule: tests are never weakened, skipped, deleted, or edited to make them pass; a failing test means the code or the design is wrong, and each has its path (fix, or escalate). (Kills: the single most corrosive agent failure — manufacturing green.)
4. Bounded fix-loops — never thrash. Diagnose, fix, re-run — at most 3 attempts per task (per-project override: see Inputs). Exhausted → stop, leave the box unchecked, record the failure state honestly, WIP- commit, surface it. (Kills: infinite loops and desperation hacks.)
5. Scope discipline — this feature only. Touch what the tasks require. No drive-by refactors, no "while I'm here" improvements, no reformatting neighboring code. Genuine tech-debt discoveries are recorded (the feature's escalations section), never acted on. (Kills: scope creep and unreviewable diffs.)
6. Convention conformance by construction. Code follows the conventions technical-design §2 surveyed. UI realizes screens from ui-design.md/the manifest through the design system — tokens, never raw values; design.md's do/don'ts are binding — with the screenshot loop for code-native screens (bounded, per discipline 4). Boundary/lint rules run as part of every task's verification, not at the end. (Kills: convention drift and design-system forks.)
7. Git is the checkpoint mechanism. Commit per completed task — FEAT-004 T3: implement POST /auth/login contract — so every task is a recovery point, history is a readable execution log, and an orchestrator resumes from durable state. A blocked task WIP-commits, explicitly marked (FEAT-004 T4: WIP — blocked, see tasks.md note); a failing state is never committed as if green. (Kills: lost work and unrecoverable sessions.)