The email landed on a Tuesday, forwarded from a friend who had spent all weekend doomscrolling. Subject line: "Is this the end?" A graph of January layoffs, a headline about AI-written code, a thread arguing the bootcamp career path was now worthless. He is a good engineer. He is terrified.
I get it. I run a software firm from a small town on Delaware's coast, and I have felt the same spike of dread reading this week's numbers. But here is what I have come to believe, after talking to founders, reading the actual studies, and watching my own team adapt: the 'death of software engineering' is real, and it is the best news our profession has had in years. What is dying is the rote, syntactical 'code monkey' work. What that clears room for is the scarce, valuable, well-paid core of the discipline — architecture, judgment, and product ownership. The engineers who want to keep doing exactly what they did in 2019 are in trouble. The engineers who build things are entering a golden age.
The productivity numbers tell the real story
Start with the data everyone is citing, because it is real. Developers using GitHub's Copilot complet[/]d coding tasks about 55% faster than those without it, per GitHub's own research, and by 2025 the tool was generating roughly 46% of the code its users shipped, up from 27% in 2022. Skip ahead to Google's numbers and the shift looks even more absolute: CEO Sundar Pichai said in April 2026 that 75% of the company's new code is now AI-generated and reviewed by engineers, up from 25% in 2024 (Business Insider). When nearly half of your output writes itself, and the biggest engineering organizations on Earth are racing to that mark, it is not paranoid to wonder whether the job itself is next.
Yet read those numbers again. Copilot's 55% acceleration is a head start on a task, not a replacement for the engineer who decides what to build and how. Google's 75% figure comes with a caveat in the same sentence: that code is generated and then reviewed by human engineers. Nobody at Google is shipping 75% of anything without a person deciding whether it is right. The percentage of code that writes itself is climbing. The percentage of that code a machine can be trusted to deploy without human judgment is still zero.
The honest counterargument: the ladder really is hollowing out
Before I celebrate, let me steel-man the fear my friend forwarded, because it holds a truth I would be lying to ignore. The entry level is quietly collapsing. A Stanford analysis found employment rates among younger software developers have fallen about 20% since late 2022, as AI agents take over code migration and routine refactoring (DevOps.com). Marc Andreessen has publicly called the panic over AI and jobs "totally off base," and his firm's post counters the fear of software going extinct by arguing that AI changes who builds software but not how much the world needs of it — in its own words, "We need vastly more software, not less" (Andreessen Horowitz). That confidence sits uneasily beside a real squeeze: the junior titles, the entry slots where a newcomer used to learn by grinding out CRUD and unit tests, are exactly the tasks AI automates first. A decade of 'learn to code' pipelines now dumps graduates into a market where the cheapest rung of the ladder has been kicked away.
That squeeze is genuine, and I do not want to talk anyone out of it. What I want to correct is the wrong conclusion too many people draw from it.
What actually survives is not the typing
That is not a demotion. It is a promotion to the role the profession always claimed to hold but rarely actually rewarded. Pichai himself described the shift to "truly agentic workflows" where engineers run more autonomous tasks and increasingly orchestrate systems instead of hand-typing every line (Business Insider). The engineer who knows the domain, owns the result, and can tame an agent's confidently-wrong output is worth more, not less, when generation is free.
Here is the uncomfortable statistic on the other side of the doom scroll: only 33% of developers trust AI output to be accurate, yet 84% use it anyway (byteiota). Every one of those wary, flinty, can-I-ship-this users is a human doing the scarce work of deciding. The tool is the tide. The judgment is the shore.
So what do we do with the good news? Two things. First, stop mourning the syntax. The line of code was never the product; the product that ships and the outage that never happens are. Second, spend the hours AI just gave back on the things it cannot do for you: the domain you can argue about from experience, the architecture you can defend under pressure, the call you can make when the agent is confident and wrong. Andreessen's most useful line in this debate is aimed straight at anxious engineers: "Don't be fungible." (Lenny's Podcast)
The career that dies is the one that priced itself by the keystroke. The career that survives is the one that sells judgment, and that supply is about to become the rarest thing in technology. Software engineering is not leaving us. It is finally being promoted to the job description we wrote for it decades ago. My friend is going to be fine — once he stops rereading the rumors and starts rereading the contract between what AI automates and what it still cannot decide.
Discussion