A senior software engineer reviews code on two monitors.

AI Coding’s Impact on Senior Engineers: What the Evidence Actually Shows

Key Takeaways

  • "AI coding impact senior engineers" is a breakout search, and the evidence behind it is genuinely mixed: the best studies point in different directions depending on who is coding and what is being measured.
  • The most discussed result, a METR randomised trial from July 2025, found experienced developers took 19 percent longer on real tasks when allowed to use AI tools, even though they believed they were 20 percent faster.
  • The largest field evidence, three randomised trials covering 4,867 developers at Microsoft, Accenture, and a Fortune 100 company, found Copilot users completed 26.08 percent more tasks per week, with the largest gains going to less experienced developers.
  • A METR follow-up published in February 2026 pointed to a speedup with newer tools, but METR itself called the data very weak evidence because of selection effects.
  • The consistent pattern is that senior engineers gain least on raw typing speed and most on work that needs judgement: architecture, code review, steering AI output, and mentoring.
  • No credible study shows senior engineers becoming obsolete. The evidence shows their value shifting from writing code to deciding what code should exist and whether it is correct.

Searches for "ai coding impact senior engineers" are breaking out on Google Trends, with related interest in DeepMind rising sharply and MiniMax also climbing. The question behind the search is a worried one, and it is usually asked in one of two forms. Are senior engineers about to be replaced by AI coding tools? Or are senior engineers the ones who benefit least from those tools, while juniors catch up?

Both questions have answers in the research, and neither answer is simple. The evidence is real, it comes from randomised trials rather than marketing claims, and it points in different directions depending on what you measure. This article reviews the studies that matter, explains where they agree and where they conflict, and sets out what the evidence actually means for an experienced engineer deciding how to work with AI coding tools in 2026.

The Study Everyone Is Arguing About

The single most cited piece of evidence is a randomised controlled trial published by METR in July 2025. METR, short for Model Evaluation and Threat Research, is a nonprofit research organisation that evaluates AI systems. The paper, "Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity", was written by Joel Becker, Nate Rush, Elizabeth Barnes, and David Rein.

The design was unusually close to real work. Sixteen experienced open-source developers worked on 246 real issues in repositories they had contributed to for years, codebases averaging more than a million lines of code. Each task was randomly assigned to allow or forbid AI tools. The developers mainly used Cursor Pro with Claude 3.5 or Claude 3.7 Sonnet, including chat, agent mode, and autocomplete features. The tools available covered February to June 2025.

The measured result surprised almost everyone, including the participants. Developers took 19 percent longer to complete tasks when they were allowed to use AI tools. The 95 percent confidence interval ran from 2 percent to 39 percent slower, which means the true effect could have been small or large, but the study's best estimate was a slowdown, not a speedup.

The perception gap was more striking than the slowdown itself. Before starting, the developers expected AI to make them 24 percent faster. After finishing the tasks and being measured, they still believed it had made them about 20 percent faster. Measured reality said 19 percent slower. Belief said 20 percent faster. The gap between the two is roughly 39 percentage points, and it appeared among experienced engineers reflecting on work they had just completed.

That gap is the most important finding in this whole area, because almost every confident claim about AI productivity rests on self-reported impressions of exactly the kind this study found to be wrong. When a developer says a tool makes them faster, they may be reporting a genuine feeling, a real reduction in effort, or a real enjoyment of the work. They are not necessarily reporting measured completion time. The METR trial is valuable precisely because it measured completion time rather than asking for opinions.

METR itself was careful about what the study did not show. The researchers explicitly stated that it was not evidence that AI fails to speed up most developers, since 16 people on mature open-source projects is not a representative sample, and not evidence that current AI cannot be used more effectively to get a real speedup. The trial covered tools available in early 2025. Those tools are not the tools available now.

Why the Slowdown Happened

Understanding why experienced developers slowed down matters more than the headline number, because the reasons reveal where senior engineers' real work lies.

The first reason is context. An experienced developer working in a codebase they know intimately already holds in their head the information an AI must infer from files, documentation, and history. The AI has to reconstruct context the developer already has. That reconstruction takes time, and it takes the form of prompts, corrections, and review of output that does not quite fit the codebase's conventions.

The second reason is review burden. AI-generated code must be read, checked, and often corrected. For a senior engineer, that review work is not trivial. They are the person who knows whether a proposed change breaks an implicit contract between two systems, violates a security assumption, or introduces a subtle performance problem. Reading and verifying AI output can take as long as writing the code would have taken, and in a mature codebase the verification burden is high because the cost of a mistake is high.

