incremental-implementation

Implements multi-file code changes in thin, tested, committed vertical slices.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features and multi-file changes often get written in one giant pass, leaving bugs hidden among hundreds of lines and the codebase broken between edits. This Skill enforces an implement-test-verify-commit cycle so every change lands as a small, working, revertable increment. ## Core Features & Use Cases - Thin Vertical Slicing: Breaks features into end-to-end slices (e.g., create, list, edit, delete) where each slice leaves the system working and testable. - Slicing Strategies: Provides contract-first slicing for parallel backend/frontend work and risk-first slicing to prove uncertain pieces early. - Scope and Simplicity Discipline: Enforces one logical change per commit, feature flags for incomplete work, safe defaults, and rollback-friendly changes. - Use Case: When building a task management feature, implement the database schema and API endpoint first, run the test suite, commit, then add the UI in the next increment instead of writing everything at once. ## Quick Start Implement the next task from my plan incrementally, starting with just the backend slice, and run the test and build commands after each step.

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 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.

When should I use feature flags for incomplete work?▼

Use feature flags whenever a feature is not ready for users but you need to merge increments to the main branch. Gate the new code behind an environment variable or config flag so incomplete work stays hidden while small commits keep landing.

When is incremental implementation not needed?▼

Skip it for single-file, single-function changes where the scope is already minimal. The discipline targets multi-file changes, new features from task breakdowns, and any work where you would write more than roughly 100 lines before testing.

Why should refactors be separate commits from features?▼

Mixing refactors with features makes both harder to review and debug, and complicates rollbacks. Each increment should change one logical thing, so land the refactor and the feature as separate commits.