incremental-implementation

Splits multi-file code changes into independently tested and verifiable implementation slices.

4|Updated Jun 19, 2026
One-click install
npx skills add https://github.com/douglance/sdlc-plugin --skill incremental-implementation-douglance
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/douglance/sdlc-plugin/tree/main/.rulesync/skills/incremental-implementation
Command: npx skills add https://github.com/douglance/sdlc-plugin --skill incremental-implementation-douglance

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large code changes written in one pass are hard to test, review, and revert. This Skill enforces a disciplined increment cycle so every slice of a feature is implemented, tested, verified, and committed before moving to the next. ## Core Features & Use Cases - Increment Cycle: A repeatable Implement → Test → Verify → Commit loop that keeps the codebase compilable and tests green after every slice. - Slicing Strategies: Vertical slices for end-to-end functionality, contract-first slicing for parallel backend/frontend work, and risk-first slicing to surface uncertainty early. - Implementation Rules: Simplicity-first checks, scope discipline, feature flags for incomplete work, safe defaults, and rollback-friendly commits. - Use Case: When building a task management feature, implement create, list, edit, and delete as four separate verified slices instead of one large unreviewable change. ## Quick Start Ask the agent to implement the next task from the plan incrementally, starting with only the database schema and API endpoint, then running the test suite and build before moving to the UI slice.

Frequently Asked Questions about incremental-implementation

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

FAQPage Schema
How do I break a large feature into smaller commits?▼

Use vertical slicing: implement one complete path through the stack per slice, such as create, then list, then edit, then delete. After each slice, run the test suite and build, verify the behavior, and commit before starting the next slice.

What is vertical slicing in software development?▼

Vertical slicing builds one complete path through all layers of the stack, such as database, API, and UI, in a single increment. Each slice delivers working end-to-end functionality that can be tested and demonstrated independently.

How do backend and frontend teams work in parallel on one feature?▼

Use contract-first slicing: define the API contract with types, interfaces, or an OpenAPI spec first. The backend implements against the contract with API tests while the frontend builds against mock data, then both integrate and test end-to-end.

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 spans multiple files or exceeds roughly 100 lines.

How do I merge unfinished features without breaking the main branch?▼

Use feature flags to gate incomplete work, defaulting new behavior to off and opt-in. This lets you merge small verified increments to the main branch without exposing unfinished functionality to users.