Geoffrey Hinton, Nobel laureate and self-described "godfather of AI," predicted last month that AI will soon handle software engineering tasks that currently take a month of human effort, leaving very few people needed for the work. Marc Benioff announced Salesforce won't hire software engineers in 2025. Zuck told Joe Rogan that Meta will have AI capable of being "a mid-level engineer" this year. Dario Amodei predicted 90% of code would be AI-written within six months.
I think these predictions get the causality backwards. AI didn't suddenly become capable of writing software — software development has been making itself easier to automate for a long time. The industry commodified itself, and AI is riding on that.
What commodification looks like
There's always a relevant xkcd.
The comic is from 2007. The joke worked because it was already true then, and the ecosystem has only gotten more comprehensive since.
Processing credit cards used to require PCI compliance, bank integrations, and fraud detection — distributed systems problems that took teams of specialists. Stripe reduced it to a few API calls. Their retrospective describes the integration as "seven lines of code that felt magical." Deployment used to mean servers, load balancing, SSL, DNS, CDNs, autoscaling — then a whole category of tools (Vercel, Netlify, Railway, Fly) collapsed it into git push. Unreal Engine ate decades of graphics research so that solo devs can ship games without ever writing a shader.
The pattern is always the same: smart people solve a hard problem once, then package it behind a documented interface. This was designed to make things easier for human developers. But it makes things even easier for a pattern-matcher trained on millions of examples of people using those same interfaces.
AI is good at software because software got easier
The METR study found that experienced open-source developers were actually 19% slower when using AI tools on codebases they already knew well. METR's own follow-up acknowledges developers are likely faster with current tools than during the study period — but the improvements are concentrated exactly where you'd expect: the already-commodified tasks with established patterns and documentation.
That result makes sense once you think about what AI is actually doing. It's good where patterns are established, where the docs are thorough, where the problem has been solved thousands of times before in the training data. The more standardized and documented a problem is, the better AI performs at it. Another way of saying that: AI is best at the problems we already commodified.
The plumber reframe
Most commercial software development was always more like skilled trades than invention. Salaries were high because demand outstripped supply and because software has unusual leverage on revenue — one engineer can ship something that touches millions of users or dollars. Companies bid up for positions close to the money. That's rational, but it's not the same as the work being uniquely difficult.
Plumbing requires real knowledge — different domains, building codes, diagnosing problems in systems you can't see inside. Nobody pretends every plumber is reinventing fluid dynamics though. Most software work was probably always closer to that than many wanted to admit, and AI is making it harder to maintain the gap between the narrative and the reality.
Where novelty lives
The work that hasn't been commodified is the work that can't be — problems where there's no pattern to match yet, where the solution isn't in the training data because nobody's solved it before.
AI designs reasonable APIs for standard problems and writes working code for documented patterns. That's the whole point of the commodification argument — most of the work was already systematized enough for this to work. What AI hasn't demonstrated is solving genuinely novel problems, where you can't pattern-match because the pattern doesn't exist yet.
The training data iceberg
People consistently underestimate how much of what looks like AI "capability" is recall. A study on financial data found that GPT-4o has near-perfect recall of S&P 500 values from its training period — 0.01% error on data it was trained on, falling off sharply past the training cutoff date. It memorized the numbers. It's not reasoning about markets.
Something similar is happening with code. When AI produces a working solution for a common problem, some of that is matching against similar problems already solved by developers, already documented on Stack Overflow, already committed to GitHub. There is real inference happening in LLMs — I'm not arguing otherwise — but people underestimate how much of the base layer is just solved problems being repackaged. Hundreds of billions of dollars in VC funding went to build systems that are, in significant part, compressing and recombining work that human developers and data annotators already did.
AI looks most impressive where the ecosystem already did the hard work.
So what
Salaries normalize as more of the work becomes composing pre-solved pieces. That's not collapse, it's the profession adjusting to what it probably always was without the mystique around it.
The interesting work — architecture, figuring out what to build in the first place, understanding the actual problem you're solving, catching the places where the documented behavior doesn't match reality — that stuff doesn't go away. How work and society adjust to the shift is a different question, and I don't think anyone knows for sure yet.
The death-of-software-engineering discourse is wrong, but not in the way its defenders usually argue. AI writes code well because the industry spent a long time making code easier to write. Commodification first. Automation after.