Update to Build

{
  "name": "incremental-implementation",
  "description": "Delivers changes incrementally in thin, verifiable slices. Use when implementing any feature or change that touches more than one file, or when picking up the next task from a plan. Use when rolling a change out behind a feature flag, when you're about to write a large amount of code at once, or when a task feels too big to land in one step.",
  "included_files": [],
  "skill_md_contents": "---\nname: incremental-implementation\ndescription: Delivers changes incrementally in thin, verifiable slices. Use when implementing any feature or change that touches more than one file, or when picking up the next task from a plan. Use when rolling a change out behind a feature flag, when you're about to write a large amount of code at once, or when a task feels too big to land in one step.\ndisable-model-invocation: true\n---\n\n# Incremental Implementation\n\n## Overview\n\nBuild 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.\n\n## When to Use\n\n- Implementing any multi-file change\n- Building a new feature from a task breakdown\n- Refactoring existing code\n- Any time you're tempted to write more than ~100 lines before testing\n\n**When NOT to use:** Single-file, single-function changes where the scope is already minimal.\n\n## The Increment Cycle\n\n```\n┌──────────────────────────────────────┐\n│                                      │\n│   Implement ──→ Test ──→ Verify ──┐  │\n│       ▲                           │  │\n│       └───── Commit ◄─────────────┘  │\n│              │                       │\n│              ▼                       │\n│          Next slice                  │\n│                                      │\n└──────────────────────────────────────┘\n```\n\nFor each slice:\n\n1. **Implement** the smallest complete piece of functionality\n2. **Test** — run the test suite (or write a test if none exists)\n3. **Verify** — confirm the slice works as expected (tests pass, build succeeds, manual check)\n4. **Commit** -- save your progress with a descriptive message (see `git-workflow-and-versioning` for atomic commit guidance)\n5. **Move to the next slice** — carry forward, don't restart\n\n## Slicing Strategies\n\n### Vertical Slices (Preferred)\n\nBuild one complete path through the stack:\n\n```\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\n```\n\nEach slice delivers working end-to-end functionality.\n\n### Contract-First Slicing\n\nWhen backend and frontend need to develop in parallel:\n\n```\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\n```\n\n### Risk-First Slicing\n\nTackle the riskiest or most uncertain piece first:\n\n```\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\n```\n\nIf Slice 1 fails, you discover it before investing in Slices 2 and 3.\n\n## Implementation Rules\n\n### Rule 0: Simplicity First\n\nBefore writing any code, ask: \"What is the simplest thing that could work?\"\n\nAfter writing code, review it against these checks:\n- Can this be done in fewer lines?\n- Are these abstractions earning their complexity?\n- Would a staff engineer look at this and say \"why didn't you just...\"?\n- Am I building for hypothetical future requirements, or the current task?\n\n```\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\n```\n\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.\n\n### Rule 0.5: Scope Discipline\n\nTouch only what the task requires.\n\nDo NOT:\n- \"Clean up\" code adjacent to your change\n- Refactor imports in files you're not modifying\n- Remove comments you don't fully understand\n- Add features not in the spec because they \"seem useful\"\n- Modernize syntax in files you're only reading\n\nIf you notice something worth improving outside your task scope, note it — don't fix it:\n\n```\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?\n```\n\n### Rule 1: One Thing at a Time\n\nEach increment changes one logical thing. Don't mix concerns:\n\n**Bad:** One commit that adds a new component, refactors an existing one, and updates the build config.\n\n**Good:** Three separate commits — one for each change.\n\n### Rule 2: Keep It Compilable\n\nAfter each increment, the project must build and existing tests must pass. Don't leave the codebase in a broken state between slices.\n\n### Rule 3: Feature Flags for Incomplete Features\n\nIf a feature isn't ready for users but you need to merge increments:\n\n```typescript\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}\n```\n\nThis lets you merge small increments to the main branch without exposing incomplete work.\n\n### Rule 4: Safe Defaults\n\nNew code should default to safe, conservative behavior:\n\n```typescript\n// Safe: disabled by default, opt-in\nexport function createTask(data: TaskInput, options?: { notify?: boolean }) {\n  const shouldNotify = options?.notify ?? false;\n  // ...\n}\n```\n\n### Rule 5: Rollback-Friendly\n\nEach increment should be independently revertable:\n\n- Additive changes (new files, new functions) are easy to revert\n- Modifications to existing code should be minimal and focused\n- Database migrations should have corresponding rollback migrations\n- Avoid deleting something in one commit and replacing it in the same commit — separate them\n\n## Working with Agents\n\nWhen directing an agent to implement incrementally:\n\n```\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.\"\n```\n\nBe explicit about what's in scope and what's NOT in scope for each increment.\n\n## Increment Checklist\n\nAfter each increment, verify with the repository's own commands (see the test-driven-development skill's Discover the Stack First section):\n\n- [ ] The change does one thing and does it completely\n- [ ] All existing tests still pass (the repository's test command: `npm test`, `./gradlew test`, `pytest`, ...)\n- [ ] The build succeeds (the repository's build command)\n- [ ] Type checking passes, where the stack has one (`npx tsc --noEmit`, `mypy`, ...)\n- [ ] Linting passes (the repository's lint command)\n- [ ] The new functionality works as expected\n- [ ] The change is committed with a descriptive message\n\n**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\n## Common Rationalizations\n\n| Rationalization | Reality |\n|---|---|\n| \"I'll test it all at the end\" | Bugs compound. A bug in Slice 1 makes Slices 2-5 wrong. Test each slice. |\n| \"It's faster to do it all at once\" | It *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\" | Small commits are free. Large commits hide bugs and make rollbacks painful. |\n| \"I'll add the feature flag later\" | If the feature isn't complete, it shouldn't be user-visible. Add the flag now. |\n| \"This refactor is small enough to include\" | Refactors mixed with features make both harder to review and debug. Separate them. |\n| \"Let me run the build command again just to be sure\" | After 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\n## Red Flags\n\n- More than 100 lines of code written without running tests\n- Multiple unrelated changes in a single increment\n- \"Let me just quickly add this too\" scope expansion\n- Skipping the test/verify step to move faster\n- Build or tests broken between increments\n- Large uncommitted changes accumulating\n- Building abstractions before the third use case demands it\n- Touching files outside the task scope \"while I'm here\"\n- Creating new utility files for one-time operations\n- Running the same build/test command twice in a row without any intervening code change\n\n## Verification\n\nAfter completing all increments for a task:\n\n- [ ] Each increment was individually tested and committed\n- [ ] The full test suite passes\n- [ ] The build is clean\n- [ ] The feature works end-to-end as specified\n- [ ] No uncommitted changes remain\n\n## See Also\n\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`.\n"
}