The gain lands on one engineer, the cost on another

After GitHub Copilot arrived, the most active developers in a large set of Microsoft-owned open-source repositories wrote 19% fewer commits of their own and reviewed 6.5% more pull requests. Their projects produced more code overall. Most of the extra output came from the contributors who had done the least work before.

That is the central finding of a working paper by Feiyang Xu, Poonacha Medappa, Murat Tunc, Martijn Vroegindeweij and Jan Fransoo of Tilburg University, AI-Assisted Programming Decreases the Productivity of Experienced Developers by Increasing the Technical Debt and Maintenance Burden (arXiv, version 3, January 2026). Its subject is who pays for an AI time saving, a question a per-developer dashboard cannot answer.

What the study measured

The authors built a monthly panel of GitHub activity from July 2020 to July 2022, twelve months either side of the June 2021 Copilot technical preview. It covers 2,755 repositories and, at the individual level, 1,699 contributors.

They could not see who used Copilot, so they used language as a proxy. Repositories whose main language the preview officially endorsed (Python, JavaScript, Ruby, TypeScript and Go) form the treatment group. Repositories in languages the preview did not officially endorse, such as Java, C# and C++, form the control group. The comparison is a difference-in-differences design: the change in the treated group minus the change in the control group.

They split contributors by their commit count before the preview. The top 25% are "core" contributors and the remaining 75% are "peripheral". The results by group:

GroupWhat changed after the preview
Treated repositoriesCommits up 4.1%, pull requests up 4.3%. Rework, counted as follow-up commits added to a pull request after its first submission, up 2.4% at a constant number of pull requests.
Peripheral contributorsCommits up 43.5%, a gain the paper attributes "particularly" to the bottom percentiles: the contributors with the fewest commits before the preview. The bottom quarter (the 0 to 25th percentile by prior commits) submitted 17.7% more pull requests.
Core contributorsCommits down 19%, pull request reviews up 6.5%.

The authors describe the core group as moving toward "reviewing and correcting others' contributions." One of the paper's own specifications puts the drop in core commits at 42.9% when it compares core contributors with everyone else, and the text does not reconcile that with the 19% in the abstract. The 19% is the conservative figure, and it is the one this article uses.

Read the limits before you generalise. The treatment is a language proxy, not observed use. The tool was 2021 autocomplete, not an agent that opens its own pull requests. The setting is open source, and "core" means most active, not most senior by title.

From core contributors to senior engineers: our inference

The paper measures activity, not seniority, and says nothing about job titles. The title of this article, and every mention of senior, Staff or Principal engineers below, rests on our inference: inside a company, the people who know a codebase best and review other people's changes are usually its senior engineers, the role the paper's core contributors play in open source. The study does not test that mapping. Test it on your own data before you rely on it.

Two other sources point the same way without measuring the transfer itself. Faros AI's takeaways from its AI Engineering Report 2026 (April 2026) give a section the title "The most experienced people in your organization are being buried. We call it the senior engineer tax." The review-time figures in that section, such as median time in review up 441.5%, cover whole organisations. Faros does not publish them by seniority, so the label is an interpretation, not a measured split.

Fastly's July 2025 survey of 791 US developers found that just under 30% of seniors (ten or more years of experience) say they edit AI output enough to offset most of their time savings, against 17% of juniors (up to two years). That is a self-reported vendor survey. It asked developers about fixing their own AI output, not about fixing other people's work, so it says nothing about a transfer. It supports only a narrower point: experienced engineers report catching and fixing more of what the tools get wrong.

The volume side of this, more code arriving at review, is covered in the verification tax of AI coding agents. The question here is narrower: whose calendar the extra work lands on.

Per-developer metrics read the transfer backwards

Picture the dashboard a platform team builds after an AI rollout: commits, pull requests and cycle time per engineer, compared with the quarter before. Apply the paper's pattern to it. The peripheral contributors' numbers rise by double digits. The core contributors' numbers fall.

A reasonable manager reading that chart concludes that the tool works for the less active contributors and that the core contributors are resisting it or coasting. Both readings are wrong if the paper's mechanism holds. Part of the peripheral contributors' gain was paid for with the core contributors' own commits, and the core group's falling output is that payment showing up. If your core contributors are your senior engineers, as we infer, the people the chart marks down are the ones absorbing the cost.

