Writing a single big change for two days and trying it at the end is the quickest way to discover, at the last moment, that the problem was in the first hour. Incremental implementation reverses the order: you build a small piece, try it, save it, and only then move to the next.
The increment cycle
You choose the next small portion, build it, try it (tests, compilation, a visual check), save it with a descriptive commit and only then move on. If something breaks halfway, the damage is twenty minutes, not two days.
How to cut the work
- Vertical slices (preferred). A slice cuts through all the layers and produces something that works: from the data to the screen, for a simple case. It can be shown and tried.
- Contract first. When several parts must talk to each other, you agree on and write the boundary first (the interface, the data format), then each works on their side.
- Risk first. You tackle the most uncertain part first: if it cannot be done, better to know on the first day.
The rules
Simplicity first. The simplest solution that works is the right one until reality shows otherwise.
Scope discipline. You do what is in the task. The idea "while I'm here I'll add this too" is how a one-hour change becomes a three-day one.
One thing at a time. One increment, one intention. Unrelated changes in the same increment make it impossible to tell what broke what.
Always buildable. Between one increment and the next the system starts and the tests pass. If it breaks, you repair it before going on.
Switches for incomplete features. A half-done feature is hidden behind a configuration option (feature flag), so the code can be integrated without users seeing it.
Safe defaults. A new option starts off and cautious.
Easy to undo. Every increment must be revertible on its own, without dragging anything else with it.
When working with an agent
The same applies, and more so: an agent left free tends to produce a lot of code at once. You ask for one step at a time, check, and decide the next. More than a hundred lines written without running anything is a warning bell.
Warning signs
- More than a hundred lines written without running the tests.
- Several unrelated changes in a single increment.
- Scope expansions of the "I'll add this on the fly" kind.
- Skipping verification to go faster.
- Broken build or tests between one increment and the next.
- Large unsaved changes piling up.
- Abstractions built before a third use case calls for them.
An example
You have to add sending a notification when an order changes status. First increment: send a fixed message on the change from "new" to "confirmed", tried with a test. Second: customise the text. Third: handle the other statuses. Fourth: let the customer turn it off. At every step the system works, and whoever reviews the code reads a few lines, not a wall.
When to use it
When building a feature or a change that touches more than one file, when you are about to write a lot of code at once, or when a job seems too big to finish in a single step.
This method derives from the open-source agent-skills family by Addy Osmani (MIT licence), rewritten and adapted.
This article is an OIAR skill
What you have just read is the content of a skill from the OIAR catalogue, written for people. Knowledge like this, but richer and deeper, written for the agents, drives the interviews, the analysis and the report inside the platform. Skills are used in OIAR: to try this one on a project of yours you need an account.
incremental-implementationA method for making a change in small verifiable increments: the choose-build-test-save cycle, vertical slices, scope rules, code that always builds, switches for incomplete features, easy rollback. Use it when a change touches several files or when you are about to write a lot of code at once.