incremental-implementation

Implements multi-file features in thin vertical slices using a test-first RED-GREEN-REFACTOR cycle.

Updated Jun 13, 2026
One-click install
npx skills add https://github.com/22Teikk/22Teikk-Agent-Skills-Hub --skill incremental-implementation-22teikk
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/22Teikk/22Teikk-Agent-Skills-Hub/tree/main/core/skills/incremental-implementation
Command: npx skills add https://github.com/22Teikk/22Teikk-Agent-Skills-Hub --skill incremental-implementation-22teikk

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve? Large features implemented in one pass produce unreviewable commits, hidden bugs, and broken builds. This Skill enforces incremental delivery so every change leaves the codebase in a working, tested, committable state. ## Core Features & Use Cases - Thin Vertical Slices: Breaks features into end-to-end slices (DB + API + UI) that each deliver working functionality, with contract-first and risk-first slicing strategies. - Test-First Increment Cycle: Enforces RED (write failing test, observe it fail) → GREEN (minimal code) → REFACTOR → Verify → Commit for every slice. - Session Resume via Task Index: Uses .teikk/tasks/todo.md with a **Current task:** pointer for O(1) context recovery, plus phase-exit gates (traceability, build, full test suite) via shell scripts. - Use Case: When implementing a multi-file Android feature, the agent resumes from todo.md, writes a failing test for the current slice, implements the minimum code, runs the task test class plus assembleDebug, commits, and advances the pointer. ## Quick Start Ask the agent to implement the next task from the plan incrementally, writing the failing test first and committing each verified slice before moving on.

Frequently Asked Questions about incremental-implementation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a large feature incrementally?▼

Break the feature into thin vertical slices where each slice delivers working end-to-end functionality. For each slice, write a failing test first, implement the minimum code to pass it, verify the build, and commit before moving to the next slice.

How to resume a coding task after the AI context is cleared?▼

Read the todo.md task index first and follow its Current task pointer instead of re-reading the full plan. Open only that task's section in plan.md, flip its checkbox to in-progress, and continue the increment cycle from there.

What is vertical slice development versus horizontal layering?▼

Vertical slicing builds one complete path through the stack (database, API, UI) per increment, so every slice is testable end-to-end. Horizontal layering builds all of one layer first, leaving nothing demonstrable until the final layer lands.

When should I not use incremental implementation?▼

Skip it for single-file, single-function changes where the scope is already minimal. The per-increment test and commit overhead adds no value when the entire change fits in one small, obvious step.

Why must the test be observed failing before writing code?▼

A test never seen failing may assert the wrong thing, pass on old behavior, or not run at all. Watching it fail confirms the test is an independent check rather than a transcript of code already written.

How do feature flags help with incremental delivery?▼

Feature flags let you merge incomplete increments to the main branch without exposing unfinished work to users. New behavior stays disabled by default and is enabled only when the feature is complete.