The third reason is that the tasks were real issues in real repositories, not greenfield exercises. Writing new code from scratch is the task where AI coding tools are strongest. Modifying a large, established system, where every change interacts with years of accumulated decisions, is the task where they are weakest. The METR trial deliberately chose the hard case: experienced developers, familiar code, real issues. That is also the case that most resembles a senior engineer's daily work.

The fourth reason is that the tools of early 2025 were less capable than today's tools. Agent modes were newer and the models less reliable at multi-step work, so a result measured on Claude 3.5 and 3.7 Sonnet is a result about that period, not a permanent verdict.

The Larger Study That Found the Opposite

If the METR trial were the only evidence, the story would be that AI coding tools slow senior engineers down. It is not the only evidence, and the largest study in the field found something different.

Cui and colleagues ran three randomised field experiments at Microsoft, Accenture, and an anonymous Fortune 100 electronics manufacturing company, covering 4,867 developers in total. The experiments ran as part of the ordinary course of business, as the companies decided whether to adopt GitHub Copilot, and the companies shared the resulting data with the researchers. The paper, "The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers", was published in February 2025, with an updated version in August 2025.

The pooled result was a 26.08 percent increase in completed tasks, measured as weekly pull requests, among developers using the tool, with a standard error of 10.3 percent. That standard error matters. It means the plausible range runs from roughly 6 percent to 46 percent, which is the difference between a modest gain and a large one. The authors are open about this: each experiment is noisy on its own, and the effects differ across companies.

Crucially, the gains were not evenly distributed. Less experienced developers had higher adoption rates and greater productivity gains. The largest gains showed up among shorter-tenure developers, with figures cited in secondary analysis reaching roughly 39 percent for newer engineers, while more experienced developers improved by a smaller amount, roughly in the 7 to 16 percent range. The study also found increases in commits and builds alongside the pull request gains.

The two studies are not actually in contradiction, once you read them carefully. They measured different people doing different work with different tools. METR measured 16 experienced developers on their own large open-source codebases with early-2025 agent tools. Cui and colleagues measured nearly 5,000 developers doing ordinary company work with GitHub Copilot, a code completion tool, in 2022 and 2023. A senior engineer doing greenfield work or boilerplate with Copilot may well go faster. The same engineer modifying a million-line codebase they know deeply may well go slower with an early-2025 agent. Both results can be true at once, because they describe different situations.

The 2026 Update: What Changed

METR did not stop after the July 2025 result. The organisation repeated the experiment in late 2025 with 57 developers and more than 800 tasks, using newer tools, and published an update on 24 February 2026.

The new results pointed in the opposite direction. Returning developers showed an estimated 18 percent speedup, with a confidence interval from 38 percent faster to 9 percent slower, and new developers a 4 percent speedup, with an interval from 15 percent faster to 9 percent slower. But METR was unusually direct about the weakness of this evidence. The organisation said the data from the new experiment gave an unreliable signal, because 30 to 50 percent of developers told the researchers they were choosing not to submit some tasks because they did not want to do those tasks without AI. That selection effect means the tasks that were measured were not a fair sample of all tasks, and the speedup estimate cannot be trusted as a precise number.

METR's current position, as reported in February 2026, is that it is likely developers are more sped up from AI tools now, in early 2026, compared with the estimates from early 2025, while cautioning that this is only very weak evidence about the size of any increase. The organisation is redesigning its experiment and now labels the original July 2025 result as historical, saying it no longer necessarily reflects current AI tools or current developer workflows.

The honest summary is therefore a moving picture, not a fixed verdict. Early-2025 tools slowed experienced developers on familiar code. Late-2025 tools probably help, but nobody has yet produced a clean measurement of by how much. Anyone quoting the 19 percent slowdown as a current fact, or quoting an 18 percent speedup as a proven fact, is overstating what the evidence supports.

What the Other Evidence Adds

Several other studies fill in the picture around the two headline trials, and they are worth knowing because they measure things the trials did not.

A 2023 experiment by Peng and colleagues at GitHub and Microsoft Research recruited 95 professional developers and randomly split them into a group with Copilot and a group without. The task was to build an HTTP server in JavaScript, a single well-defined greenfield task. Developers with Copilot finished 55.8 percent faster. The result is real, but its limit is obvious: one standardised task, with code quality not examined, tells you about greenfield speed and nothing about maintaining a large system.

