incremental-implementation

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

665|3|Updated Sep 12, 2026
One-click install
npx skills add https://github.com/rizqinrr/viserys-agent --skill incremental-implementation-rizqinrr
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/rizqinrr/viserys-agent/tree/main/skills/incremental-implementation
Command: npx skills add https://github.com/rizqinrr/viserys-agent --skill incremental-implementation-rizqinrr

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 so every change lands in small, verifiable slices that keep the codebase working at all times. ## Core Features & Use Cases - Increment Cycle: A repeatable loop of implement, test, verify, commit, then move to the next slice, with a checklist covering tests, build, type checking, and linting. - Slicing Strategies: Vertical slices for end-to-end functionality, contract-first slicing for parallel backend/frontend work, and risk-first slicing to prove the riskiest piece early. - Implementation Rules: Simplicity-first checks, scope discipline, feature flags for incomplete work, safe defaults, and rollback-friendly commits, plus anti-rationalization tables and red flags. - Use Case: When building a task management feature, deliver it as four slices (create, list, edit, delete), each tested and committed independently, instead of one 500-line change. ## Quick Start Ask the agent to implement the next task from your plan incrementally, starting with just the database and API slice, running the repository's test and build commands 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 in a working, testable state instead of 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 flag so incomplete work stays hidden while slices land continuously.

When is incremental implementation not needed?

Skip it for single-file, single-function changes where the scope is already minimal. The overhead of slicing, per-increment verification, and separate commits adds no value when the entire change is one small, obvious edit.

Why should refactors be separate commits from features?

Mixing refactors with feature changes makes both harder to review and debug, since a regression cannot be attributed to either change cleanly. Separate commits keep each increment doing one logical thing and independently revertable.