Deepseek ArtifactsDeepseek Artifacts
Back to blog

AI Coding and Senior Engineers: What Actually Changed, and How to Use It Well

What the evidence says about AI coding for experienced engineers — METR's 19% slowdown and its 2026 reversal, Stack Overflow's trust numbers, DORA's "AI is an amplifier" — plus the five things senior engineers should move their time to.

Nov 17, 2026

Senior engineers are the group most likely to be told that AI coding changes everything, and the group with the least tolerance for a claim without a source. So this post does two things: it puts the numbers on the table with links, and it separates what the data supports from what is judgement.

The short version: on the strongest evidence available, AI does not make an experienced engineer faster by default — it changes which parts of the job are expensive. Reviewing, specifying and verifying get cheaper to start and more expensive to get right. The engineers who benefit most are the ones who move their time into exactly those three places.

What the evidence actually says

Four sources are worth citing, and none of them says "senior engineers are obsolete" or "senior engineers are unaffected". They say something more awkward.

1. METR's randomised trial found experienced developers were slower. METR ran a randomised controlled trial with experienced open-source developers working on their own repositories. Their conclusion, verbatim: "when developers use AI tools, they take 19% longer than without—AI makes them slower." That is a 19% slowdown with a confidence interval from +2% to +39%, from data collected February–June 2025, on 16 developers (METR, 2025-07-10).

This is the single most relevant study for senior engineers, because the participants were not beginners being handed a new tool. They were people who knew their codebase well — arguably the situation a staff engineer is in every day.

2. METR's own follow-up says that number is out of date — and that they can no longer measure it reliably. In February 2026 METR published a design-change note (metr.org, 2026-02-24). For the subset of the original developers who joined the later study, they now estimate a speedup of 18% (confidence interval −38% to +9%); for newly recruited developers the estimate is 4% (−15% to +9%).

But read the caveats in the same post, because they are the interesting part: they observed "a significant increase in developers choosing not to participate in the study because they do not wish to work without AI", they cut the hourly pay from $150 to $50, and they admit time measurements are unreliable for developers running several agents concurrently. Their conclusion is that the data "gives us an unreliable signal", while they believe developers probably are sped up more now.

So the honest summary is: the one clean experiment we had measured a slowdown on experienced developers in early 2025, and the follow-up cannot cleanly establish the opposite. Anyone quoting "AI makes engineers 20% faster" or "AI makes engineers 20% slower" as settled is quoting a study past its expiry date.

3. Experienced developers are the most sceptical group, by a wide margin. Stack Overflow's 2025 survey (survey.stackoverflow.co/2025/ai) found 84% of respondents using or planning to use AI tools, up from 76% the year before, with 51% of professional developers using them daily. Favour among all respondents fell from 70%+ in 2023 and 2024 to 60% in 2025.

On trust: 46% actively distrust the accuracy of AI output versus 33% who trust it, and only 3% "highly trust" it. Experienced developers — defined there as 10+ years — are the most cautious subgroup, with the lowest "highly trust" rate (2.5%) and the highest "highly distrust" rate (20.7%). That is not technophobia; it is the population that has been on call for the code the model just wrote.

4. DORA's finding is about organisations, not individuals. The 2025 DORA report (dora.dev) concludes that AI's "primary role is as an amplifier, magnifying an organization's existing strengths and weaknesses", and that "the greatest returns on AI investment come not from the tools themselves, but from a strategic focus on the underlying organizational system." Its companion AI Capabilities Model names seven capabilities that amplify the benefits.

Notice what that implies for a senior engineer: if the surrounding system — review culture, test coverage, deployment hygiene, clear ownership — is weak, AI makes the weakness arrive faster. The amplifier does not care whose fault it is.

Hard data vs. judgement

Being explicit about the difference is the whole game here:

