incremental-implementation

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

Updated May 5, 2026
One-click install
npx skills add https://github.com/nikegeorgian-stack/otgruzka-tovara --skill incremental-implementation-nikegeorgian-stack
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/nikegeorgian-stack/otgruzka-tovara/tree/main/.cursor/skills/incremental-implementation
Command: npx skills add https://github.com/nikegeorgian-stack/otgruzka-tovara --skill incremental-implementation-nikegeorgian-stack

SYSTEM DOCUMENTATION & REQUIREMENTS

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, and commit one thin slice at a time, keeping the build green between steps. - 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: Enforces one logical change per commit, feature flags for incomplete work, safe defaults, and rollback-friendly changes. - Use Case: When adding full CRUD for a task feature, build create, list, edit, and delete as four separate tested slices instead of one 500-line change. ## Quick Start Ask the AI to implement the next task incrementally, starting with only the database schema and API endpoint, running the test and build commands after each slice before moving to 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 basic 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 not use incremental implementation?▼

Skip it for single-file, single-function changes where the scope is already minimal. The overhead of slicing and per-increment verification adds no value when the entire change is small enough to verify in one step.

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 refactors be separate commits from features?▼

Mixing refactors with feature changes makes both harder to review and debug, and complicates rollbacks. Separate commits keep each change focused on one logical thing so a bug can be traced to a specific increment.