A longitudinal study published on arXiv in September 2025 followed 300 engineers across multiple teams at an enterprise over a year, using an in-house AI platform that combined code generation and automated review. The study reported a 31.8 percent reduction in pull request review cycle time, with 85 percent adoption and 93 percent of developers wanting to continue using the platform. Top adopters achieved a 61 percent increase in code volume pushed to production. By experience level, junior engineers showed the highest productivity gain at 77 percent, while mid-level and senior engineers showed 45 percent improvements in code shipped. This is observational evidence from a single company using its own platform, not a randomised trial, but it is useful because it measures real production work over a full year rather than a laboratory task.

Research on code quality adds a caution. GitClear analysed 211 million lines of code and reported an eightfold increase in duplicated code blocks during 2024, alongside a fall in refactoring. A separate study led by researchers at CodeScene and Lund University, "Echoes of AI: Investigating the Downstream Effects of AI Assistants on Software Maintainability", ran a pre-registered controlled experiment with 151 participants, 95 percent of them professional developers. It found no significant difference in maintenance cost or code quality between AI-assisted and human-only code in the maintenance phase, and where a difference appeared it favoured AI: code written by habitual AI users scored measurably higher on maintainability. The quality story is therefore contested and depends on which metric you trust, but there is no settled evidence that AI assistance systematically destroys codebases.

The Stack Overflow 2025 Developer Survey, treated across the industry as the 2026 reference, found that 84 percent of developers are using or plan to use AI tools, with 51 percent of professionals using them daily. Adoption is no longer a question of early adopters. It is the default, and the question for senior engineers is how to use the tools well, not whether to use them at all.

What Actually Changes in a Senior Engineer's Day

Pulling the evidence together, a clear picture emerges of how AI coding tools change senior engineers' work. It is not a story of replacement. It is a story of redistribution, in which some tasks get faster, some get slower, and the tasks that matter most shift.

Writing boilerplate and scaffolding gets faster. Generating a new service skeleton, writing tests for straightforward logic, converting data formats, and producing repetitive code are all tasks where AI tools are strong. A senior engineer who spends an hour a week on this kind of work will save most of that hour.

Exploring unfamiliar code and libraries gets faster. A senior engineer asked to work in a part of the system they do not know, or with a library they have never used, can use an AI tool to build understanding quickly. This is one of the clearest gains in the research, because it is a task where the AI's breadth of training compensates for the engineer's lack of local context.

Reviewing code becomes more important and more demanding. As AI generates more of the code that enters a codebase, the review step becomes the main quality gate. Senior engineers are the people who can tell whether generated code is correct, secure, and consistent with the system's architecture. The METR trial's slowdown is partly a review story: the time saved in writing was spent in reading and correcting. That is not wasted time. It is the work that prevents bad code from reaching production.

Architecture and system design become a larger share of the job. AI tools are weak at decisions that span a whole system: how services should be split, where data should live, what can fail and what happens when it does. Those decisions require judgement about trade-offs that no model can make on its own, because they depend on business context, team capacity, and risk tolerance. As code generation gets cheaper, the relative value of good architecture rises.

Mentoring changes shape. Junior developers now arrive with AI tools that can generate working code quickly, but they may not understand what the code does. A study by Anthropic found that junior engineers learning a new library with AI assistance scored 17 percentage points lower on comprehension tests than those who coded manually. Senior engineers are increasingly needed not to teach juniors how to write code, but to teach them how to read it, question it, and know when it is wrong. That is a harder mentoring job, and a more valuable one.

Skills atrophy is a real risk, and the evidence gives reason to take it seriously. If a senior engineer stops writing certain kinds of code entirely, their fluency in those areas will fade. The research on learning suggests the answer is deliberate practice: using AI for speed where speed matters, and writing code by hand where understanding matters. The engineers who will do best are those who treat AI as a tool they direct, not as a replacement for their own competence.

For readers who want the wider context on how AI is changing entry-level and junior work, our article on what vibe coding is explains the trend that has brought AI code generation to a mass audience, and our analysis of AI's impact on the labour market sets out which roles are most exposed. The senior engineer story sits inside that larger picture, but it is distinct: senior roles are being reshaped, not removed.

The Skills That Gain Value

If the evidence is right, the skills that become more valuable for senior engineers are not the ones AI does well. They are the ones it does badly.

System-level judgement is first. Knowing what to build, what not to build, and what will break in six months is worth more when code is cheap, because cheap code makes it easy to build the wrong thing quickly.

