Is Your Programming Career Already Running in Production Without You?

Half the Code Was Already Written by a Robot and Nobody Held a Funeral

Nobody announced that artificial intelligence was ending programming as we knew it. There was no press conference, no solemn Reuters headline, no moment where the industry collectively put down its mechanical keyboards and said "well, that's that then." The robots just started writing the code, and everyone sort of... let them.

And now here we are: by the end of 2024, 46% of new code on GitHub was AI-assisted, which is less a statistic and more a confession that arrived three years too late to be shocking.

Here's the part that should make you set down your coffee. Google, a company that employs some of the most credentialed software engineers on the planet (people with more degrees than a thermometer, people who could probably debug the universe given enough RAM), reported in 2025 that AI was writing 21% of their new code.

Twenty-one percent. Not some scrappy startup trying to ship fast and apologize later. Google. The company that wrote the internet's plumbing.

Meanwhile, GitHub Copilot Agent alone generated over one million pull requests between May and September 2025. Four months. One million pull requests. To put that in scale: that's roughly the output of a small country's entire developer workforce, produced by something that doesn't take lunch breaks or passive-aggressively ignore Slack messages.

Stack Overflow found that 84% of professional developers were using or actively planning to use AI coding tools by late 2025. The transition from "developer types syntax" to "developer supervises robot that types syntax" is not a forecast — it is a changelog, already merged, already deployed, already running in production while everyone was still arguing about whether it was going to happen.

Jensen Huang and the Annual Ceremony of Declaring Traditional Programming Dead

Jensen Huang would like you to know that AI has increased developer productivity value from three trillion dollars to nine trillion dollars. That's a six trillion dollar jump, which is a number so cosmically large it stops functioning as information and becomes more of a spiritual experience, like being told the universe is 93 billion light-years wide — technically true, experientially meaningless. Huang has made some version of this announcement at enough conferences now that it qualifies as a recurring calendar event, like tax season or a solar eclipse, except louder and with better lighting.

Elon Musk, characteristically, decided Huang's version wasn't unhinged enough. His prediction is that by late 2026, AI will generate optimized machine code directly, bypassing human programming languages entirely. Python, Java, whatever you learned at that bootcamp you spent four months and eight thousand euros on — just abstraction layers for nostalgia at that point, apparently.

Here's the thing about these proclamations that nobody wants you to understand: the people making them are not going to be writing the code either way. They haven't been writing code for decades. They manage people who manage people who manage the people writing code.

Their relationship to actual programming is roughly the same as a restaurant owner's relationship to chopping onions.

Meanwhile, the market confirms the chaos is real and profitable. Cursor hit two billion dollars in annual recurring revenue by February 2026. The AI code generation market sits at $4.91 billion today and is projected to hit $30.1 billion by 2032.

Someone is getting extraordinarily rich off this transition. It is not the junior developer.

The Trust Numbers Are Going the Wrong Direction and Everyone Is Pretending Not to Notice

Developer trust in AI-generated code dropped from 40% in 2024 to 29% in 2025. Adoption went up. Confidence went down. These two facts coexist in the industry like a car that's technically running but making a sound the mechanic described as "concerning but probably fine."

The problem is not the code that explodes immediately on contact with reality. Catastrophic failures are easy — they show up in testing, someone fixes them, life goes on. The genuinely terrifying output is the code that is almost correct: compiles cleanly, passes review, survives staging, then fails in production at 2 AM in a way that takes nine senior engineers and a shared Google Doc to untangle. That's the category nobody in a product demo mentions.

Devin — the autonomous AI software engineer marketed as the thing that was supposed to make all other software engineers deeply anxious — autonomously resolves 13.86% of real-world GitHub issues. That number is real. It is also, depending on your level of optimism, either impressive for a first-generation autonomous agent or a fairly stark reminder that 86% of the problems still need a human.

More code is being produced than at any point in history. Better code is a separate conversation, one the industry is having very quietly, mostly in postmortem documents nobody publishes.

The Junior Developer Is Not Dead, But Their Career Ladder Has Been Quietly Removed

Picture this: it is 2019, and somewhere in a slightly too-warm open-plan office, a twenty-three-year-old named Máté is writing his four hundredth CRUD endpoint. He hates it. It is boring, repetitive, and he keeps googling the same Stack Overflow thread.

But he is also, without knowing it, building the mental model that will make him a senior engineer in six years — the specific, granular, failure-shaped knowledge that comes from writing the wrong thing and watching it break in production at 2 AM. That pipeline is now being automated shut.

