incremental-implementation

Implements multi-file code changes in thin, tested, individually committed vertical slices.

1|Updated Mar 2, 2025
One-click install
npx skills add https://github.com/marjorg/setup --skill incremental-implementation-marjorg
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: incremental-implementation
Source: https://github.com/marjorg/setup/tree/main/home/.agents/skills/incremental-implementation
Command: npx skills add https://github.com/marjorg/setup --skill incremental-implementation-marjorg

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large features implemented in one pass produce bugs that are hard to locate, reviews that are hard to read, and rollbacks that are painful. This Skill enforces a disciplined workflow where every change is delivered as a small, verifiable increment that keeps the codebase building and tests passing. ## Core Features & Use Cases - Increment Cycle: A repeatable implement-test-verify-commit loop where each slice leaves the system in a working state. - Slicing Strategies: Vertical slices, contract-first slicing for parallel backend/frontend work, and risk-first slicing to surface uncertainty 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, deliver create, list, edit, and delete as four separate end-to-end slices, each tested and committed, instead of one 500-line change. ## Quick Start Ask the agent to implement the next task from your plan incrementally, starting with just the database schema and API endpoint, running tests after each slice before moving to 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 without breaking the build?

Break the feature into thin vertical slices where each slice delivers one complete path through the stack. After each slice, run the test suite and build, then commit before starting the next slice so the codebase never sits in a broken state.

What is vertical slice development in software engineering?

Vertical slicing builds one complete path through all layers (database, API, UI) per increment instead of completing one layer at a time. Each slice delivers working end-to-end functionality that can be tested and demonstrated.

How do I merge unfinished features without exposing them to users?

Wrap the incomplete feature behind a feature flag checked at runtime, defaulting to disabled. This lets you merge small increments to the main branch while keeping unfinished work invisible until it is ready.

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 reviewable in one step.

Why do bugs compound when testing only at the end?

A defect introduced in an early slice silently corrupts every slice built on top of it, making the root cause hard to isolate among hundreds of changed lines. Testing each slice catches defects at the point of introduction.