The narrative that AI will render software developers obsolete has become something of a parlor game in tech circles. It makes for compelling headlines and conference keynotes. But the reality on the ground, the reality that engineering managers, CTOs, and developers themselves are living through, tells a far more nuanced and interesting story.
The Boomerang Effect
Here's a phenomenon that hasn't received nearly enough attention: boomerang hiring. Companies that laid off engineering teams in favour of AI-driven development are quietly hiring them back. Not because AI failed, exactly, but because the organisation discovered something fundamental about the relationship between human expertise and machine capability.
The pattern goes something like this. A company embraces AI coding assistants, sees an initial burst of productivity, and concludes that it can operate with a leaner team. Engineers are let go. Weeks pass. The codebase accumulates subtle issues, architectural decisions that no one questions because no one understands the original intent, edge cases that slip through automated tests, performance regressions that compound quietly. Eventually, the company rehires, often the very people it let go, at a premium.
"AI can write code. It cannot own code. There is a profound difference between generating syntax and bearing responsibility for a system that serves millions."
This isn't a failure of AI. It's a misunderstanding of what software development actually is. Writing code is perhaps 20% of the job. The rest is understanding context, navigating trade-offs, reading the intentions embedded in a codebase by its original authors, and making judgment calls that no training data can fully prepare you for.
The Productivity Paradox
Studies and industry reports consistently show that AI coding tools deliver genuine productivity gains, in some cases, dramatic ones. GitHub's research suggests developers complete tasks up to 55% faster with Copilot. Amazon reported similar improvements with their internal tools. These numbers are real, and they matter.
But productivity gains in software development are not straightforward arithmetic. Writing code faster does not mean shipping software faster. It does not mean shipping better software. And it most certainly does not mean spending less time on the activities that actually determine whether a project succeeds or fails.
Consider the time equation. If an AI tool helps a developer write a function in 10 minutes instead of 30, that's a 20-minute saving. Brilliant. But if the code review for that function now takes 40 minutes instead of 15, because the reviewer must carefully examine unfamiliar patterns, interrogate assumptions the AI made, and verify that the generated code actually does what it appears to do, then the net gain is negative.
The Code Review Bottleneck
This is the elephant in the room that few AI evangelists want to discuss: code review has become the new bottleneck.
When humans write code, reviewers can leverage shared context, the author's habits, their understanding of the system, the conventions of the team. When AI generates code, that contextual scaffolding is absent. The reviewer must treat every AI-generated suggestion as if it were written by a talented stranger who left no notes.
And AI-generated code has a particular quality that makes it harder to review: it looks confident. It's syntactically perfect, well-structured, and presented with the quiet authority of a system that has no self-doubt. This confidence is precisely what makes it dangerous. A junior developer's code raises natural skepticism. An AI's code lulls you into acceptance.
"The most perilous code is the kind that looks correct. AI produces nothing but that."
The result is a paradox: AI generates code faster, but humans review it slower. The overall cycle time may improve modestly, but the cognitive load on senior developers, the people whose judgment holds the whole system together, increases substantially. And those are precisely the people you cannot afford to burn out.
What AI Actually Does Well
None of this is to diminish AI's contribution to software development. It's genuinely transformative in specific, well-defined areas:
Generating repetitive code, configuration files, and standard patterns, the tedious work that drains creative energy.
Rapidly understanding unfamiliar codebases, languages, or frameworks. AI is an exceptional tutor.
Producing a starting point that a developer can refine. The value isn't in the output, it's in eliminating the blank page.
Creating comprehensive test cases, edge cases, and mock data. This is genuinely time-saving and improves quality.
What AI Cannot Do
AI cannot hold a system in its head. It doesn't understand why a particular design decision was made three years ago in response to a production incident that nobody documented. It doesn't know that the finance team relies on a seemingly unused field, or that the API endpoint that looks redundant is actually serving a critical integration.
More fundamentally, AI cannot exercise engineering judgment. It cannot weigh the trade-off between shipping quickly and building something maintainable. It cannot read the room in a design review. It cannot push back on a product requirement that sounds reasonable but will create a maintenance nightmare six months hence.
Software development, at its core, is an exercise in managing complexity under uncertainty. AI excels at pattern recognition within known domains. It struggles, genuinely struggles, with the novel, the ambiguous, and the political.
The Real Future: Augmentation, Not Replacement
The most productive engineering teams in 2026 aren't the ones that replaced developers with AI. They're the ones that gave their developers AI tools and trusted them to use those tools wisely. The distinction matters enormously.
Augmentation means a senior developer can spend less time on grunt work and more time on architecture, mentoring, and the kind of deep thinking that produces elegant systems. It means a mid-level developer can level up faster by having AI explain unfamiliar code and suggest patterns. It means a junior developer can be productive sooner without forming bad habits that will haunt them later.
But this only works when there are experienced humans in the loop, people who can distinguish between code that is merely functional and code that is correct, maintainable, and aligned with the system's broader architecture.
"The best developer in 2026 isn't the one who writes the most code. It's the one who asks the right questions of the code the machine provides."
A Word of Caution
The boomerang hiring trend should serve as a cautionary tale for any organisation tempted to treat AI as a replacement for human expertise. The short-term productivity numbers can be seductive. But software is a long game. The costs of replacing developers with AI don't appear on the quarter's balance sheet, they manifest over months and years, in accumulated technical debt, in lost institutional knowledge, and in teams that lose the ability to make sound engineering decisions.
The organisations that will thrive are those that pair AI's remarkable capabilities with human judgment, experience, and accountability. Not because AI isn't powerful, it is. But because building software that matters requires something more than power. It requires wisdom. And wisdom, for now, remains a human endeavour.