incremental-implementation

Implements features in thin vertical slices with test, verify, and commit cycles.

Updated May 19, 2026
One-click install
npx skills add https://github.com/richardnguyen0715/agent-sharing --skill incremental-implementation-richardnguyen0715
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/richardnguyen0715/agent-sharing/tree/main/.github/skills/incremental-implementation
Command: npx skills add https://github.com/richardnguyen0715/agent-sharing --skill incremental-implementation-richardnguyen0715

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features implemented in one pass produce bugs that are hard to locate, broken builds between steps, and commits that are painful to review or roll back. This Skill enforces a disciplined increment cycle so every change leaves the codebase in a working, testable state. ## Core Features & Use Cases - Increment Cycle: Implement, test, verify, and commit one small slice at a time before moving to the next. - Slicing Strategies: Choose vertical slices, contract-first slicing for parallel backend/frontend work, or risk-first slicing to validate the riskiest piece early. - Implementation Rules: Enforces simplicity-first design, scope discipline, compilable states, feature flags, safe defaults, and rollback-friendly commits. - Use Case: When building a task management feature, deliver create, list, edit, and delete as four separate end-to-end slices, each tested and committed independently. ## Quick Start Implement this feature incrementally, starting with just the database schema and API endpoint, then run the tests 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 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 tests, 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 working and testable, unlike horizontal slicing which completes one layer at a time.

When should I not use incremental implementation?▼

Skip it for single-file, single-function changes where the scope is already minimal. The overhead of slicing and per-increment verification adds no value when the entire change is small and atomic.

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. Gate the new code behind an environment variable or config check that defaults to disabled, then enable it when the feature is complete.

Why should each increment be committed separately?▼

Small commits isolate bugs to a specific slice, make reviews easier, and allow independent rollback of any change. Mixing unrelated changes in one commit hides the cause of failures and makes reverts painful.