incremental-implementation

Implements code changes in thin, tested, individually committed vertical slices.

1|Updated Sep 4, 2026
One-click install
npx skills add https://github.com/SanHsien/agent-skills --skill incremental-implementation-sanhsien
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/SanHsien/agent-skills/tree/main/skills/incremental-implementation
Command: npx skills add https://github.com/SanHsien/agent-skills --skill incremental-implementation-sanhsien

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features implemented in one pass produce bugs that are hard to locate, reviews that are hard to read, and rollbacks that are painful. This Skill enforces a disciplined increment cycle so every change lands as a small, tested, working slice. ## Core Features & Use Cases - Increment Cycle: A repeatable Implement → Test → Verify → Commit loop that keeps the codebase buildable after every slice. - Slicing Strategies: Vertical slices, contract-first slicing for parallel backend/frontend work, and risk-first slicing to surface uncertainty early. - Scope and Simplicity Rules: Guardrails against scope creep, premature abstraction, mixed-concern commits, and unflagged incomplete features. - Use Case: When building a task management feature, implement create-task end-to-end first (DB + API + UI), verify tests pass and commit, then move to list, edit, and delete as separate slices. ## Quick Start Ask the agent to implement the next task from the plan as one thin slice, starting with only the database schema and API endpoint, then run the repository's test and build commands before committing.

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, implement the smallest complete piece, run the test suite, verify the build, commit with a descriptive message, then move to the next slice.

What is vertical slice development in software engineering?

Vertical slicing builds one complete path through the entire stack per increment, such as database plus API plus UI for a single operation. Each slice leaves the system in a working, testable state rather than completing one layer at a time.

How do I merge incomplete features without exposing them to users?

Use feature flags to gate work-in-progress code, defaulting to disabled and opt-in. This lets you merge small increments to the main branch while keeping unfinished functionality invisible to users.

When should I not use incremental implementation?

Skip it for single-file, single-function changes where the scope is already minimal. The increment cycle adds overhead that only pays off when a change touches multiple files or feels too big to land in one step.

Why should each code increment be committed separately?

Small commits keep each change independently revertable and make bugs easy to locate. Mixing a feature, a refactor, and config changes in one commit makes review harder and rollbacks painful.