Are AI agents replacing software engineers?

The Replacement Panic vs. the Adoption Reality

The numbers sound alarming at first glance. According to the Stack Overflow 2025 survey, 84% of developers now use or plan to use AI tools, and the JetBrains Developer Ecosystem Survey found 90% of professional developers use coding agents at least weekly — 68% of them daily.

At the frontier, the picture is even more striking. Boris Cherny, creator of the TypeScript compiler at Meta, shipped roughly 200 pull requests written entirely by Opus 4.5 in a single month without opening an IDE, as The Pragmatic Engineer reports. If agents can do that, the reasoning goes, why hire engineers at all?

The tension sits in the productivity data, which tells two very different stories:

• Developers self-report 30–60% time savings from AI tools
• A controlled METR trial found experienced developers were 19% slower with AI than without it
• Those same METR participants predicted they'd be 24% faster and afterward believed they had been 20% faster

That gap between perception and measurement is why the replacement narrative deserves scrutiny. As this analysis of the latest research notes, developers confidently misjudged their own speed in both directions — before and after the trial. Self-reported gains, in other words, are not evidence of replacement-level capability.

The organizational data reinforces the caution. A Harvard study of 700+ firms and 700,000+ employees found AI agents boosted code volume substantially — more lines, more commits, more pull requests — but produced no statistically significant increase in resolved issues or epics, and no reduction in employment. More code, in short, is not the same as more software.

What's actually happening is a restructuring of the engineer's role, not its elimination. The Harvard data shows review time up 49% and the share of workers doing code reviews up 14%, meaning human judgment is becoming more central, not less. Elite practitioners with strong workflows — and well-equipped agents — benefit; average outcomes lag behind.

That last point matters for anyone building agent workflows: what your agent loads shapes what it produces. SkillzBench is building a free directory that security-scans and benchmarks agent skills, so teams can equip agents only with capabilities that actually help rather than hinder — one small way to close the gap between the hype and the measured reality.

What 700 Firms of Data Actually Show: Restructuring, Not Replacement

If AI agents were truly replacing software engineers, the largest dataset ever assembled on the question would show it. Instead, it shows something stranger: firms are generating far more code while producing essentially the same amount of software.

A Harvard study of 700+ firms and 700,000+ employees — built on 300 million work events between 2021 and March 2026 — found that AI agents boosted code volume by 30% in lines of code and 23% in pull requests. Yet the same study found no statistically significant change in Jira Issues or Epics resolution, and no significant change in employment.

Where did the gains go? Straight into the human bottleneck. Review process time jumped 49% and comments per PR rose 35%, while the share of workers doing code reviews increased 14%. Even though 80% of firms use AI code review, AI produced only 23.3% of review comments — humans still do the overwhelming majority of verification work.

The labor market tells the same restructuring story:

• AI-fluent developers report 50%+ wage bumps and promotions arriving twice as fast, per PwC data
• Early-career tech employment has dipped roughly 20% from 2022 peaks in some markets
• BLS still projects 15–18% software developer job growth through 2034
• Goldman Sachs estimates ~25% of work hours could be automated, but only ~6–7% of jobs disappear entirely

In other words, the profession is splitting, not dying. Seniors who treat AI as a "turbocharged intern" report 2–2.5x output, while junior spec-to-code translator roles shrink. Rising value sits in architecture, product-mindedness, and validating generated code — not raw typing speed.

One caveat deserves attention: the METR controlled trial found experienced developers were actually 19% slower with AI tools, even while believing they were 20% faster. Skill matters enormously. Teams that succeed with agents invest in planning-first workflows, strong test suites, and careful vetting of what agents are allowed to do — including the skills and extensions they load, which is exactly the problem SkillzBench is building its free directory, security scanning, and benchmarking to solve.

The data is unambiguous: agents amplify capable engineers and expose unprepared teams. Replacement isn't happening — restructuring is, and it rewards those who adapt first.

The New Engineer: Specifying, Orchestrating, and Reviewing

Something quietly profound is happening to the job title "software engineer": many of the best ones now spend more time directing machines than typing into them. The market has shifted decisively toward delegated agent workflows, where engineers hand complex multi-file work to agents like Claude Code while keeping specification, architecture, and review firmly in human hands, according to developer ecosystem research.

