incremental-implementation

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

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

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 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 so the codebase never stays broken. - Slicing Strategies: Choose vertical slices, contract-first slicing for parallel backend/frontend work, or risk-first slicing to prove uncertain pieces early. - Implementation Rules: Simplicity first, 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, deliver create, list, edit, and delete as four separate end-to-end slices, each tested and committed, instead of one 500-line change. ## Quick Start Ask the agent to implement the next task from your plan incrementally, starting with only the database schema and API endpoint, then running the repository's test and build commands 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, 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 working and testable, unlike horizontal layers that deliver nothing usable until the end.

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 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 exceeding 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. Testing each increment isolates failures to a small, recent change, making diagnosis and rollback fast instead of searching hundreds of changed lines.