Coding isn't dead. It's where the loop closed first.

Every few weeks someone declares coding dead. Each time I read the argument, I notice the same thing: the author is looking at a language model and describing something else.

What writes code today is not a model. It is a model inside a loop — with a compiler, a test runner, a browser and a screenshot tool for company, allowed to try again a hundred times. That system does the work. The model is one part of it, and not the part that made the difference.

This post is about that confusion: why coding was the first place it showed up, why the approach has nothing to do with coding in particular, and why I think engineering is not dead. Not now, at least. If anything, it has just become visible.

What you’re actually looking at

Take a model out of the loop and ask it for a feature. You get a plausible file. Sometimes it compiles. It’s autocomplete with good manners, and nobody would call it a programmer.

Now give the same model a loop. Write, run, read the error, fix, run again. Let it open the app and look at the screen. Let it run the tests. Let it do that for an hour without getting bored. The thing on the other side is suddenly a worker, and the files it leaves behind are hard to tell from the ones I would have written on a good day.

Nothing about the model changed between those two paragraphs. What changed is that the system can now tell when it’s wrong. The loop is the product; the model is the engine. Confusing the two is how you end up with “LLMs can code” as a claim about language models, when it is a claim about feedback.

I’ve written about where this loop stalls and won’t repeat it here. The short version: the loop is only as good as its checks, and when the checks run out, the model keeps going anyway. Keep that in mind, because it’s the whole story of what comes next.

Why coding went first

In software, the “you’re wrong” signal is cheap, instant and everywhere. The compiler says so. The types say so. The tests, the runtime exception, the log line, the HTTP trace, the screenshot — every one of them is a sentence an agent can read, none of them takes more than a few seconds, and none of them gets tired of telling you.

No other profession has anything like it. A lawyer’s draft gets checked by a judge a year later. A marketer’s copy by a quarter’s numbers. A doctor’s decision by a patient. Coding is the one field where reality answers in a second, in text, as many times as you ask.

So coding didn’t fall first because it’s easy. It fell first because its environment is the best oracle ever built — assembled by programmers, for themselves, over fifty years of wanting faster answers to “does this work?”. The agent walked into a room that was already full of instruments.

The approach is universal

The loop doesn’t know it’s running on code. Act, observe, compare with the intent, act again. Anywhere you can give it an observation step, it works.

One of my apps edits people’s photos. A model makes the edit; another model looks at the result and answers plain questions — is the subject still there, were the faces kept, does this crop make sense — and the edit goes around again if the answer is no. Same loop, different oracle. Mail triage, research, filling forms, reading documents: the same shape every time.

The difference between domains is not whether the loop applies. It’s the price of the check. In code it came for free. Everywhere else, somebody has to build it. Hold that thought; it’s where engineers come back in.

This is the human model

None of this is new, and I think that’s the part people miss while arguing about intelligence.

Delegate, receive, check, send back with notes. A team is this. Code review is this. QA, an editor, peer review, a restaurant kitchen. Human collaboration has always been agents in loops with checks between them — we just called it management, or craft, or apprenticeship, and never drew the diagram.

What’s new is a participant that costs cents, doesn’t tire, and makes the loop visible, because for the first time you can watch it run on a screen. We didn’t invent agentic systems. We finally got to see our own — and it turns out it isn’t rocket science. It’s how we have always worked.

Programmers were never typists

Here is where “coding is dead” gets its one true word: typing is dead. Good.

The confusion underneath the slogan is between developers and programmers. A programmer is not the person who turns a spec into keystrokes. A programmer is the person who understands the domain and solves the problem efficiently with whatever is at hand. The keystrokes were always the least interesting part — the part we tolerated because there was no other way to get the idea into the machine.

I’ve been doing this for a long time. I didn’t come for the money; I came because technology was interesting, and it still is. So the typing going away doesn’t feel like a loss. It’s the part I would have given away for free, and now I have.

What’s left is the good part

The loop closes only where someone has built the check. In code we inherited it. Everywhere else it has to be designed: what counts as done, which signal says so, how to make it cheap enough to run a thousand times, which observations the agent should trust and which it shouldn’t. That is engineering with the typing removed. I spent a whole post on one such harness, and building it was the most engineering I’ve done in years — none of it was typing code.

And the domain itself never lived in the keystrokes. Knowing what the problem actually is, what the data must never become, what “works” means for the person on the other end — that’s the job. It always was. The loop didn’t take it; the loop needs it, because without someone who knows what right looks like there is nothing to check against.

So, is engineering dead? Not now. Not from what I can see. The part that was mechanical is gone, and what’s left is the part that required a mind in the first place.

Where else the loop closes

What I’m genuinely curious about now is which domain closes its loop next. That’s the question I’d ask of any field: how expensive is its “you’re wrong”, and can it be made cheap?

I believe these systems should move humanity faster, and not only in software. Look at how discoveries are made now: the scientist is less and less the person running the thousandth measurement by hand, and more and more the person who built the system that runs thousands of them, then reads what came back and decides what it means. Automated screening, simulations that try candidates all night, pipelines that filter a million possibilities down to the ten worth a human’s attention. The loop is the same shape; the oracle is an instrument or a simulation instead of a compiler.

That’s exactly what happened to programmers, and I think it’s the better version of the job. Not the routine, not the typing, but the hypothesis, the validation, the design of the solution. When the thousand operations are someone else’s, what’s left for the scientist, the doctor, the analyst is the part they came for in the first place — the same part programmers came for.

Which is why I’d rather talk about problems than tools, and that brings me to the one thing I hope these systems kill off.

Maybe the end of the stick wars, too

I’ll admit this one is personal.

I’ve been tired of this industry’s toxicity for a long time: the framework wars, the language wars, the endless measuring of whose stack is better than whose. You need to know your technologies, the way a physicist needs to know their instruments. But being a fan of a framework is a strange thing to be. Mathematicians, physicists and philosophers drew in the sand with a stick and took pleasure in the thinking. Nobody argued about whose stick was prettier or whose sand was softer.

An agent doesn’t care which stick you hand it. It will use whatever is there, and the loop judges the drawing, not the tool. I hope that moves the conversation back to the drawing — to problems, output, the thing that actually works — and away from the tools as identity. The best people I’ve worked with always lived there anyway.

Where this leaves me

Coding isn’t dead. It was the first place where the loop closed, because programmers spent decades building the instruments that make a check cheap. Typing is dead, and I won’t mourn it. Programming — understanding a domain and solving its problems well — is not, and the loop can’t run without it.

If you came here because technology is interesting, this is the most interesting it has ever been. The stick got better. The sand is the same. The drawing is still yours.