incremental-implementation

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

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

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, testable state. ## Core Features & Use Cases - Increment Cycle: Implements one slice, then tests, verifies, and commits before moving to the next slice. - Slicing Strategies: Provides vertical, contract-first, and risk-first slicing patterns for different project shapes. - Scope and Simplicity Rules: Blocks scope creep, premature abstraction, and mixed-concern commits with explicit checklists. - Use Case: When building a task management feature, implement create, list, edit, and delete as four separate tested slices instead of one large 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 tests and the build before touching 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 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 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 100 lines of code.

How do I merge incomplete features without breaking the main branch?▼

Use feature flags that default to disabled, gating unfinished UI or logic behind an environment variable. This lets you merge small tested increments to the main branch without exposing incomplete work to users.

Why should refactors be separate commits from features?▼

Mixing refactors with feature changes makes both harder to review and debug, and complicates rollbacks. Each increment should change one logical thing so any single commit can be independently reverted.