Stanford researchers, pulling from ADP payroll data, found a 19% employment gap for workers aged 22 to 25 in AI-exposed occupations. Not a rounding error. Not a blip. A crater, shaped exactly like "entry-level tech job," with the outline still smoking.

Dario Amodei, the CEO of Anthropic — the company that makes the AI eating the junior developer's lunch — estimates that AI could eliminate up to 50% of entry-level white-collar jobs within five years. He said this calmly, the way you tell someone their flight is cancelled while holding their boarding pass.

The cruel punchline is that junior developers using AI now produce quality-adjusted output comparable to unassisted senior developers. That sounds like a win. It is not a win.

The entry-level role never existed to fill headcount — it existed to manufacture the senior engineers of 2031. Nobody has figured out how to automate the seven years of suffering that makes someone good enough to catch what the AI gets subtly, catastrophically wrong.

The Competency Trap, or: We Let the Algorithm Do the Debugging and Now Nobody Knows How Anything Works

Compare this to how a generation of kids grew up using GPS and lost the ability to read a map. Fine, mostly. Until the signal drops and you're in rural Slovakia. The software industry is currently sprinting toward that exact ditch, and the car is going sixty.

LLM reliance creates a documented competency trap where developers stop acquiring deep debugging expertise because they simply never needed to acquire it. The skills being automated away are precisely the skills required to catch the mistakes made by the automation. That's not irony, that's a structural catastrophe wearing a productivity-gains name badge.

The skills being automated away are precisely the skills required to catch the mistakes made by the automation.

Senior engineers are now the last line of defense against subtle AI-generated bugs and security flaws, which sounds reassuring until you remember we stopped making senior engineers. The junior-to-senior pathway historically ran through manual debugging, ugly code reviews, and three years of fixing someone else's spaghetti. That pathway now routes through "accept AI suggestion, ship, wonder later why production is on fire."

Then there's vibe coding, which is exactly what it sounds like: non-technical users building actual production applications using only natural language descriptions and ambient optimism. No technical knowledge required. Real production consequences very much included.

It is, genuinely, the most unhinged thing to happen to software since someone decided blockchain needed to be in everything — and the consequences are going to be substantially less funny than the pitch decks.

Estonia Is Doing Something Structurally Sane About This, Which Is Unusual and Worth Noting

Most countries are handling the AI-in-education question by forming committees, commissioning studies, and scheduling conferences about the committees that will commission the studies. Estonia is not doing that.

TalTech's tehisaru strategy, led by Ingrid Pappel, operates from a position that is almost aggressively obvious once you read it: AI does not assume responsibility for creation. Humans own the output. The tool does not get the grade.

That sentence should be a legal requirement printed above every AI code editor, but here we are, discussing it as if it's a radical position. The 2025/26 TI-Hüpe program takes this further — deploying a learning app specifically designed to scaffold understanding rather than hand students finished answers. The pedagogical bet is that a student who learns to verify, validate, and question AI output will outlast the one who learns to prompt their way to a passing grade.

Mark Fišel at Tartu University is teaching practical AI implementation with a consistent emphasis on algorithmic thinking over rote syntax. The underlying logic here is data-driven: if 46% of new GitHub code is already AI-assisted, drilling students on manual syntax is the educational equivalent of teaching navigation by the stars to people who will spend their careers indoors.

Estonia, a country of 1.3 million people, is quietly making a structural bet that oversight is the durable skill. Nobody else seems to have noticed.

Anyway, AI Is Ending Programming From the Inside and We Have Questions Nobody Is Answering

Nobody actually knows if the 19% junior employment gap is a dip or a cliff. It could be a temporary market spasm, the kind that resolves itself in three years when everyone adjusts and writes a Medium post about resilience. Or it could be permanent structural collapse wearing the costume of a temporary adjustment, which is a very specific type of catastrophe that economists love to name only after it's too late.

Then there's Jevons Paradox, which states that making something cheaper to produce doesn't reduce demand — it explodes it. Cheaper software means more software, which means more software to maintain, which means someone has to maintain the vast AI-generated codebases that currently have the documentation quality of a receipt from a vending machine. Nobody is answering who that someone is.

Artificial intelligence doesn't end programming. It ends programming as the entry point — which is where everyone starts, which is where expertise is built, which is apparently now closed for renovations with no reopening date posted.