incremental-implementation

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

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features implemented in one pass produce unreviewable diffs, hidden bugs, and broken builds. This Skill enforces a disciplined increment cycle so every change lands in a working, tested, and committed state. ## Core Features & Use Cases - Increment Cycle: Implement, test, verify, commit, then move to the next slice so the codebase never sits in a broken state. - Slicing Strategies: Choose vertical slices, contract-first slicing for parallel backend/frontend work, or risk-first slicing to validate the riskiest piece 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 create, list, edit, and delete as four separate tested slices instead of one 500-line changeset. ## Quick Start Ask the AI to implement the feature incrementally, starting with only 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 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 passes, 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.

When should I not use incremental implementation?▼

Skip this approach 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 exceeds roughly one hundred lines of code.

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 configuration check that defaults to disabled, then enable it when the feature is complete.

Why should each increment be a separate commit?▼

Small commits isolate bugs to a specific slice and make rollbacks painless. Mixing a feature, a refactor, and a config change in one commit makes all three harder to review, debug, and revert independently.