Taste in code review is second. The ability to read generated code and spot the subtle error, the security hole, or the architectural violation is the quality gate that stands between AI output and production. It cannot be automated away, because it requires understanding the system the code will live in.

Communication and influence are third. As AI takes over more of the typing, a senior engineer's leverage comes from aligning teams, explaining trade-offs to non-technical stakeholders, and making decisions that others trust. Those are human skills, and they are the ones that determine whether a team ships the right product.

And domain knowledge remains decisive. An AI tool can generate code for a payment system, a medical device, or a trading platform, but it does not understand the regulations, the failure modes, or the business rules that govern those domains. The senior engineer who does understand them is the person who keeps the system safe.

What Employers and Teams Should Do

The evidence has practical implications for how teams organise senior engineers' work with AI tools.

Measure outcomes, not feelings. The METR trial's central lesson is that self-reported speed is unreliable. Teams that want to know whether AI tools help should measure completion time, defect rates, review time, and delivery stability, not survey responses. A team that adopts AI on the basis of enthusiasm alone may be paying for a slowdown it cannot see.

Do not judge AI tools by junior gains alone. The field studies consistently show that junior developers gain most on throughput. A team that evaluates AI by looking at average gains will overstate the benefit for senior engineers and may set expectations that seniors cannot meet. Evaluate by experience level, and by task type.

Invest in review capacity. If AI generates more code, review becomes the bottleneck. Teams should treat review time as a first-class cost, staff it accordingly, and recognise that senior engineers' review work is productive work, not overhead.

Protect learning time. If junior developers use AI to skip the struggle of understanding code, they will arrive at senior roles without the foundations the role requires. Teams should deliberately preserve hand-coding practice for learning, even when AI could do the task faster. The short-term cost is real. The long-term cost of a generation of engineers who cannot read code is larger.

The Bottom Line

AI coding tools do not make senior engineers obsolete. They make the senior engineer's job more clearly about judgement and less about typing. The best evidence we have says that experienced developers on familiar, complex code gained little or nothing in speed from early-2025 tools, and may have slowed down, while the same tools produced large gains for less experienced developers and on simpler tasks. Newer tools probably help more, but the clean measurement of that improvement does not yet exist.

The engineers who will thrive are not those who write the most code, and not those who resist AI tools. They are the ones who use the tools where they help, measure whether they actually help, review ruthlessly, and invest in the judgement that no model can supply.

For a broader view of which jobs AI can and cannot replace, see What Jobs Can AI Not Replace?

What We Could Not Verify

  • We could not verify the exact Google Trends figures behind the search surge for this topic, because Google Trends does not publish a permanent public record of those values. The figures are reported here as the trend signal that prompted this article, not as independently verified data.
  • We could not verify the claim, cited in some secondary sources, that AI coding tools require 30 to 100 hours of hands-on use before they consistently help, because we could not trace it to a primary study in the time available. It is included as a reported estimate, not a verified finding.
  • We could not verify the current capabilities of the newest AI coding tools against the studies cited, because the studies used tools from 2022 to early 2026 and the tools have changed since. Any claim about what today's tools do for senior engineers is an extrapolation, not a measured result.
  • We could not verify the Stack Overflow 2025 survey figures beyond the secondary reporting cited, and we have not treated them as primary data.

Sources

  • METR: Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, via ScienceBlog, https://scienceblog.com/randomized-trial-metr-found-experienced-developers-completed-real/
  • Cui, Demirer, Jaffe, Musolff, Peng, and Salz: The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers, MIT Economics, https://economics.mit.edu/sites/default/files/inline-files/draft_copilot_experiments.pdf
  • Pieoneers: Why AI Coding Tools Pay Off for Senior Engineers, https://pieoneers.com/blog/why-ai-coding-tools-pay-off-for-senior-engineers
  • Katabench: AI coding assistants and engineering skills: the evidence, https://katabench.com/blog/ai-coding-assistants-engineering-skills
  • Velona: Do AI Coding Tools Make Developers Faster? (2026 Research Review), https://www.velona.in/blog/do-ai-coding-tools-make-developers-faster-research-2026
  • arXiv: Intuition to Evidence: Measuring AI's True Impact on Developer Productivity, https://arxiv.org/pdf/2509.19708
  • BlueHeadline: AI Helps Junior Developers Most: What the GitHub Copilot Study Really Means for Senior Engineers, https://blueheadline.com/software-dev/ai-helps-new-developers-but-seniors/

Similar Posts