ClaimStatus
Experienced OSS developers were 19% slower with AI in early 2025Measured (METR RCT, 16 devs, CI +2% to +39%)
The same cohort later measured ~18% fasterMeasured but unreliable — METR says selection effects make the signal weak
46% of developers distrust AI output accuracy; experienced devs are the most scepticalMeasured (Stack Overflow 2025, 33,244 responses)
AI amplifies existing organisational strengths and weaknessesResearch conclusion (DORA 2025)
Senior engineers should spend more time on specs, review and verificationJudgement — mine, consistent with the above, but not a measured result
AI will/won't reduce headcount at senior levelNo reliable public evidence — do not quote anyone who claims otherwise without data

That last row is the one to hold onto when someone shows you a chart.

What actually got cheaper, and what got more expensive

If the net effect on an experienced engineer is roughly a wash in aggregate, the interesting question is composition. From the sources above plus the shape of the tooling, four shifts are defensible:

Writing the first draft got cheaper. Boilerplate, a new endpoint, a migration, a test scaffold — the model produces a plausible first version in seconds. This is real, and it is where the "10x" anecdotes come from.

Reviewing got more expensive. More code arrives faster, written by something with no stake in the system. The review is now the bottleneck, and it is the part that requires the experience.

Specifying got more valuable. A vague request to a human produces a clarifying question; a vague request to an agent produces 400 lines. Precision about acceptance criteria is now the highest-leverage writing a senior engineer does.

Verification did not get cheaper at all. Tests still have to be right, and a model that writes both the code and the test can be confidently wrong twice. Stack Overflow's trust numbers are a reasonable proxy for how much verification practitioners think is needed.

Five moves that follow

These are recommendations, not findings. Each one maps to a shift above.

  1. Write the acceptance criteria before you open the agent. Two sentences plus the command that proves it works. If you cannot write them, the task is not ready — and you have just saved an hour of reviewing confident nonsense.
  2. Budget review time explicitly. If the agent produced the diff, assume the review costs what writing it used to. Put it on the calendar rather than discovering it at 6pm.
  3. Keep the tests you trust, and make the agent prove itself against them. A test suite written by humans before the change is the cheapest defence against a plausible-looking regression. This is also the DORA point in miniature: AI amplifies whatever your verification system already is.
  4. Move your own time up the stack. Architecture, boundaries, data model, failure modes, "should we build this at all". These are the decisions where a wrong answer costs weeks and where an agent has the least context to help.
  5. Write down the conventions once, then load them automatically. Style rules, review checklists, "we use this HTTP client, not that one" — as a skill or an AGENTS.md the agent reads, instead of a comment you leave in every second review.

Using Claude Code or DeepSeek without lying to yourself

Both tools are capable of the first-draft work above, and both will happily produce code you would reject in review. Three practical habits keep the division of labour honest:

  • Ask for the plan before the patch. A short plan exposes a wrong assumption in ten lines instead of four hundred. It also mirrors how you would brief a junior engineer — same skill, different recipient.
  • Make the agent show its evidence. "Which file and line did you base that on?" is a cheap question that catches invented APIs. It is the same instinct as the 46% distrust number, applied productively rather than as a blanket refusal.
  • Keep a human-written test as the contract. Then the agent's output is either compliant or not, and you are not adjudicating style at midnight.

Our own walkthroughs for the mechanics: the Claude skills tutorial for packaging team conventions as skills, DeepSeek vs ChatGPT for coding for model choice, and the OpenCode tutorial if you want an agent-agnostic setup.

The uncomfortable part

The METR follow-up contains a sentence that matters more than any percentage: developers increasingly refuse to work without AI at all — enough of them that the experiment could not recruit a clean control group.

That is not a productivity finding, it is an organisational one. If your team has reached the point where the tool is no longer optional, then the thing being amplified is whatever your process already was. For senior engineers, that makes the review culture and the test suite the actual AI strategy — and the model choice a detail.

Sources

All sources were read on 2026-11-17. Percentages are quoted with the sample or interval the source reports; where a source does not state a number, this post does not invent one.