incremental-implementation

Break feature work into vertical slices with implement-test-verify-commit loops.

Updated Mar 8, 2026
One-click install
npx skills add https://github.com/luyzkk/Anti-Vibe-Coding --skill incremental-implementation-luyzkk
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/luyzkk/Anti-Vibe-Coding/tree/main/skills/incremental-implementation
Command: npx skills add https://github.com/luyzkk/Anti-Vibe-Coding --skill incremental-implementation-luyzkk

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Prevents big-bang delivery and late integration failures by forcing each change to be implemented, tested, verified, and committed as a working increment.

Core Features & Use Cases

  • Increment cycle discipline: Implement the smallest complete piece, then immediately run tests and verify behavior before moving on.
  • Vertical slice planning: Build end-to-end user value per slice (e.g., CRUD steps) so earlier work remains demonstrably usable.
  • Slicing strategies for parallel work: Use contract-first or risk-first slicing when frontend/backed or uncertain components need early validation.
  • Rules for safety and scope control: Keep changes focused, maintain a compilable/testable codebase between slices, and use feature flags for work-in-progress.

Use cases: implementing any multi-file feature, refactoring with confidence, developing new capabilities from a breakdown, and preventing regressions when an agent or team is iterating on multiple components.

Quick Start

Ask the AI to implement your feature as vertical slices: start with the smallest end-to-end path, add or update tests for that slice, verify build and test success, commit, then proceed to the next 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 multi-file features without causing late integration failures?

Vertical slicing delivers end-to-end user value per slice, such as completing CRUD steps, so earlier work remains demonstrably usable. This approach ensures each increment is a working, functional piece of the application rather than an isolated technical component.

How do I use feature flags for incremental delivery and refactoring safety?

Feature flags provide refactoring safety during incremental delivery by keeping work-in-progress hidden while maintaining a compilable codebase. They allow you to merge incomplete features safely and isolate new capabilities until they are fully verified and ready for release.

What is the best way to plan slices for parallel frontend and backend development?

For parallel frontend and backend development, use contract-first slicing to validate components early. This strategy establishes interface contracts upfront, allowing separate teams to implement their respective slices while ensuring integration risk is minimized through early validation.

When should I use risk-first slicing during incremental feature development?

Use risk-first slicing during incremental feature development when dealing with uncertain components that need early validation. This strategy prioritizes implementing the riskiest parts of the system first to surface potential architectural or integration issues before committing to broader implementation.