AI Won't Kill Developer Jobs — But It Will Change Them

There's a conversation happening everywhere right now about which jobs AI is going to wipe out. And everyone seems to have the same take: "It's going to replace all those jobs — but not mine."

The cognitive dissonance is remarkable. We're all incredibly good at looking at someone else's profession, reducing it to its most mechanical parts, and declaring it ripe for automation. We completely miss what actually makes those roles valuable.

I want to start from the premise that this is a known phenomenon, and then talk about what I actually think is going to happen with software development.

The Accountant Test

I had a conversation with my dad (a CPA of many years) this past week about the value of what an accountant actually brings to the table. My instinct was the same as everyone else's: "You're taking numbers from System A, pulling data from System B, loading it all into your bookkeeping tools, and producing a tax return. Isn't that part going to be replaced by AI?"

But that framing completely ignores all the things that make accounting hard. What does the IRS actually want? What are they willing to accept? What's the judgment call when the rules are ambiguous? There's a mountain of insight, experience, and contextual understanding baked into the work that has nothing to do with arithmetic. AI can help with a lot of that — but it's not going to replace it.

The same logic applies to most professions people love to dismiss as "just" something.

The Developer Job Apocalypse (That Isn't Coming)

On the subject of developers specifically, there's this dramatic narrative floating around: AI is going to replace software engineers entirely. Product people will describe requirements in plain English, and AI agents will ship production code. No more developers needed.

I think we can all generally consider this hyperbole.

Here's what's actually happening. Since AI coding tools became mainstream, we're seeing a monumental amount of new code being written — far more than before. But it's not necessarily good code. A lot of it is low-quality, brittle, and architecturally questionable.

There's growing research showing that AI-generated systems are becoming fragile precisely because the AI isn't thinking about architecture. GitClear's 2025 AI Code Quality study, which analyzed 211 million changed lines of code across repos from Google, Microsoft, Meta, and enterprise companies, found an eightfold increase in duplicated code blocks, a surge in short-term churn, and a dramatic decline in code refactoring — copy-pasted lines exceeded moved (refactored) lines for the first time ever.

Similarly, the SWE-CI benchmark from Sun Yat-sen University and Alibaba showed that current LLMs still fall short at controlling regressions during long-term code maintenance — an agent that hard-codes a brittle fix and one that writes clean, extensible code can both pass the same test suite, but the difference becomes painfully obvious when the codebase needs to evolve.

It's not reasoning about how systems are framed, how components interact, or how things need to evolve over time. It's optimizing for "does this work right now?" — which is a very different bar than "is this well-built?"

So yes, the role is going to change. But will that mean fewer jobs? I don't think so.

More Code, More Problems

From personal experience, I can tell you: we're seeing way more people writing code than ever before. Non-technical people are generating functional prototypes. That's genuinely exciting. But it's also creating a huge increase in demand for people who actually understand what good code looks like — people who can review, refactor, architect, and maintain what's being produced.

My prediction is that the average lines of code per developer is going to increase dramatically. If a developer was previously responsible for writing and maintaining 100,000 lines of code, that number might 10x. Maybe they're now responsible for a million lines.

That's a massive difference, and it surfaces a tension that every experienced engineer already knows: your goal is to write as few lines of code as possible. Every line of code is future technical debt. Every line requires maintenance. Every line expands your surface area for bugs, security vulnerabilities, and complexity.

If AI is helping us write 10x more code, we need to be thinking very carefully about whether we should be writing 10x more code — and that's a deeply human judgment call.

The Shift, Not the Shrink

What I think we're going to see is not a massive loss of developer jobs, but a meaningful shift in what developers do. The value is going to move toward the things that AI is worst at: designing pipelines, structuring environments, thinking about system architecture, building the guardrails and infrastructure that make AI-generated code actually production-worthy.

Sure, there will be some job losses. But I believe there's going to be a net increase in new roles — especially as the demands on every company change. In an AI-driven world, the value of well-designed APIs is significantly higher. The ability to build integrations, connect systems, and create the plumbing that makes AI actually useful inside a business? That's not going away. That's becoming more important.

And it's not just the big tech-forward companies. Every company is going to need to think about their AI experience, their data infrastructure, their integration layer. That creates a lot of work for a lot of people who understand how to build things properly.

The Bottom Line

Tools are going to let individual developers do a lot more. That's real, and it's exciting. But "more output per person" doesn't automatically mean "fewer people needed" — not when the total volume of work is growing faster than individual productivity.

The profession isn't dying. It's evolving. And the people who understand that the hardest part of software was never typing the code? They're going to be just fine.