incremental-implementation

Implements feature plans one verified task at a time with thin vertical slices.

Updated Mar 9, 2026
One-click install
npx skills add https://github.com/ArMaTeC/Redball --skill incremental-implementation-armatec
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/ArMaTeC/Redball/tree/main/.devin/skills/incremental-implementation
Command: npx skills add https://github.com/ArMaTeC/Redball --skill incremental-implementation-armatec

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large feature implementations often fail because too many changes are batched together, making bugs hard to isolate and diffs impossible to review. This Skill enforces a disciplined one-task-at-a-time workflow so every change is small, verified, and reversible. ## Core Features & Use Cases - Single-Task Focus: Picks exactly one task from the plan, re-reads its acceptance criterion, and implements only the minimal change required. - Thin Vertical Slices: Each task produces working end-to-end code, using feature flags for partially complete functionality. - Verify-Before-Next Discipline: Runs type checks, tests, and regression checks before moving on, with a structured implementation log and per-task commits. - Use Case: You have a multi-task feature plan for a web app. Invoke this Skill to execute each task sequentially, producing small reviewable commits and a complete implementation log instead of one risky mega-diff. ## Quick Start Use the incremental-implementation skill to execute the next incomplete task in my feature plan, verify it, and commit before continuing.

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 plan without breaking existing code?▼

Break the plan into dependency-ordered tasks and implement one at a time, verifying each with type checks and tests before proceeding. Keep each diff under roughly 200 lines and commit after every verified task so regressions are easy to isolate.

What is a thin vertical slice in software development?▼

A thin vertical slice implements a small piece of functionality end-to-end across all layers, such as the type definition, API endpoint, and UI, rather than building one full layer at a time. Each slice works on its own even if the overall feature is incomplete.

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

Use a feature flag pattern: wrap the new code path in a boolean constant set to false so the incomplete feature exists in the codebase but is not active. Remove the flag once the feature is complete.

What should I do when a planned task turns out bigger than expected?▼

Split the task into sub-tasks immediately before continuing rather than expanding the diff. Document the deviation in the implementation log and update the plan explicitly instead of silently improvising.

When is incremental implementation not the right approach?▼

It adds overhead for trivial single-file changes or throwaway prototypes where verification and logging cost more than the risk they mitigate. It is designed for multi-task feature work where regressions and review quality matter.