addy-incremental-implementation

Implements multi-file features in thin vertical slices with per-slice testing and commits.

Updated Aug 21, 2026
One-click install
npx skills add https://github.com/TylerSimons1127/vibe --skill addy-incremental-implementation-tylersimons1127
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: addy-incremental-implementation
Source: https://github.com/TylerSimons1127/vibe/tree/main/skills/addy-incremental-implementation
Command: npx skills add https://github.com/TylerSimons1127/vibe --skill addy-incremental-implementation-tylersimons1127

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Large features implemented in one pass produce bugs that are hard to locate, broken builds between steps, and painful rollbacks. This Skill enforces an incremental implementation discipline so every change lands in small, tested, independently revertable slices. ## Core Features & Use Cases - Increment Cycle: A repeatable Implement → Test → Verify → Commit loop that keeps the codebase compilable and tests green after every slice. - Slicing Strategies: Vertical slices, contract-first slicing for parallel backend/frontend work, and risk-first slicing to prove uncertain pieces early. - Implementation Rules: Simplicity-first checks, scope discipline, feature flags for incomplete work, safe defaults, and rollback-friendly commits. - Use Case: When building a task management feature, implement create-task end-to-end (DB + API + UI) as slice one, verify tests pass, commit, then add list, edit, and delete as separate slices instead of writing all CRUD at once. ## Quick Start Ask the agent to implement the feature incrementally, starting with just the database schema and API endpoint, running the test and build commands after each slice before moving to the UI.

Frequently Asked Questions about addy-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 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 not use incremental implementation?▼

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 whole change is small and atomic.

How do feature flags help with incremental delivery?▼

Feature flags let you merge small increments of an unfinished feature to the main branch without exposing incomplete work to users. Gate the new UI or behavior behind an environment variable that defaults to disabled and opt-in.

Why do bugs compound when testing only at the end?▼

A bug introduced in an early slice silently corrupts every slice built on top of it, making the root cause hard to locate among hundreds of changed lines. Testing each slice isolates failures to the most recent increment.