The saving gets booked to the person who made it. The cost gets booked to nobody, or to the core contributor as lower output. A per-seat licence review built on these numbers will overstate the return, and a performance review built on them will penalise the people absorbing the cost.

The team totals in the study still rose, so the study does not show a net loss. The problem is attribution. Per-developer metrics remain useful leading indicators. They cannot see a transfer between people, because each person's numbers are measured in isolation. That is one reason AI engineering ROI needs measures above the individual, and why AI throughput is not engineering throughput at the release level either.

The scarce hours pay for the cheap ones

A time saving and a time cost are not equal just because both are measured in hours. You can add general engineering capacity by hiring. The knowledge that makes a core contributor useful comes from time spent in one codebase, and that takes years to grow. The paper's abstract warns that AI's gains "may mask the growing burden of maintenance on a shrinking pool of experts."

Look at what the core contributors stopped doing. They wrote 19% fewer commits of their own and did 6.5% more reviewing. The study counted commits and did not classify what each one contained. If your ROI model prices every hour at the same blended rate, it hides that swap, because it values an hour of your most experienced engineer's own work the same as an hour of routine code a less active contributor saved.

The study saw this through two proxies, commits and reviews. Inside a company the moved work takes more forms: architecture discussions that start in pull request comments instead of design reviews, changes that pass tests but break a boundary, work that someone abandons or rewrites. Treat that list as places to look, not as findings. The hidden cost of AI-generated rework sets out a method for costing each of those stages.

What to measure instead

You do not need a new metrics platform to see the transfer. You need to cut the data you already have the way the paper did.

  • Segment by experience before you compare. Group engineers by tenure in the codebase or by commit history before the rollout, then compare the groups' change, not the individuals'.
  • Split senior time into original work and others' work. Track commits and pull requests your Staff and Principal engineers author, next to the reviews and corrections they make on other people's changes. Watch the ratio across the rollout.
  • Count follow-up commits after first submission. This is the paper's rework measure, and your code host already records it. Break it down by author group.
  • Report team output alongside individual output. If some individuals' numbers rise and team throughput stays flat, the gain moved rather than grew.
  • Ask before you rate a senior's drop. A falling commit count in an experienced engineer after an AI rollout may be the cost of everyone else's gain.

Where governance fits

Some of what a senior engineer corrects is a decision the team has already made, such as keeping the billing service from querying the ledger table directly. Restating that decision in a pull request comment is the most expensive way to enforce it, because it spends the scarcest hours on a known answer.

Mneme, an open-source tool that checks AI coding agents' changes against a team's recorded decisions, lets a team write such a decision as a rule that matches exact text, such as the ledger table's name, optionally limited to certain paths. It flags a violation in supported coding agents and in continuous integration, where strict mode fails the build. The agent meets the rule before the senior reviewer has to. This covers only decisions that someone has written as a rule. Judgement calls and design trade-offs still need the senior engineer.

Frequently asked questions

Do AI coding tools shift work onto senior engineers?+
One study found that pattern. A Tilburg University working paper on Microsoft-owned open-source repositories found that after the 2021 GitHub Copilot preview, the most active contributors wrote 19% fewer commits and reviewed 6.5% more pull requests, while the least active contributors drove most of the output gain. The study used language as a proxy for Copilot use and defined experience by past activity, not job title.
Why don't per-developer productivity metrics show this?+
They measure each engineer in isolation, so a transfer between two people looks like one person improving and another declining. The contributor whose output rose looks better. The experienced engineer who reviewed and corrected that work looks worse. Segment by experience and compare team totals with individual numbers to see the transfer.
What is the senior engineer tax?+
It is Faros AI's name, in its AI Engineering Report 2026 takeaways, for experienced engineers spending more time on plausible-looking AI-generated code. The review-time figures Faros publishes alongside it are organisation-wide and not broken down by seniority, so the label describes an interpretation rather than a measured split.
How can a team measure whether senior engineers absorb AI costs?+
Group engineers by experience before the rollout. For senior engineers, track the work they author against the reviews and corrections they make on other people's changes, and watch that ratio over time. Count follow-up commits added to pull requests after first submission, by author group. Report team output next to individual output, so a gain that only moved between people is visible.