Take Smaller Steps Than You Think You Need To

AI removed the one thing that used to keep your steps small. Now you have to put it back yourself.

For a long time, the way I used AI was simple. I would take whatever I was working on, the whole of it, paste it in, and hope.

The output would come back. It would look fine. Often it was fine, on the surface. But I could never quite stand behind it. I had not watched it get made. I had handed over the whole problem and received the whole answer, and somewhere in that trade I had given up the one thing that lets you trust a piece of work, which is having seen each part of it come together and knowing why it holds.

It took me longer than I would like to admit to find the alternative. It is not clever. It is almost embarrassingly simple. Take smaller steps. Take much smaller steps than feel necessary. Get AI to do one small thing, check it, and only then move to the next.

I used to think this was about being careful. It is not. It took me a while to see what it is actually about.

What a small step buys you

Here is what a small step actually buys you. It keeps any single mistake small enough to throw away.

When AI takes a large step and it is subtly wrong, the error does not announce itself. It looks like all the rest. So you build the next thing on top of it, and the next, and by the time the problem surfaces it is three moves down and load-bearing. The cost of a wrong step is not flat. It compounds, because every step after it quietly assumed it was sound. A small step keeps you within reach of the last point where everything worked. If it is wrong, you have lost a few minutes, not a morning, and you can throw it away cheaply because nothing is standing on it yet.

So the feedback loop is not there to confirm quality at the end. It is there to catch the error while it is still cheap to reverse. And this is why it feels calmer to work this way, even though you stop more often. You are never more than one small move away from something that works, so you are not carrying the quiet anxiety of not knowing whether the last twenty minutes was built on sand.

Why almost nobody takes them

If small steps are so obviously better, why does almost nobody take them?

Because for most of the history of building things, you did not have to choose them. When you write code by hand, you cannot take a large step even if you want to. You are held back by your own pace, by how fast you can type and think and hold the pieces in your head. That slowness is annoying. It is also a constraint that does quiet, useful work. It forces small steps on you whether you like it or not, and it forces you to half-understand each line as you go, because you had to write it.

AI removes the constraint completely. It will produce sixty files in the wrong direction in ninety seconds, and they will look plausible the whole way. The thing that used to keep your steps small for free, your own limitation, is simply gone.

So the small step is no longer the default. It has become a choice, one you have to keep making against a tool that is constantly inviting you to go bigger, because going bigger is exactly what it is good at. The same capability that makes AI valuable, that it can take enormous steps cheaply, is the very thing that hurts you the moment you stop holding it back.

Watch what people do with that pull, though. They feel it, they sense the risk, and they try to manage it by writing the perfect large prompt. Hours poured into the instruction, hoping that if they specify enough up front, the one giant step will land. It almost never does. The effort was real, but it was spent in the wrong place. Not on getting the big step exactly right. On not taking the big step at all.

There is an older idea worth borrowing here. The cost of fixing a problem rises the later you catch it. Caught early, when it is still just a thought, it costs almost nothing. Caught late, after a great deal has been built around it, it costs a great deal more. AI makes you believe it has flattened that curve, when it has only flattened one part of it.

What became cheap is producing the work. Generating it, regenerating it, throwing it away and asking again. So people assume change itself became cheap. But the cost of understanding what went wrong inside a large block of AI output, code you never reasoned through, and finding which of the buried assumptions is the bad one, is no cheaper than it ever was. People mistake cheap-to-generate for cheap-to-change, and the two could not be more different. The small step keeps you where you still understand what you are holding, which is the only place change is genuinely cheap.

Older than AI

It is worth asking whether any of this is new. Breaking a big thing into small, careful steps is how almost every leap in automation has worked. Nobody automated “build a car.” They broke the work into single stations, fitting one part, tightening one bolt, validated each one, and chained them together. AI did not invent this. It just made forgetting it easy.

But there is a twist with AI that no earlier automation had, and it is the reason small steps matter even more now, not less.

On an assembly line, the small steps are temporary. You break the work down and perfect each station once, during design. Then you lock it, and it runs ten thousand times in a row without anyone watching, because the machine is reliable. Press the same button, get the same result. The small step was scaffolding. You climb it to build the system, and then you take it away, and the system runs in long, confident, unsupervised strides.

With AI you never get to take the scaffolding away. Ask the same thing twice and you can get two different answers. Every step is a roll of the dice, not the press of a stamp. So the checking is not a one-time cost you pay during design and then bank forever. It is a cost you pay on every single run, because the station never becomes reliable the way a machine becomes reliable.

That is the real shift. In a factory, small steps are how you reach a system that then runs in big ones. With AI, the small step is not the scaffolding you remove. It is the permanent way you work. You do not graduate out of taking it carefully, because the work itself never stops being uncertain.

None of this means a big step is always wrong. If you are building a throwaway prototype, or a script you will run once and delete, let AI take the whole thing in one go and do not look back. The rule matters when the work has to last, when other things will be built on top of it, when you will have to stand behind it later. That is most real work, which is why the small step is the better default. But it is a default, not a law.

How I wrote this

This is not abstract for me. It is how I wrote this piece.

I did not ask AI to write an article about small steps. I talked through the idea first. Then I had it generate a few directions, and I picked one. Then an outline, which I checked before going further. Then we built it one section at a time, and within each section a few lines at a time, and I stopped after each to see whether I was still happy. Small step, check, next step. The same pattern I would use for code, or anything else.

It is slower in the way that stopping at each floor is slower than taking the lift to the top. But I have rarely had to throw the whole thing away and start again. And I can stand behind every part of it, because I watched each part arrive.

That is the quiet trade. You give up the fantasy of the one big step that lands perfectly. In return you get work you can actually trust, and you rarely have to go backwards.