incremental-implementation

Incremental Implementation

Build in thin vertical slices: implement one piece, test it, verify it, commit, then expand. Each increment leaves the system in a working, testable state. This is the execution discipline that turns "implement the whole feature" from one large, unverifiable leap into a sequence of small, individually-checked steps.

When to use

Any multi-file change; building a feature from a task breakdown; refactoring existing code; any time about to write more than ~100 lines before running anything.

Skip it for: a single-file, single-function change where the scope is already minimal.

The increment cycle

Implement ──→ Test ──→ Verify ──→ Commit ──→ next slice

1. Implement the smallest complete piece of functionality.
2. Test — run the suite, or write a test if none covers this yet.
3. Verify the slice works (tests pass, build succeeds, or a manual check for something not yet automatable).
4. Commit with a descriptive message covering this slice only.
5. Move to the next slice — carry forward, don't restart from scratch.

Slicing strategies

Vertical (preferred) — one complete path through the whole stack per slice:

Slice 1: create a task (DB + API + minimal UI) → user can create via the UI
Slice 2: list tasks (query + API + UI)         → user can see their tasks
Slice 3: edit a task (update + API + UI)       → user can modify tasks
Slice 4: delete a task (+ confirmation)        → full CRUD complete

Each slice delivers working, end-to-end functionality — never "all of the database layer, then all of the API, then all of the UI," which leaves nothing demonstrably working until the very last slice lands.

Contract-first — when backend and frontend need to proceed in parallel: define the API contract (types/interfaces/OpenAPI) first, then implement backend against it and frontend against mock data matching it, then integrate.

Risk-first — tackle the riskiest or most uncertain piece first (e.g. prove a WebSocket connection works) so a fundamental blocker surfaces before slices 2 and 3 are built on top of an unproven foundation.