Addy Osmani calls this "AI-assisted engineering": leveraging AI aggressively while staying personally accountable. His advice is to treat the LLM as a powerful pair programmer that needs clear direction, context, and oversight — not autonomous judgment. The craft is moving toward writing precise specs, planning, and what he calls "context packing" before a single line is generated.

The pattern is visible inside enterprises, too. JM Family assembled a genuine multi-agent team — a requirement agent, a story writer, a coding agent, a documenter, and an orchestrator coordinating them all. Yet even there, engineering leader Amit Sethi insists on keeping a human in the loop. The agents produce; humans stay accountable for what ships.

The data backs up this division of labor. A Harvard study of 700+ firms found AI boosted code volume by 30% but review process time rose 49%, with 14% more workers doing code reviews. Humans still produce the vast majority of review comments — AI generated only 23.3% of them. Reviewing, it turns out, is where engineering judgment now concentrates.

Where you deploy agents matters as much as whether you do:

• Agents excel at greenfield projects, prototypes, and startups chasing product-market fit, where mistakes are cheap and speed is everything.
• Humans stay in the loop for high-risk codebases, production systems, and anything where a wrong answer costs real money or trust.
• Strong test suites determine how much you can safely delegate — teams with good coverage extract the most from agents.
• Benchmark scores mislead: models solve 84–89% of toy problems but only 25–34% of real production-repository tasks, per research analysis.

As agents take on more of the pipeline, what they're instructed to do becomes a supply-chain question. SkillzBench is building a free directory that security-scans, validates, and benchmarks agent skills (with a trust score and measured Lift), plus a free MCP connector — so you can equip your agents only with capabilities that have actually been vetted. Skills, proven — browse the directory and join the waitlist to see how your orchestrator agents can be verified before they touch your codebase.

How to Win the Shift: Workflow, Review Capacity, and Vetted Tools

The scariest number in AI-assisted development isn't about job losses — it's the METR randomized trial where experienced developers using Cursor were 19% slower than a control group, even though they believed they were faster. The difference between engineers who win this shift and those who lose time to it comes down to workflow discipline, and you can design for it deliberately.

Start with planning-first, small-chunk workflows. Addy Osmani's documented approach treats the LLM as a "powerful pair programmer that requires clear direction, context and oversight" — detailed specs before generation, tight iterative loops, and deliberate context packing so the agent has what it needs. Small chunks matter because they keep review tractable: agents excel at bounded tasks and drift on sprawling ones, and LLMs that solve 84–89% of toy benchmark problems drop to 25–34% accuracy on real production-repository code, per analysis of the latest research.

Second, expand review capacity before you expand code generation. The Harvard study of 700+ firms found AI drove +30% lines of code and +23% pull requests — but review process time rose 49% and comments per PR climbed 35%, absorbing the gains entirely. Teams that pair agent adoption with stronger test suites and protected reviewer time capture the productivity; teams that don't just move the bottleneck.

Third, stay multi-tool rather than betting on one agent. Current usage data shows Claude Code at 39%, GitHub Copilot at 21%, OpenAI Codex at 16%, and Cursor at 12% of workplaces — and senior engineers increasingly combine tools by task: inline editors like Cursor or Copilot for daily editing, Claude Code for delegated multi-file work. Delegate greenfield and low-risk work; keep humans driving in high-risk codebases.

Finally, vet what your agents load. As agents touch most of your codebase, the skills and instruction packages they run become part of your supply chain — and published research has found roughly 26% of agent skills carry at least one vulnerability. That's the problem SkillzBench is being built to solve: a free, independent directory that security-scans, verifies, and benchmarks agent skills — pinning each version to a commit SHA, testing every skill in a sandbox with and without it, and publishing both a 0–100 trust score and a measured Lift. A free MCP connector will let teams equip each agent only with the vetted skills they choose.

The teams that pair disciplined workflows with deliberate tooling and a vetted agent supply chain will be the ones the Harvard data can't explain — the ones actually converting more code into more software.