Here is the most quietly unsettling fact about AI at work in 2026: the tool is winning while the team is not. Individual engineers report that AI makes them dramatically faster — yet when researchers measure the organizations those engineers work in, delivery gets a little slower and noticeably less stable. One person sprints; the org limps.

Boris Cherny, the engineer behind Claude Code, put the everyday version of this in a single sentence — he hears the same story at company after company: one person is 10x-ing their output, and the rest of the org hasn't caught up.

That gap between the one fast person and everyone else is the real story of AI adoption right now. It isn't a story about who has the best model. It's a story about what a team does with it — and why raw individual speed so stubbornly refuses to become team speed.

84%
Developers using or planning to use AI
51%
Use an AI tool every day
39%
Have little or no trust in AI code
3%
"Highly trust" AI output

Everyone has the tool. That was never the hard part.

Access is basically solved. In Stack Overflow's 2025 survey of more than 49,000 developers across 177 countries, 84% said they use or plan to use AI tools — up from 76% a year earlier — and 51% now reach for one every single day. If adoption were just a matter of handing people a login, we'd be done.

But look one row down and the picture cracks. More developers actively distrust AI's accuracy (46%) than trust it (33%), and only 3% say they "highly trust" what it produces. Positive sentiment toward these tools actually fell — from north of 70% in 2023 and 2024 to about 60% in 2025. The industry got more AI and less faith in it at the same time.

That is the shape of the adoption gap: broad access, shallow confidence. Everyone can generate code; almost nobody fully trusts the code that comes out. And an output you don't trust is an output someone still has to read, question, and verify — which is exactly where the fast person's speed goes to die inside a slow org.

Why the 10x person doesn't pull the org along

Here's the mechanism, and it's the part most "AI will transform work" takes skip. AI makes writing code cheap. It does almost nothing to make absorbing code cheap — reviewing it, integrating it, testing it, owning it in production. A single accelerated engineer can now push far more change into a system than the surrounding process was built to digest.

Google's DORA research put numbers on the fallout. Its 2024 report estimated that for every 25% rise in a team's AI adoption, delivery throughput dropped about 1.5% and delivery stability fell around 7.2% — even as roughly three-quarters of individual developers said AI improved their personal productivity. The same wave that made people feel faster made their systems shakier.

More AI: docs improve, delivery slips

Individual speed doesn't automatically become team speed: as AI use rises, docs get better but delivery throughput and stability slip. (Chart: BougainWell · Data: Google DORA 2024)

Why would faster coders make delivery worse? DORA's own reading is refreshingly unglamorous: AI makes it easy to write more code, and more code shoved into a single change means bigger batches — and bigger batches carry more risk. The discipline that keeps delivery healthy (small changes, tight testing, quick review) is precisely what a firehose of AI-generated code overwhelms. The tool got faster; the guardrails didn't.

So the 10x individual isn't a myth — but "10x output" and "10x value to the org" are different quantities. The first is about how fast you can produce. The second is about how fast everyone around you can safely accept what you produced. The bottleneck moved. It didn't disappear.

The trust tax nobody put in the budget

Notice what quietly connects the two datasets. Only 3% of developers highly trust AI output, and ~39% have little or no trust in AI-generated code. Low trust isn't a vibe — it's a cost. Every low-trust output demands extra human verification, and verification is the one step AI hasn't made cheaper.

That's the "trust tax": the invisible review-and-recheck work that gets added downstream every time an accelerated engineer hands the rest of the team code no one is sure about. The person generating it feels 10x. The people paying the tax feel buried. Interestingly, DORA found the clearest positive effect of AI adoption was a ~7.5% jump in documentation quality — a task where being roughly right is genuinely helpful and the cost of a small error is low. AI shines where verification is cheap and stumbles where it's expensive. That single distinction explains most of the gap.

The trap: measuring AI success by how fast your fastest engineer moves. If the rest of the team is drowning in review, integration, and re-checking, individual velocity is just relocating the bottleneck — and, per DORA, sometimes making delivery less stable, not more.

Closing the gap is an org problem, not a tool problem

If access were the lever, 84% adoption would already have delivered the promised productivity boom. It hasn't — which tells you the remaining work isn't buying more seats. It's redesigning how a team turns one person's speed into everyone's throughput: shrinking batch sizes so AI output arrives in reviewable pieces, building verification and testing that scale with generation, and — bluntly — earning back some of the trust that adoption ran ahead of. The 10x person is proof the ceiling is high. The lagging org is proof the ceiling isn't the constraint.

What to Take Away

  • Access is solved; absorption isn't. 84% of developers use or plan to use AI and 51% use it daily — the hard part now is what the team does with the output, not getting the tool.
  • Individual speed ≠ team speed. DORA estimates every 25% rise in AI adoption came with ~1.5% lower throughput and ~7.2% lower delivery stability. The 10x person is real; the 10x org is not automatic.
  • Bigger batches are the hidden killer. AI makes writing code cheap, so people ship more of it at once — and big changes are riskier. Small batches and tight testing matter more with AI, not less.
  • Watch the trust tax. Only 3% of developers highly trust AI output. Untrusted code has to be re-checked by hand, and verification is the step AI hasn't made cheaper.
  • AI wins where being wrong is cheap. Its biggest clean gain in DORA was documentation (+7.5%). Point it at low-stakes, easy-to-verify work first.

Charts: BougainWell, built from the Stack Overflow 2025 Developer Survey and the Google DORA 2024 report. This article is for general information only and is not professional advice.

Sources

All analysis and opinions in this article are BougainWell's own.