A couple of years ago I used AI for autocomplete and the occasional regex. Today I describe a feature in a few paragraphs, point an agent at the repository, and come back to a pull request with working code and tests. If you write software for a living, you've probably had the same experience, along with a small knot in your stomach the first time it happened.
So is coding "solved"? Tech leaders have been saying yes for three years, with dates attached. It's worth checking how those dates held up before deciding what to do about our careers.
The predictions, and how they aged
A site called codingissolved.com tracks these claims with a countdown on each one. In March 2025, Dario Amodei said AI could be writing "essentially all of the code" within a year. Mark Zuckerberg said Meta would have an AI mid-level engineer in 2025. Stability AI's former CEO said in 2023 there would be no programmers in five years. Most of those deadlines have passed, and most of us still write and review code every day.
The prediction that aged best was the least dramatic one. Sam Altman said each engineer would do much more for a while, and that at some point we might need fewer of them. That matches what I see.
What actually changed
The timelines were wrong, but the direction was right. Sean Goedecke, a staff engineer at GitHub, compares this period to chess after Deep Blue, when human and computer teams ("centaurs") beat both humans and machines for about twenty years. In his view, an engineer working alone can no longer compete with an engineer using AI, and an unsupervised agent can't beat that pair either. If software follows chess, this phase could last a decade or two.
He also describes how agents fail now. Their mistakes are less often plain bugs and more often mismatches with what the team actually wants: over-engineering one part, under-engineering another, ignoring the team's technical standards. That's exactly my experience. The code works, and it's often not the code I would have chosen.
Cockroach Labs gave the clearest picture of what agents can do at scale. For five months they ran coding agents like a teaching hospital, with one agent planning a fix, another reviewing it, and another checking CI before merge. Humans made the final calls. The pipeline merged over 1,200 PRs with seven reverts, and it added IBM Db2 support to their tooling in under two days for about $4,000 in tokens. Adding Oracle support the old way had taken nine months. Even so, they made human approval mandatory after the first autonomous week, and the question they tracked was how many of those PRs they'd have been embarrassed to merge themselves.
What AI still gets wrong
Models still state wrong things confidently, don't learn from experience, and can't reliably catch their own mistakes. In practice, the code compiles, the demo works, and nobody has decided what the system should do under load, during an outage, or when data arrives twice. Someone still has to think about failure.
Debugging has changed too, because now we often debug code we didn't write. Cindy Sridharan's recent post on this comes down to old-fashioned discipline: if you can't reproduce the failure, you're guessing; a retry or a cache is a mitigation, not a diagnosis; and when two things you believe can't both be true, that's where the bug is.
Where software engineers stand right now
The job market is mixed. CNBC reported this month that software development postings have risen nearly 15% since early 2025 while overall US postings fell. But senior roles made up 71% of that increase, and employment for developers aged 22 to 25 has dropped nearly 20% since 2024. An Indeed economist put the risk well: "Today's entry-level talent becomes tomorrow's senior experts." Companies that stop hiring juniors now will run short of seniors later.
On teams, each engineer ships more, the small tickets that juniors learned on are disappearing, and code review has become the bottleneck. When an agent writes two thousand lines in an afternoon, someone still has to understand them well enough to approve the merge. "The AI wrote it" won't satisfy anyone when that code leaks customer data. An engineer who reads code critically and rejects a design that looks fine but won't scale is worth more today than two years ago.
What worries me most is the entry level. I learned most of what I know by fighting a bug for two days. If new engineers never get those two days, I'm not sure where their intuition will come from.
Where AI is taking us
The unit of work keeps growing: from the next line, to a function, to a whole ticket, and now to pipelines of agents checking each other. Coinbase's engineering blog says its engineers "are evolving from implementers into orchestrators of agent fleets." The job looks more and more like a tech lead's: break down the problem, set the constraints, review the output, own the system.
Models are also getting smaller and more specialized. Coinbase trained a small open model on its own fraud data and reported that it beat a leading frontier model on their benchmark with less than half the latency. They also found that newer frontier models didn't always do better on their task. Choosing, evaluating, and sometimes training models is becoming normal engineering work.
How to grow during the transition
Use AI every day on real work. Goedecke says the surest way to fail right now is to "refuse to become a centaur." Learn where the tools break, and trust them about as much as a smart new hire.
Know what you add. If your only contribution is passing the agent's output along, you're replaceable. Judgment about what the business needs, what to build, and what not to ship is the part that stays human.
Go deeper on fundamentals. System design, data modeling, concurrency, security, and performance are where AI output goes wrong in ways that survive a quick glance.
Learn to evaluate. Build small test sets from real cases so you can tell whether a new model or prompt is better or just different.
Get closer to the business. An agent can write a refund flow, but it doesn't know your biggest client processes refunds in batches at midnight.
Write more. Design docs, clear tickets, and careful reviews are how you direct agents now.
Own things end to end. Deploy, monitor, and read user feedback. Agents make side projects cheap, so build and ship something small on your own.
What I'm doing about it
Each week I hand one real task to an agent before touching it myself, and I note where it went wrong. I review AI code like a colleague's first PR and ask whether I'd be embarrassed to merge it. I write a design doc before any feature longer than a day, because the agent's output gets much better when I do.
I don't think the job is disappearing, at least not on the timelines we keep hearing. It's shrinking down to the parts that were always hard: judgment, communication, and responsibility for what goes live. People who enjoy those parts will do well. People who mostly enjoyed the typing will need to find something new to love about the work, and for some of us that's a real loss.
References
- Coding Is Solved: https://www.codingissolved.com/
- Sean Goedecke, "Software's centaur age may last decades": https://www.seangoedecke.com/softwares-centaur-age-may-last-decades/
- Cockroach Labs, "Five months treating bugs like patients and coding agents like a medical team": https://www.cockroachlabs.com/blog/experiment-running-hospital-code/
- Cindy Sridharan, "How to effectively debug when you no longer understand the code": https://copyconstruct.medium.com/how-to-effectively-debug-when-you-no-longer-understand-the-code-bd3dcb2c5f7b
- CNBC, "AI is automating coding. So why are software developer job postings on the rise?": https://www.cnbc.com/2026/10/11/ai-software-developer-jobs.html
- Coinbase, "Owning Intelligence" series: https://www.coinbase.com/blog/part-three-owning-intelligence-series
