incremental-implementation

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

Updated Aug 15, 2026
One-click install
npx skills add https://github.com/jacksonlee-tw/mystock-vue --skill incremental-implementation-jacksonlee-tw
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/jacksonlee-tw/mystock-vue/tree/main/mystock-vue/.agents/skills/incremental-implementation
Command: npx skills add https://github.com/jacksonlee-tw/mystock-vue --skill incremental-implementation-jacksonlee-tw

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features implemented in one pass produce bugs that are hard to locate, reviews that are hard to read, and rollbacks that are painful. This Skill enforces a disciplined increment cycle — implement, test, verify, commit — so every change lands in small, working, revertable slices. ## Core Features & Use Cases - Increment Cycle Discipline: Each slice is implemented, tested, verified, and committed before moving to the next, keeping the codebase always buildable. - Slicing Strategies: Provides vertical slicing, contract-first slicing for parallel frontend/backend work, and risk-first slicing to surface uncertainty 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 it as four slices — create, list, edit, delete — each passing tests and committed separately, instead of one 500-line change. ## Quick Start Implement the next task from my plan incrementally, starting with just the database schema and API endpoint, and run the test suite after each slice before committing.

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 slicing in software development?▼

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 whenever 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.

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 feels too big to land in one step.

Why should refactors and features be in separate commits?▼

Mixing refactors with features makes both harder to review and debug, and complicates rollbacks. Separate commits keep each change focused on one logical thing and independently revertable.