The bottleneck moved
The claim that engineers are finished usually comes from people who have never had to keep a system running that they did not write. It is a claim about typing. Typing was never the job.
Coding agents are genuinely strong. They are a multiplier on a good engineer and a floor-raiser for a mediocre one. I use them daily and my throughput is not comparable to what it was two years ago. That is the part the sceptics get wrong.
But the constraint did not disappear. It moved.
What got cheap
Producing a plausible implementation of a well-specified function got close to free. So did boilerplate, migrations, test scaffolding, the third refactor of a file you already understand, and translating between two languages you both know.
If your work was mostly that, the last two years hurt. That is real and I am not going to pretend otherwise.
What did not
Deciding what to build. An agent will happily construct exactly the wrong thing at high speed. The specification is still the hard artefact, and writing a specification precise enough to be checkable is most of the intellectual work in software. It always was. We just used to hide it inside the coding.
Trade-offs. Should this be consistent or available? Do we take the operational cost of a queue or the latency of a synchronous call? These questions do not have correct answers, they have answers that fit a context — a team size, a budget, a failure tolerance, a regulator. Agents do not have a context. They have a prompt.
Security modelling. I spend a lot of time attacking my own services in a red-team environment I built for exactly that. What I look for is what happens at the seams: the endpoint that trusts a header, the local port that was never meant to be reachable, the parser that accepts input from somewhere the author forgot about. Those bugs are almost never in the function an agent wrote. They are in the assumption between two functions that nobody wrote down.
Verification. Generated code is cheap. Trusted code is not. As generation gets faster, the review and test burden grows with it, and review is the part that does not parallelise well, because it requires holding the whole system in your head.
Legacy is still legacy
Most real codebases are not a greenfield repository with clean boundaries. They are ten years of decisions, half of them undocumented, three of them load-bearing for reasons nobody remembers, with compliance requirements bolted on and a deployment process that exists because of an incident in 2019.
An agent entering that environment has no access to the thing that actually matters: why. It reads the code, not the argument that produced the code. Every senior engineer’s real value is that they carry the argument.
What the next few years actually look like
Human plus agent, with the human holding the spec and the verdict. Not agent replaces engineer.
The engineers who do well will be the ones who move up a level: from writing implementations to specifying, decomposing, reviewing, and designing the systems agents operate inside. That is a promotion in responsibility disguised as a threat, and a lot of people are going to resist it because the new work is less immediately satisfying than the old work. Writing code has a feedback loop. Specification does not, until much later.
The ones who ignore agents entirely will not be replaced by AI. They will be outproduced by a peer who did not ignore them. That has always been how this goes.
The honest version
I am not defending my profession out of sentiment. If the models get good enough to hold a real system’s context, absorb the undocumented why, and verify their own output against a hostile world, I will say so and change what I do.
They are not there. The gap is not a scaling detail. And in the meantime, the way to stay useful is straightforward: get better at the parts that were never about typing.