incremental-implementation

Overview of incremental-implementation skill

The incremental-implementation skill helps you ship code in small, working slices instead of trying to finish a large change in one pass. It is best for the incremental-implementation for Code Editing workflow when a task spans multiple files, needs tests, or is risky enough that one big edit would be hard to debug.

Use it when you want a practical way to keep a feature moving without losing correctness. The main job-to-be-done is simple: break work into a sequence of implement-test-verify steps so each slice remains reviewable, testable, and easier to recover if something breaks.

Best fit and why it matters

This skill is a strong fit for feature work, refactors, and changes where the first draft could easily exceed what you can confidently validate at once. It is less useful for tiny single-file edits, where the overhead of slicing adds more process than value.

What makes it different

Unlike a generic “work iteratively” prompt, incremental-implementation gives you a concrete execution pattern: make the smallest complete change, validate it, then proceed. That discipline reduces hidden coupling, keeps regressions localized, and helps agents avoid overbuilding before feedback arrives.

What users care about most

Readers usually care about whether the skill will actually reduce risk, how much planning it requires, and whether it slows them down. The answer here is: it should speed up hard tasks by preventing rework, but it only pays off if you are willing to define a slice boundary and verify each step.

How to Use incremental-implementation skill

Install the skill and find the source

Install the incremental-implementation install package with:

npx skills add addyosmani/agent-skills --skill incremental-implementation

Then read SKILL.md first. In this repo, that is the main source of truth; there are no extra rules/, references/, or helper scripts to chase. If you want the fastest possible onboarding, start with the sections on when to use it and the increment cycle.

Turn a vague task into slices

The best incremental-implementation usage starts with a task that is already broken into outcomes, not one giant ask. Good input sounds like this:

• “Add user profile editing in three slices: form rendering, save API, validation/error states.”
• “Refactor the parser incrementally: keep existing behavior, add tests before moving logic.”
• “Implement the dashboard filter with a working UI first, then persistence, then edge cases.”

Weak input sounds like: “Make the app support profiles.” That forces the skill to guess slice boundaries, which is where implementation quality drops.

Follow the loop, not the whole feature

A strong incremental-implementation guide is: implement the smallest complete slice, run the relevant test or build, verify the behavior, then move to the next slice. If a slice cannot be tested, make it smaller. If it cannot be verified, it is probably too broad.

Practical workflow for Code Editing

For incremental-implementation for Code Editing, ask the agent to preserve working state after each step and avoid broad rewrite passes. A useful prompt shape is:

Use incremental-implementation. Break this task into 3-5 slices. For each slice, change only the necessary files, explain the test or verification step, and stop if the slice would leave the app broken.

That prompt helps because it constrains scope, forces checkpoints, and makes the agent surface tradeoffs before editing too much code.

incremental-implementation skill FAQ

Is incremental-implementation only for big features?

No. It is for any change where an all-at-once edit increases risk. The incremental-implementation skill is especially helpful when you need tests, have cross-file dependencies, or expect the first attempt to surface unknowns.

Do I need to change my whole workflow?

No. You can keep your normal stack and just change the order of execution: slice, validate, then continue. The skill is about implementation discipline, not a new framework or toolchain.

When should I not use it?

Skip it for single-function or single-file fixes that are already straightforward. If the task is tiny and well understood, incremental planning can add unnecessary ceremony.

Is it beginner-friendly?

Yes, if you can describe a feature at a basic level and accept stepwise progress. It is also useful for experienced developers because it prevents “almost done” code from accumulating without verification.

How to Improve incremental-implementation skill

Give better slice boundaries

The biggest quality boost comes from telling the agent where one slice should end. Include constraints like “keep the app buildable after every step,” “avoid schema changes until the UI works,” or “add tests before touching the API layer.” Those boundaries make incremental-implementation usage much more reliable.

Provide the right context up front

Share the entry points, current files, and any hard limits: framework version, test commands, migration constraints, or files that must not change. If the agent has to discover those constraints midstream, it may choose slices that are technically incremental but still awkward to merge.

Watch for the common failure mode

The main failure mode is a slice that is too large to verify cleanly. If the first output looks broad, ask for a smaller next step, a tighter test plan, or a narrower file set. Better results usually come from reducing scope before editing code, not after.

Iterate after each slice

Treat the first pass as the plan, not the final answer. After each slice, tell the agent what passed, what broke, and what still feels risky. That feedback loop is where the incremental-implementation skill becomes most valuable: it turns a one-shot request into a controlled sequence of code edits.