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/UlaYuga/promo-preflight --skill incremental-implementation-ulayuga
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/UlaYuga/promo-preflight/tree/main/.agents/skills/incremental-implementation
Command: npx skills add https://github.com/UlaYuga/promo-preflight --skill incremental-implementation-ulayuga

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features implemented in one pass produce untested, hard-to-review code where a single bug hides among hundreds of changed lines. This Skill enforces a disciplined increment cycle — implement, test, verify, commit — so every slice leaves the codebase in a working, testable state. ## Core Features & Use Cases - Increment Cycle: Each slice is implemented, tested against the suite, verified via build and type checks, then committed before moving on. - Slicing Strategies: Choose vertical slices (end-to-end paths through DB, API, and UI), contract-first slicing for parallel backend/frontend work, or risk-first slicing to prove the riskiest piece early. - Implementation Rules: Enforces simplicity-first design, scope discipline, one logical change per commit, feature flags for incomplete work, safe defaults, and rollback-friendly changes. - Use Case: When building a task management feature, implement create-task (DB + API + UI) as slice one with passing tests, then list, edit, and delete as separate committed slices instead of one large CRUD dump. ## Quick Start Ask the agent to implement the feature incrementally, starting with just the database schema and API endpoint, running tests and build after each slice before touching 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 one complete path through the stack. Implement the smallest piece, run the test suite, verify the build passes, commit it, 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 — 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 and per-increment verification adds no value when the entire change is trivially small.

How do feature flags help with incremental delivery?▼

Feature flags let you merge incomplete increments to the main branch without exposing unfinished work to users. Gate the new code behind an environment variable check and enable it only when the feature is complete.

Why should each code increment be committed separately?▼

Separate commits keep each change independently revertable and make bugs easy to locate. Mixing a feature, a refactor, and a config change in one commit makes review harder and rollbacks painful.