incremental-implementation

Implements multi-file code changes in thin vertical slices with test and commit cycles.

9|Updated Jul 8, 2026
One-click install
npx skills add https://github.com/jerrylin96/dotgemini --skill incremental-implementation-jerrylin96
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/jerrylin96/dotgemini/tree/main/skills/incremental-implementation
Command: npx skills add https://github.com/jerrylin96/dotgemini --skill incremental-implementation-jerrylin96

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features implemented in a single pass produce unreviewable commits, hidden bugs, and broken intermediate states. This Skill enforces an implement-test-verify-commit cycle so every increment leaves the codebase in a working, testable state. ## Core Features & Use Cases - Increment Cycle Discipline: Guides each slice through implement, test, verify, and commit steps before moving to the next piece of functionality. - Four Slicing Strategies: Provides vertical slicing, contract-first slicing, risk-first slicing, and sequential subagent slicing for different project shapes. - Subagent Orchestration Rules: Defines workspace modes, single-writer constraints, context compaction blocks, scratchpad handoffs, and failure circuit breakers for delegating slices to subagents. - 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 verified slices. ## Quick Start Ask the agent to implement the feature incrementally using thin vertical slices, testing and committing after 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 tests, verify the result, commit with a descriptive message, then move to the next slice.

What is vertical slicing in software development?

Vertical slicing builds one complete path through the entire 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 contract-first slicing?

Use contract-first slicing when backend and frontend must develop in parallel. Define the API contract first, then implement backend against the contract and frontend against mock data, and finally integrate and test end-to-end.

When should I not use incremental implementation?

Skip this approach for single-file, single-function changes where the scope is already minimal. The implement-test-verify-commit cycle adds overhead that provides no benefit when the change is inherently atomic.

How do subagents handle sequential implementation slices?

Each slice is delegated to a fresh subagent using Workspace inherit mode so commits land on the shared feature branch. Only one writer subagent runs at a time, and the parent verifies each slice committed cleanly before dispatching the next.

What happens if an implementation slice fails verification?

A failure circuit breaker halts execution immediately when a slice fails verification, cannot commit, or alters a contract unexpectedly. The next slice is not launched and the issue returns to the parent agent or user for triage.