Incremental Implementation skill for Claude Code: build in thin, tested slices

Makes your agent build multi-file changes in thin, tested slices instead of one big pass.

Installs: 66.3K; on skills.sh
Stars: 112.6K; on GitHub
Updated: Nov 2026; last repo commit

incremental-implementation makes the agent implement one small piece, test it, verify it and commit it before it moves on. It loads for any change that touches more than one file, when you pick up the next task from a plan, or when a task feels too big to land in one step.

The skill sets rules such as keep it simple, touch only what the task needs, keep the project compiling after each slice and use feature flags for unfinished work. It uses your project's test, build and lint commands and bundles no scripts.

Good for

Developers building a feature that touches several files
Anyone who wants small, revertable commits from an agent
Teams rolling changes out behind feature flags

Install incremental-implementation

Claude Code

Copy this prompt.

Install the incremental-implementation skill in Claude Code. Run this command:

npx skills add https://github.com/addyosmani/agent-skills --skill incremental-implementation

Then check that it loaded and tell me how to use it.

2
Paste it into Claude Code. It shows the change and asks before running it.

Requires Node.js.

From its listing on skills.sh. Source.

What's in the skill

When it loads

Delivers changes incrementally in thin, verifiable slices. Use when implementing any feature or change that touches more than one file, or when picking up the next task from a plan. Use when rolling a change out behind a feature flag, when you're about to write a large amount of code at once, or when a task feels too big to land in one step.

Sections in SKILL.md

Overview
When to Use
The Increment Cycle
Slicing Strategies
Vertical Slices (Preferred)
Contract-First Slicing
Risk-First Slicing
Implementation Rules
Rule 0: Simplicity First
Rule 0.5: Scope Discipline
Rule 1: One Thing at a Time
Rule 2: Keep It Compilable
Rule 3: Feature Flags for Incomplete Features
Rule 4: Safe Defaults
Rule 5: Rollback-Friendly
Working with Agents

Key facts

Author: addyosmani (repo owner)
Installs on skills.sh: 66,281 (Nov 2, 2026)
GitHub stars: 112,555 on the agent-skills repo (Nov 2, 2026)
License: MIT
Last commit: 2026-11-01
What installs: 1 file: SKILL.md
Needs: Your project's test, build and lint commands; it points to git-workflow-and-versioning for commit guidance
Works in: Claude Code, Codex, Cursor, Gemini CLI, Copilot, OpenCode and more, per the README

What it includes

Implement, test, verify, commit, then move to the next slice
Five steps for each slice. Carry forward; do not restart.
Runs code · Increment cycle
Vertical slices (preferred), contract-first and risk-first
Choose how to cut the work: end to end, API contract first, or riskiest piece first.
Slicing strategies
Ask what the simplest thing that could work is
Three similar lines beat a premature abstraction.
Rule 0: Simplicity first
Touch only what the task requires; note other issues instead of fixing them
Do not clean up adjacent code or add unrequested features.
Rule 0.5: Scope discipline
Each increment changes one logical thing
Separate commits for a new component, a refactor and a config change.
Rule 1: One thing at a time
The build and existing tests pass after every increment
No broken state between slices.
Rule 2: Keep it compilable
Merge unfinished features behind a flag
Lets small increments reach the main branch without exposing incomplete work.
Rule 3: Feature flags
New code defaults to conservative behavior
Example in TypeScript.
Rule 4: Safe defaults
Each increment can be reverted on its own
Keep deletes and replacements in separate commits; migrations get rollbacks.
Rule 5: Rollback friendly
Tests, build, type check, lint, behavior and commit message
Run each command after a relevant change; do not repeat on unchanged code.
Runs code · Increment checklist
Tell the agent what is in scope and what is not for each increment
The example prompt asks for the database change and the endpoint only, leaves the UI for the next increment, and has the agent run the repository's test and build commands afterwards.
Working with agents
Apply the project-wide Definition of Done as the final gate
The SKILL.md points to ../../references/definition-of-done.md in the pack. A one-skill install does not copy that file.
Read · Definition of Done (See Also)

From the official docs

Permissions

Low risk

It edits your files, runs your checks and commits slice by slice. Work on a branch so you can review or revert each commit.

What it can do

Read your data
Create and change things
Delete things
Read-only mode

Watch out for

It commits after each slice
The increment cycle ends with a commit. Work on a branch and tell the agent if you want to review before it commits.
It runs your test, build and lint commands
The checklist names npm test, tsc, mypy and similar as examples of what it runs in your project.

Questions

What does incremental-implementation do?

It makes Claude build in thin slices: implement one piece, run the tests, check it works, commit, then continue. It warns against writing more than about 100 lines before testing.

How do I install incremental-implementation?

Use the install box above. The README also lists npx skills add addyosmani/agent-skills --skill incremental-implementation for one skill, and a Claude Code plugin for the whole pack (/plugin marketplace add addyosmani/agent-skills, then /plugin install agent-skills@addy-agent-skills). A one-skill install copies only skills/incremental-implementation/ and not the repo-level references folder; the README says the skill still works. The skill also points to ../../references/definition-of-done.md, which a one-skill install does not copy.

Does it need other skills?

No. It suggests the git-workflow-and-versioning skill for commit guidance and a Definition of Done file in the repo-level references folder. Both are optional for this skill to work.

Does it commit for me?

Yes, its cycle says to commit after each verified slice with a descriptive message. Tell Claude not to commit if you want to review each slice first.

When should I not use it?

The SKILL.md says to skip it for single-file, single-function changes where the scope is already small.

Is it safe to run?

It is a text file of instructions and bundles no scripts. It tells the agent to run your tests, build and linter and to commit, so work on a branch.

Does it work in Codex, Cursor or other tools?

The README documents Codex (codex plugin marketplace add addyosmani/agent-skills, then codex plugin add agent-skills@agent-skills, Codex CLI v0.122 or newer), Cursor (copy skills into .cursor/skills/), Gemini CLI, Windsurf, OpenCode, GitHub Copilot, Kiro and others. It says the skills are plain Markdown that work with any agent that accepts instruction files. It does not mention the Claude app.

Information

updated Nov 2, 2026

Repository: addyosmani/agent-skills
Folder: skills/incremental-implementation

addyosmani/agent-skills skills.sh

Sources

Docs, issue trackers and discussions this page is built from.

Show all 2

incremental-implementation SKILL.md · github.com
addyosmani/agent-skills README · github.com