Build in thin vertical slices — implement one piece, test it, verify it, then expand. Avoid implementing an entire feature in one pass. Each increment should leave the system in a working, testable state. This is the execution discipline that makes large features manageable.
\nWhen NOT to use: Single-file, single-function changes where the scope is already minimal.
\n┌──────────────────────────────────────┐\n│ │\n│ Implement ──→ Test ──→ Verify ──┐ │\n│ ▲ │ │\n│ └───── Commit ◄─────────────┘ │\n│ │ │\n│ ▼ │\n│ Next slice │\n│ │\n└──────────────────────────────────────┘\nFor each slice:
\ngit-workflow-and-versioning for atomic commit guidance)Build one complete path through the stack:
\nSlice 1: Create a task (DB + API + basic UI)\n → Tests pass, user can create a task via the UI\n\nSlice 2: List tasks (query + API + UI)\n → Tests pass, user can see their tasks\n\nSlice 3: Edit a task (update + API + UI)\n → Tests pass, user can modify tasks\n\nSlice 4: Delete a task (delete + API + UI + confirmation)\n → Tests pass, full CRUD complete\nEach slice delivers working end-to-end functionality.
\nWhen backend and frontend need to develop in parallel:
\nSlice 0: Define the API contract (types, interfaces, OpenAPI spec)\nSlice 1a: Implement backend against the contract + API tests\nSlice 1b: Implement frontend against mock data matching the contract\nSlice 2: Integrate and test end-to-end\nTackle the riskiest or most uncertain piece first:
\nSlice 1: Prove the WebSocket connection works (highest risk)\nSlice 2: Build real-time task updates on the proven connection\nSlice 3: Add offline support and reconnection\nIf Slice 1 fails, you discover it before investing in Slices 2 and 3.
\nBefore writing any code, ask: \"What is the simplest thing that could work?\"
\nAfter writing code, review it against these checks:
\nSIMPLICITY CHECK:\n✗ Generic EventBus with middleware pipeline for one notification\n✓ Simple function call\n\n✗ Abstract factory pattern for two similar components\n✓ Two straightforward components with shared utilities\n\n✗ Config-driven form builder for three forms\n✓ Three form components\nThree similar lines of code is better than a premature abstraction. Implement the naive, obviously-correct version first. Optimize only after correctness is proven with tests.
\nTouch only what the task requires.
\nDo NOT:
\nIf you notice something worth improving outside your task scope, note it — don't fix it:
\nNOTICED BUT NOT TOUCHING:\n- src/utils/format.ts has an unused import (unrelated to this task)\n- The auth middleware could use better error messages (separate task)\n→ Want me to create tasks for these?\nEach increment changes one logical thing. Don't mix concerns:
\nBad: One commit that adds a new component, refactors an existing one, and updates the build config.
\nGood: Three separate commits — one for each change.
\nAfter each increment, the project must build and existing tests must pass. Don't leave the codebase in a broken state between slices.
\nIf a feature isn't ready for users but you need to merge increments:
\n// Feature flag for work-in-progress\nconst ENABLE_TASK_SHARING = process.env.FEATURE_TASK_SHARING === 'true';\n\nif (ENABLE_TASK_SHARING) {\n // New sharing UI\n}\nThis lets you merge small increments to the main branch without exposing incomplete work.
\nNew code should default to safe, conservative behavior:
\n// Safe: disabled by default, opt-in\nexport function createTask(data: TaskInput, options?: { notify?: boolean }) {\n const shouldNotify = options?.notify ?? false;\n // ...\n}\nEach increment should be independently revertable:
\nWhen directing an agent to implement incrementally:
\n\"Let's implement Task 3 from the plan.\n\nStart with just the database schema change and the API endpoint.\nDon't touch the UI yet — we'll do that in the next increment.\n\nAfter implementing, run the repository's test and build commands to\nverify nothing is broken.\"\nBe explicit about what's in scope and what's NOT in scope for each increment.
\nAfter each increment, verify with the repository's own commands (see the test-driven-development skill's Discover the Stack First section):
\nnpm test, ./gradlew test, pytest, ...)npx tsc --noEmit, mypy, ...)Note: Run each verification command after a change that could affect it. After a successful run, don't repeat the same command unless the code has changed since — re-running on unchanged code adds no information.
\n| Rationalization | \nReality | \n
|---|---|
| \"I'll test it all at the end\" | \nBugs compound. A bug in Slice 1 makes Slices 2-5 wrong. Test each slice. | \n
| \"It's faster to do it all at once\" | \nIt feels faster until something breaks and you can't find which of 500 changed lines caused it. | \n
| \"These changes are too small to commit separately\" | \nSmall commits are free. Large commits hide bugs and make rollbacks painful. | \n
| \"I'll add the feature flag later\" | \nIf the feature isn't complete, it shouldn't be user-visible. Add the flag now. | \n
| \"This refactor is small enough to include\" | \nRefactors mixed with features make both harder to review and debug. Separate them. | \n
| \"Let me run the build command again just to be sure\" | \nAfter a successful run, repeating the same command adds nothing unless the code has changed since. Run it again after subsequent edits, not as reassurance. | \n
After completing all increments for a task:
\nPer-increment verification is the local check. Before declaring a task done, apply the project-wide Definition of Done as the final gate, the standing bar every increment clears regardless of the task. See ../../references/definition-of-done.md.