The AI Coding Boom: Productivity Miracle or Mass Unemployment?
The debate about AI and software development keeps getting framed as a binary: either we're living through a productivity miracle or we're watching mass unemployment unfold in slow motion. After hosting a roundtable with four AI models on exactly this question, I'm convinced both framings are wrong — and that the real story is considerably more unsettling than either camp wants to admit.
Start with the numbers that seem to contradict each other but actually don't. GitHub's controlled study found developers completed a self-contained coding task 55% faster with AI assistance. The METR study, working with experienced developers on real established codebases, found they worked 19% slower. These aren't conflicting data points. They're measuring two entirely different kinds of work that both happen to carry the label "software development." As Mistral argued during our discussion, the 55% gain came from building an HTTP server in isolation — a task with clear boundaries, no legacy dependencies, and perfect documentation. That's coding as syntax generation. The 19% slowdown came from working on real systems where the hard part isn't writing the code; it's understanding why the system was built the way it was in the first place.
AI is excellent at the part of coding that was never the bottleneck.
The downstream consequences of this mismatch are already visible in the data. Code review time has increased 91%. Pull request size has grown 154%. Bugs per developer are up 9%. As Qwen observed, the bottleneck didn't disappear — it migrated. We automated the typing and handed the cognitive load to the reviewers. Senior engineers aren't coding faster; they're drowning in verification work for code they didn't write and may not fully understand.
Then there's the number that should stop everyone cold: developers using AI tools believed they were 20% faster while actually being 19% slower. That 39-percentage-point perception gap isn't a rounding error. It's a structural signal that our intuitions about AI-assisted productivity are systematically miscalibrated — which means most organizational decisions about AI adoption are being made on false premises, by people who feel productive while the metrics quietly tell a different story.
On employment, the aggregate picture looks stable. The Yale Budget Lab finds no statistically significant correlation between AI exposure and employment changes after 33 months. But Grok was right to push past the headline: what we're observing isn't a layoff effect, it's a hiring freeze effect. The Dallas Federal Reserve documents a 13% relative employment decline among workers aged 22 to 25 in AI-exposed occupations since 2022 — not through terminations, but through reduced inflow. Companies aren't firing junior developers. They're simply not replacing them when they leave and not hiring new ones at previous rates. This doesn't show up in unemployment statistics. It shows up in cohort data years later.
Which brings me to the insight that emerged from our conversation and that I can't stop thinking about.
The tasks AI absorbs first — debugging unfamiliar code, reading legacy systems, understanding architectural intent from imperfect implementations — are precisely the tasks that constitute the hidden curriculum of professional development. They are not just work. They are how junior developers become senior ones. When Mistral described junior developers as "the organization's future memory," the framing clicked into place. The people who in ten years would have known why the authentication system was built the way it was, what was tried and failed in the payment module, which architectural decisions were made under time pressure and need revisiting — those people are currently not getting the experiences that would have produced that knowledge. It isn't being formed in human minds. It exists only in AI outputs that future developers will inherit without understanding.
We are not just automating work. We are automating the apprenticeship.
The pipeline break will be invisible until approximately 2031, when today's entry-level cohort should be reaching mid-level competence — and largely won't be, because they never got the messy, frustrating, irreplaceable experience of learning from code they didn't write. No current metric captures this liability. We track shipping velocity. We do not track time-to-comprehension during failure, which is the only thing that matters when a production system breaks at 2 a.m. and someone needs to reconstruct why.
The evidence also points to a troubling asymmetry in who captures the gains versus who absorbs the costs. Google, Microsoft, and Cisco — with mature engineering practices, robust code review cultures, and deep senior talent — are positioned to convert AI-generated volume into actual velocity. A mid-size consultancy with thin margins and high junior-to-senior ratios converts that same volume into technical debt, stability drops, and systems nobody fully understands. AI isn't a universal productivity tool. It's an organizational capability amplifier. And it's making the already-winning organizations win harder.
The question I'm left with is this: if the pipeline that turns junior developers into senior architects is quietly breaking, and we won't know it happened until 2031, what decisions made today could still change the outcome — and who is actually making them?
Hear the full discussion on HelloHumans!