Guide · Agent skill
How to use the Incremental Implementation agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
The incremental-implementation skill is a set of written instructions that tells an AI coding agent to deliver changes in thin, verifiable slices instead of writing a large amount of code at once. It is useful for developers and teams who want multi-file changes that can be reviewed and verified step by step. After this guide, you will know what the skill changes about the agent's behaviour, how to install it, how to trigger it with a request, and when to skip it.
Incremental Implementationaddyosmani/agent-skills · MIT Download the skill Quick start
- 1Download the ZIP. Download the skill ZIP from this page. It contains SKILL.md.
- 2Choose where to install. Use ~/.claude/skills/ for all projects, a project's .claude/skills/ folder for one repository, or upload the ZIP in the Claude apps under Settings → Capabilities → Skills.
- 3Unzip the skill. Extract the archive into the chosen folder so the skill files sit where the agent can load them.
- 4Make a multi-file request. Ask the agent for a change that touches more than one file, or give it a task from your plan.
- 5Set scope for each slice. Say what the first increment includes and what it leaves out.
- 6Review each commit. Check that each slice passed tests and build, then review the commit before the next one.
What does the incremental implementation skill make the agent do?
When the skill is installed, the agent works through larger coding tasks in small steps. For each slice it implements the smallest complete piece, runs the test suite, verifies the slice works, commits it with a descriptive message, and then moves on to the next slice.
The skill also sets rules for the agent: keep changes minimal, avoid unrequested cleanup, and use feature flags for unfinished work. The skill is a set of written instructions for the agent and does not add new tools on its own.
- Implement one thin, complete slice at a time
- Run tests and the build after each slice
- Commit each increment with a descriptive message
- Keep scope tight and note unrelated problems instead of fixing them
- Use feature flags for work that is not ready for users
How do you install the skill?
Agent skills are folders of instructions that an agent loads. The skill for this page is distributed as a ZIP file containing SKILL.md. Download the ZIP from this page, then choose one of the two install routes below.
- Personal install: unzip the file into ~/.claude/skills/ so it is available across your projects.
- Project install: unzip the file into your project's .claude/skills/ folder so it applies only to that repository.
- Claude apps: upload the ZIP under Settings → Capabilities → Skills.
How do you trigger the skill with a natural request?
You do not need a special command. The skill's description tells the agent when to use it, so a plain request about a multi-file change or a plan task is usually enough. You can also name the approach directly to make sure it is used.
Be explicit about what is in scope and what is not for each increment. The skill's own example asks the agent to do one part of a task and to hold back the rest.
- "Implement feature X in thin slices and run the tests after each one."
- "Let's implement Task 3 from the plan. Start with the database schema change and the API endpoint only."
- "Roll this change out behind a feature flag and commit each piece separately."
"Let's implement Task 3 from the plan.
Start with just the database schema change and the API endpoint.
Don't touch the UI yet — we'll do that in the next increment.
After implementing, run the repository's test and build commands to
verify nothing is broken."What does a sliced implementation look like?
The skill recommends vertical slices by default, where each slice delivers one complete path through the stack. Each slice ends with passing tests and a state where the user can do something new. The skill also describes contract-first slicing for parallel backend and frontend work, and risk-first slicing that tackles the riskiest piece first.
- Vertical: create a task (database, API and basic UI), then list tasks, then edit, then delete.
- Contract-first: define the API contract, implement backend and frontend in parallel, then integrate.
- Risk-first: prove the riskiest connection works before building features on top of it.
What checks does the agent run after each slice?
The skill's checklist asks the agent to verify each increment with the repository's own commands rather than assumed ones. Examples given include npm test, ./gradlew test and pytest for tests, and npx tsc --noEmit or mypy for type checking where the stack has one. The agent should not re-run a command on unchanged code, since that adds no information.
- All existing tests still pass
- The build succeeds
- Type checking passes, where the stack has one
- Linting passes
- The new functionality works as expected
- The change is committed with a descriptive message
What people use it for
- Adding a new feature to an existing web app in several committed slices, such as a database change, then an API endpoint, then the UI
- Refactoring a module while keeping the build and tests green after each step
- Rolling out a change behind a feature flag so unfinished work is merged but not visible to users
- Working through tasks from a written plan one at a time, with each task verified before the next begins
Frequently asked questions
How do I install the incremental implementation agent skill?
Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use, or into a project's .claude/skills/ folder for one repository. In the Claude apps, you can instead upload the ZIP under Settings → Capabilities → Skills.
Does this skill need any requirements or extra software?
The listing states no requirements. It runs no scripts and uses no network. The skill assumes your project already has test, build and other commands the agent can run, so it works best where those exist.
Is the incremental implementation skill free?
The skill is released under the MIT licence. The source does not mention pricing, so check the page for any listed terms before you use it.
Does the skill work on a project with no tests?
Not as intended. The verification steps assume existing test and build commands to run after each slice. Without them, the agent cannot confirm each increment works in the way the skill describes.
When should I not use this skill?
Skip it for single-file or single-function edits, where the skill itself says it adds unnecessary overhead. It is also not a fast option, because it deliberately breaks work into slices.
Does the skill add new tools to my agent?
No. The skill is a set of written instructions for the agent and does not add new tools on its own.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use this skill if you want an AI agent to make multi-file changes in reviewable, tested increments, especially when following a task plan. Skip it for quick single-file edits, projects without tests or builds, or if you need a large code dump fast, since it intentionally slows work into slices.
Download the skill