In December 2024, I published a post arguing that AI coding assistants would transform rather than replace software developers. It was a reasonable piece. It was also, in the way that reasonable pieces often are, a little cowardly.
Eighteen months is enough time to score predictions. The post made five claims worth testing.
The “can’t do” list. I wrote that AI models “struggle to design scalable microservice architectures or to make security-critical design decisions.” That claim has a shelf life of roughly twelve months, and the sell-by date has passed. Claude Code, Cursor, and Windsurf are now doing substantial architectural work — not perfectly, not without supervision, but not “struggling” either. The honest update: AI moved faster up the capability stack than I implied. The list of things AI demonstrably cannot do has shrunk, and will keep shrinking.
The “AI-augmented developer” framing. This one held. Developers haven’t been replaced; they’ve changed shape. But here is the uncomfortable part: the framing was already the mainstream consensus in 2024. I wasn’t saying something the crowd hadn’t agreed to. I was summarising the median position and dressing it in slightly better sentences. Vindicated, and also irrelevant — which is a particular kind of failure.
“AGI would be needed to fully replace programmers.” Still probably true. Still also a hedge disguised as an argument. By the time we have AGI, the question of whether programmers specifically are replaced will be uninteresting. I put this in the piece because it closed a rhetorical gap; it doesn’t do analytic work.
The autopilot analogy. I wrote: “even in an age of autopilot, pilots still exist — their role has evolved rather than disappeared.” This analogy was stale when I wrote it. Every “AI won’t steal your job” piece in 2023 and 2024 ended with pilots. It was borrowed reassurance, and I should have caught it. The irony is that the analogy, used carefully, actually points somewhere more interesting than I took it. A modern pilot’s job is not flying the plane — the autopilot does that. The pilot’s job is monitoring the autopilot, understanding its failure modes, and knowing exactly when to grab the controls. That is a harder cognitive task than flying, not an easier one. I gestured at the transformation but didn’t press on what the transformation demands.
The skills to develop. I said: “system architecture, business domain expertise, and cross-functional collaboration.” Still true. Still incomplete. There is a fourth skill I didn’t name, and it is the one that actually differentiates working developers in 2026.
Here it is: verification.
The question in 2024 was whether AI could write the code. That question is answered — yes, increasingly, for a widening range of tasks. The question in 2026 is whether you can verify what it wrote. Not “does it compile?” and not “do the existing tests pass?” — both of those are table stakes the model checks itself. The question is: does it do what you specified? And the harder version: did you specify clearly enough to know?
This is not a comfortable shift. Writing code is a generative task, and humans are tolerably good at generating things. Verification is an adversarial task — you are trying to find the flaw in something that was constructed to look correct. The model is fluent, confident, and wrong in ways that are structurally difficult to detect without the domain knowledge you were supposedly able to outsource.
The architectural skill I described in 2024 is real. But architecture is upstream. Verification is the daily work now — the thing you do after the model has produced something that mostly makes sense and you have to decide whether “mostly” is good enough to ship.
I was more navigator than pilot in 2024. In 2026 I am more inspector than navigator, and the inspection is the hard part.
One honest limit to this argument: verification has always been part of the job. Code review exists. QA exists. What has changed is the ratio: generation is so fast, and so voluminous, that the verification burden has grown disproportionately. If you ship at the speed the model can generate, you will ship mistakes at the same speed. The constraint is not cycles; it is attention.
The post I wrote in 2024 got the direction right and got the pace wrong. It implied a gradual evolution. What happened was an abrupt one — not in the sense that everything changed overnight, but in the sense that the threshold shifted faster than the comfortable “transformation not replacement” framing anticipated.
The question was never whether AI could write the code. The question was always whether you could read it.