Source: addyosmani/agent-skills · Maintainer: community: Addy Osmani · License: MIT · Checked: 24 October 2026
What is the incremental-implementation skill?
incremental-implementation is an incremental implementation skill that makes a coding agent build a feature in thin vertical slices: implement one small piece, test it, verify it, commit it, then move to the next. Every slice leaves the project building and its tests passing.
It is one of 25 skills in addyosmani/agent-skills, Addy Osmani's pack that maps skills to a define, plan, build, verify, review and ship lifecycle. The README puts it first in the Build phase: "Thin vertical slices - implement, test, verify, commit. Feature flags, safe defaults, rollback-friendly changes."
The description reads: "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."
Its skills.sh page listed 60.7K installs (snapshot, 24 October 2026).
What does it do?
The SKILL.md, about 9.6 KB, centers on a five-step cycle for each slice: implement the smallest complete piece, test, verify (tests, build, manual check), commit with a descriptive message, then carry forward to the next slice. A red flag is "More than 100 lines of code written without running tests."
Three slicing strategies.
| Strategy | When | Example from the skill |
|---|---|---|
| Vertical (preferred) | Most features | Create, list, edit, delete a task, each through DB, API and UI |
| Contract-first | Backend and frontend work in parallel | Define the API contract, build each side against it, then integrate |
| Risk-first | One piece is uncertain | Prove the WebSocket connection before building on it |
Implementation rules.
- Rule 0, simplicity first. Ask "What is the simplest thing that could work?" before coding. "Three similar lines of code is better than a premature abstraction."
- Rule 0.5, scope discipline. Touch only what the task requires. No cleaning adjacent code or modernizing syntax in files you're only reading. Anything worth fixing goes in a "NOTICED BUT NOT TOUCHING" list for you to turn into tasks.
- Rule 1, one thing at a time. One logical change per increment.
- Rule 2, keep it compilable. The build and existing tests pass after every slice.
- Rule 3, feature flags. Merge unfinished work behind a flag so users don't see it.
- Rule 4, safe defaults. New options default to off, for example
notify ?? false. - Rule 5, rollback-friendly. Each increment can be reverted on its own; migrations need rollback migrations.
There's also a short template for directing an agent through one increment, an increment checklist (tests, build, type check, lint, commit), and a note not to rerun the same command on unchanged code, since "re-running on unchanged code adds no information." The skill ends with rationalizations, red flags and a final verification list, then a See Also line pointing to the pack's Definition of Done as the last gate before calling a task done.
How do you install it?
Just this skill. The skills.sh command, using the open skills CLI:
npx skills add https://github.com/addyosmani/agent-skills --skill incremental-implementation
Add -g for all projects. In Claude Code it lands in .claude/skills/incremental-implementation/ or ~/.claude/skills/incremental-implementation/, the standard skill locations.
The references/ caveat applies here. The README says a per-skill install "copies only skills/<name>/, not the repo-level references/ directory." This skill's See Also points to ../../references/definition-of-done.md, so that link breaks in a single-skill install. Fix it by copying definition-of-done.md into a references/ folder inside the installed skill and adjusting the path, or use one of the whole-repo options below. The skill also names git-workflow-and-versioning and test-driven-development, which are separate skills in the pack.
The whole pack in Claude Code. From the README:
/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skills
This adds the /build command, which invokes this skill alongside test-driven-development. Plain /build implements the next pending task and stops. /build auto needs a spec at a known path (such as SPEC.md), gets one approval for the plan, then runs every task with its own commit, stopping for failures, ambiguity or risky steps. If the marketplace add fails over SSH, use /plugin marketplace add https://github.com/addyosmani/agent-skills.git.
Codex. Run codex plugin marketplace add addyosmani/agent-skills and codex plugin add agent-skills@agent-skills (Codex CLI v0.122 or later), then call @incremental-implementation. See Codex skills and Cursor skills.
claude.ai. Zip the folder and upload it under Customize, then Skills, as the Claude Help Center explains.
How do you use it?
It works best with a plan. Pair it with planning and task breakdown to produce tasks, then hand the agent one task at a time and say what is out of scope.
Example prompts (suggestions, not quotes from the repo):
Implement task 3 from tasks/plan.md. Start with the schema change and the API endpoint only; no UI yet.Build task sharing as vertical slices behind a FEATURE_TASK_SHARING flag. Commit after each slice.The WebSocket layer is the riskiest part. Prove the connection works before anything else.Add this feature without touching unrelated files. List anything you notice but don't fix.We'll build backend and frontend in parallel. Write the API contract as slice 0.
Requirements: a git repo for the per-slice commits and your project's own test, build and lint commands. No packages or keys.
Tips and limits
- Many small commits. The skill commits after every slice. If your team squashes on merge, that's fine; if not, expect a longer history.
- The 100-line mark is a heuristic. It's the skill's trigger for "test now," not a hard limit.
- Flags need cleanup. Rule 3 adds feature flags but doesn't cover removing them; plan that as its own task.
- Security audit. On 24 October 2026 the skills.sh page showed Gen Agent Trust Hub: Pass, Socket: Pass, Snyk: Pass. The folder holds only
SKILL.md; git commits and test runs go through your agent's shell under your permission settings.
The repo is MIT licensed, so you can copy and change the skill if you keep the copyright notice.
Save it in your Kipt library
To keep a fixed copy with the Definition of Done bundled in, download the folder, add definition-of-done.md under references/, and drop the folder or a .zip into Kipt's Skills import box (you can also paste the GitHub folder link; a repo with many skills shows a list to pick from). Kipt keeps skills in your own private GitHub repo and installs all of them into Claude Code or Codex with one command:
npx skills add https://github.com/<you>/<repo>.git --all -g
Kipt is not affiliated with Addy Osmani or addyosmani/agent-skills.
Similar skills
- Planning and task breakdown skill: Addy Osmani's skill for turning a spec into the tasks this one builds.
- Executing plans skill: Superpowers' version of running a written plan test-first.
- Subagent driven development skill: Superpowers runs each task in a fresh subagent with a review after each.
- Code simplification skill: the same one-change-at-a-time discipline, for cleaning up working code.
- Debugging and error recovery skill: where
/buildhands off when a slice breaks.