incremental-implementation

Implements multi-file features in thin vertical slices with per-slice testing and commits.

2|Updated Jul 11, 2026
One-click install
npx skills add https://github.com/MoofonLi/dev-ready --skill incremental-implementation-moofonli
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/MoofonLi/dev-ready/tree/main/src/dev_ready/templates/claude/skills/incremental-implementation
Command: npx skills add https://github.com/MoofonLi/dev-ready --skill incremental-implementation-moofonli

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 painful rollbacks. This Skill enforces an increment cycle — implement, test, verify, commit — so every change lands in a working, testable state. ## Core Features & Use Cases - Slicing Strategies: Choose vertical slices, contract-first slicing for parallel backend/frontend work, or risk-first slicing to prove the riskiest piece early. - Implementation Rules: Enforces simplicity-first design, scope discipline, 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 create-task end-to-end (DB + API + UI) as slice one, verify tests pass, commit, then add list, edit, and delete as separate verified slices. ## Quick Start Ask the agent to implement the feature incrementally, starting with just the database schema and API endpoint, running the repository's test and build commands after each slice before moving to the UI.

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 result, 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 when 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 so incomplete work stays hidden while small increments merge safely.

When is incremental implementation not needed?

Skip it for single-file, single-function changes where the scope is already minimal. The overhead of slicing only pays off when a change touches multiple files or exceeds roughly 100 lines before testing.

Why do bugs compound when testing only at the end?

A bug introduced in an early slice silently corrupts every slice built on top of it, making the root cause hard to locate among hundreds of changed lines. Testing each slice isolates failures to the most recent change.