incremental-implementation

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

Updated May 13, 2026
One-click install
npx skills add https://github.com/sapatamuku-creator/mastersapatamuku --skill incremental-implementation-sapatamuku-creator
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/sapatamuku-creator/mastersapatamuku/tree/main/releases/v2.7/.agents/skills/incremental-implementation
Command: npx skills add https://github.com/sapatamuku-creator/mastersapatamuku --skill incremental-implementation-sapatamuku-creator

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

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 revert. This Skill enforces a disciplined increment cycle so every change lands in a working, testable state. ## Core Features & Use Cases - Increment Cycle: Implement, test, verify, commit, then move to the next slice, keeping the codebase compilable at every step. - Slicing Strategies: Choose vertical slices, contract-first slicing for parallel backend/frontend work, or risk-first slicing to prove uncertain pieces early. - Scope and Simplicity Rules: 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, deliver it as four slices (create, list, edit, delete), each tested end-to-end and committed separately instead of one 500-line change. ## Quick Start Ask the agent to implement the feature incrementally, starting with just the database schema and API endpoint, running tests and the 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 without breaking the build?▼

Break the feature into thin vertical slices where each slice delivers working end-to-end functionality. After each slice, run the test suite and build, verify the behavior, and commit before starting 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 slices land.

When is incremental implementation not needed?▼

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

Why should refactors be separate commits from features?▼

Mixing refactors with feature changes makes both harder to review and debug, since a regression cannot be attributed to one concern. Separate commits keep each change independently revertable and reviewable.