The Five Eras of Coding With AI

I have worked with AI through five distinct eras. Each one automated the layer below it, and each one pushed the scarce skill one level up the stack. Here is the whole arc, and where I think it goes next.

Era One, Copy and Paste

The chat window era. Copy your code, paste it into the chat, read the answer, paste it back into your editor by hand. The entire skill was the prompt.

You had to load the model with context. Be precise, spell out every constraint, because a vague instruction made it hallucinate. This is where prompt engineering was born. A master of the prompt won, because the model could only work with what you handed it.

Picture a five year old who is sad. All she can say is the word sad. She cannot tell you why, cannot give you the context. A stranger is stuck with nothing to go on. Her mother is not. The mother has been learning her since day one, every mood, every tell, every pattern, and she fills the gap the child cannot. She concludes why.

AI is the same. Early on it was the stranger, it needed everything spelled out. Today it has learned from enough of us that it behaves more like the mother. Hand it half a thought and it deduces the rest. The prompt still matters. It matters less than it did.

Era Two, Autocomplete

Then the model moved into the editor and stopped waiting for a paste. It suggested the next line while I typed.

This was the boilerplate era. I no longer needed to know one hundred percent of the syntax. I needed enough to start a function, and the model finished it. The tedious parts, the loops, the error handling, the obvious shape of a thing, all written before I reached them.

The bottleneck moved. It was no longer typing speed. It was knowing what to type.

Era Three, The Editor That Reads the Room

Autocomplete guessed from one line. The next step was a model that read the whole project.

I select a block, describe the change in plain words, and the model edits across files because it now holds the entire repository as context. I am still in the editor, still steering every change, but I am talking to it about my code instead of typing the code myself. The model stopped guessing from a single line and started reasoning about the codebase.

The bottleneck moved again. Not what to type, but how clearly I could describe the change.

Era Four, Agentic Coding

Then I left the editor.

No copy, no paste, no autocomplete, no selecting a block. Just a conversation. I describe a feature, and the agent builds it across the codebase, runs it, fixes what broke. I pilot, it flies.

Writing code stopped being the valuable part. Being expressive became the valuable part. The engineer who can take a hard, tangled problem and state it in plain simple words is the one who shines here. Clarity of thought became the deliverable.

Era Five, The Autonomous Loop

Piloting still meant I was flying the plane. The last era took me out of the cockpit.

I built a harness around the agent, a framework that goes from A to Z on its own. I describe the goal at a high level, and a set of agents figures out how to reach it. They plan it, build it, test it, and open the PR. I am no longer the bottleneck of the process. I batch my thinking into a queue of well written issues, and the loop drains it whether I am awake or asleep.

The One Thing That Moved

Across all five eras, one thing traveled in a straight line. The bottleneck.

WHERE THE BOTTLENECK LIVED

Copy and paste     ->  loading context into the model
Autocomplete       ->  knowing what to type
Project editing    ->  describing the change
Agentic coding     ->  stating the problem
Autonomous loop    ->  deciding what to build

Each era made the layer below it free. Syntax became free, then boilerplate, then editing, then building. What never became free was judgment about what should exist.

What Is Next Today

Every era so far still needed me to fill the queue. The loop is autonomous, the harness runs unattended, but I still write the issues. I still decide what should exist. The board only moves because I keep it full of good todos.

The next era is the AI filling the board itself.

The agent watches the product, the users, the errors, the metrics, and proposes its own work. It opens the issue before I think to. My job shrinks from writing the todos to approving them. From deciding what should exist to picking which of these should exist.

When code is free, when building is free, when even finding the work is free, the only thing left that is rare is taste. Judgment about what is worth doing, and why. That is the era starting now. I am watching for the first issue I did not write.

I used to type the code. Then I described it. Then I queued it. Next I only decide whether it should exist at all.