incremental-implementation

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

Updated Jun 8, 2026
One-click install
npx skills add https://github.com/Avistian/nba --skill incremental-implementation-avistian
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/Avistian/nba/tree/main/.cursor/skills/incremental-implementation
Command: npx skills add https://github.com/Avistian/nba --skill incremental-implementation-avistian

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features and multi-file changes often fail because too much code is written before anything is tested, making bugs hard to locate and rollbacks painful. This Skill enforces an incremental delivery discipline so every change lands in small, verified, revertable steps. ## Core Features & Use Cases - Increment Cycle: Implements one thin slice at a time, then tests, verifies, and commits before moving to the next slice. - Slicing Strategies: Provides vertical slicing, contract-first slicing, and risk-first slicing patterns for different project shapes. - Implementation Rules: Enforces simplicity-first design, scope discipline, feature flags for incomplete work, safe defaults, and rollback-friendly commits. - Use Case: When building a new CRUD feature spanning database, API, and UI, deliver it as four end-to-end slices (create, list, edit, delete), each leaving the build green and the test suite passing. ## Quick Start Ask the agent to implement the next task from your plan incrementally, starting with only the database schema and API endpoint, running tests and the build 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 one complete path through the stack. Implement the smallest piece, run tests, 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 end-to-end path through all layers, such as database, API, and UI, per increment. For example, slice one delivers task creation fully working before slice two adds task listing.

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, testing, and committing per step adds no value when the entire change is one small edit.

How do I merge unfinished features without breaking the build?▼

Use feature flags to hide incomplete work behind an opt-in environment variable or config check. This lets you merge small increments to the main branch while keeping unfinished functionality invisible to users.

Why should each commit contain only one logical change?▼

Mixing a feature, a refactor, and a config update in one commit makes bugs hard to isolate and rollbacks painful. Separate commits keep each change reviewable, independently revertable, and easier to debug when something breaks.