incremental-implementation

Enforce thin vertical slice implementation for multi-file code changes.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the overwhelming pain of large, multi-file coding tasks that lead to hundreds of lines of untested code, hard-to-find bugs, and wasted effort when work goes off the rails mid-implementation.

Core Features & Use Cases

  • Guides you to break work into thin vertical slices that deliver end-to-end functional value in each small increment
  • Provides three proven slicing strategies (vertical, contract-first, risk-first) for different development scenarios
  • Includes strict guardrails for scope discipline, rollback-friendly commits, and safe handling of incomplete features via feature flags
  • Use Case: When building a new task management CRUD feature, first implement only the "create task" slice (database + API + basic UI), test it fully, commit it, then move to the "list tasks" slice instead of building the entire feature in one go.

Quick Start

Ask the AI to implement the next small vertical slice of your current task, clearly define the exact scope for this increment, and request that it runs all tests and builds the project successfully before moving 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 break a large multi-file feature into smaller testable code increments?

Break large multi-file features into small testable code increments by implementing thin vertical slices that deliver end-to-end functional value. This approach eliminates risks of writing large untested code blocks by ensuring each increment is fully tested before moving forward.

What is vertical slicing in software engineering and when should I use it?

Vertical slicing in software engineering is an incremental development strategy that builds end-to-end functional value in small increments. Use it for new feature development, cross-file code modifications, and large refactoring efforts where work scope exceeds 100 lines of code.

How do I manage scope discipline when implementing cross-file code modifications?

Manage scope discipline during cross-file code modifications by enforcing strict slicing strategies like vertical, contract-first, or risk-first slicing. This ensures rollback-friendly commits and prevents uncontrolled code expansion across multiple files.

Can I use feature flags for incomplete work during incremental development?

Yes, you can use feature flags to safely handle incomplete features during incremental development. This practice allows you to merge rollback-friendly commits without exposing unfinished vertical slices to end users.

What is the best way to handle large refactoring tasks without creating hard-to-find bugs?

The best way to handle large refactoring tasks without creating hard-to-find bugs is to break work into thin vertical slices. Test each slice fully, commit it, then move to the next slice to maintain strict scope discipline and avoid wasted effort.

Why does writing hundreds of lines of code before testing lead to wasted effort?

Writing hundreds of lines of code before testing leads to wasted effort because large untested code blocks obscure hard-to-find bugs and make it difficult to roll back when implementation goes off the rails mid-task. Incremental testing prevents this.