incremental-implementation

Incremental Implementation

Overview

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.

Each increment ends at a user review gate, not an auto-commit. The agent presents a standard summary and waits for explicit approval before starting the next slice. Staging and committing are the user's responsibility — the agent never runs git add or git commit on its own.

When to Use

• Implementing any multi-file change
• Building a new feature from a task breakdown
• Refactoring existing code
• Any time you're tempted to write more than ~100 lines before testing

When NOT to use: Single-file, single-function changes where the scope is already minimal.

The Increment Cycle

┌───────────────────────────────────────────────────┐
│                                                   │
│  Implement ─→ Test ─→ Verify ─→ Request Review    │
│      ▲                               │            │
│      │                               ▼            │
│   Revise ◄── (changes requested) ── Gate          │
│                                      │            │
│                        (approved) ───┘            │
│                                      ▼            │
│                                  Next slice       │
│                                                   │
└───────────────────────────────────────────────────┘

For each slice:

1. Implement the smallest complete piece of functionality
2. Test — run the test suite (or write a test if none exists)
3. Verify — confirm the slice works as expected (tests pass, build succeeds, manual check)
4. Request review — present the Standard Slice Summary (below) and ask the user to confirm before moving to the next slice. Use the AskUserQuestion tool if available; otherwise ask in chat and wait for explicit confirmation. Do not stage or commit — the user handles git operations manually after approval. See git-workflow-and-versioning for the atomic-commit guidance the user should follow when committing approved slices.
5. Move to the next slice only after explicit approval — carry forward, don't restart