incremental-implementation

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

Updated Jul 1, 2026
One-click install
npx skills add https://github.com/raishoemi/traffic-sim-v2 --skill incremental-implementation-raishoemi
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/raishoemi/traffic-sim-v2/tree/main/.github/skills/incremental-implementation
Command: npx skills add https://github.com/raishoemi/traffic-sim-v2 --skill incremental-implementation-raishoemi

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 project 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: Touch only what the task requires, avoid premature abstraction, use feature flags for incomplete work, and keep each commit independently revertable. - Use Case: When building a task management feature, implement create-task end to end first (DB, API, UI), verify tests pass, commit, then add list, edit, and delete as separate slices. ## Quick Start Ask the agent to implement the next task from the plan incrementally, starting with just the database schema and API endpoint, running tests and the build before committing each 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 all layers finish.

When should I not use incremental implementation?

Skip it 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 new code.

How do feature flags help with incomplete features?

Feature flags let you merge small increments to the main branch without exposing unfinished work to users. Gate the new code behind an environment variable that defaults to off, then enable it when the feature is complete.

Why should each increment be a separate commit?

Small commits isolate bugs to a known set of changed lines and make rollbacks safe. Mixing a feature, a refactor, and a config change in one commit makes all three harder to review, debug, and revert independently.