The Friction Was the Signal

A pull request adds retry logic to a payment client. The diff is clean, tested, and idiomatic. A reviewer asks why it retries on a 409. The author reads the file for a moment and says they’ll check.

Nothing’s wrong with the code. What’s missing is the path the author took to write it, because there wasn’t one.

In 2025, METR ran a randomized trial with 16 experienced open-source developers working in mature codebases they knew well. With early-2025 AI tools, they completed tasks 19% slower. Afterward, they estimated they’d been 20% faster.

The slowdown matters less than the gap. These were the people best positioned to judge, and their sense of their own pace was off by nearly 40 points. Their gauge wasn’t broken. It was reading a place the difficulty had already left.

Engineering has always carried a rough signal in its friction. A hard change meant the system wasn’t understood yet. A painful refactor revealed accumulated complexity. The signal was never clean, but it was free, it ran at every level, and nobody had to design it. AI moves much of that difficulty from producing a change, where the author feels it early, to verifying and operating one, where someone else feels it late. Ease stops being a reliable proxy for understanding.

Aviation Learned This First

Commercial aviation met this problem decades ago. Autopilots and flight computers made routine flying safer and more manageable, but their constant use didn’t preserve the manual skills pilots needed when they handed control back. Nothing announced the loss. The instruments looked steady because the autopilot was flying well.

The cost showed up at the handback. In 2009, ice crystals briefly blocked the airspeed sensors on Air France 447 over the Atlantic, and the autopilot disconnected. The final report traces a chain of factors, but at its center was a crew with thousands of hours between them, handed a mostly normal airplane at cruise altitude, who flew it into a stall they never recovered from.

That’s the lesson software is about to relearn. When automation absorbs the difficulty, the difficulty stops training people and stops reporting on them. Both losses stay invisible until the handback.

What Went Quiet

At the keyboard, the struggle used to be visible. An engineer stuck on the same problem twice, a question repeated in review, a pull request that kept coming back: output looked junior when understanding was junior, and the mismatch showed where help was needed. Now output looks finished regardless of what sits behind it. An engineer used to find the edge of their understanding early, the first time something didn’t work. Now they can find it in production.

The codebase went quiet too. GitClear’s 2026 code-quality report found moved code, which it treats as a signal of refactoring, falling from 21% of changed lines in 2022 to 3.8% in the first half of 2026. Copy-pasted lines rose from 9.4% to 15.7%. The data can’t say why. One plausible mechanism: the tool did the pasting, so the cost of reading the result never reached the person making the decision. The dread of maintaining your own code was the enforcement arm of every maintainability principle. Agents don’t feel dread.

The Dashboard Looks Steady

At the top, the quiet reads as good news. Faros AI’s 2026 telemetry from 22,000 developers across more than 4,000 teams, comparing each organization’s lowest and highest periods of AI adoption, found bugs per developer up 54%, monthly incidents up 57.9%, and incidents per pull request more than tripled. Median time in review rose more than fivefold, and 31% more pull requests merged without review. It’s observational data, so it can’t prove cause. But the burden shows up exactly where a shifted cost would land: in review and operations.

An author who built a change usually carries a working model of it: the constraints, the rejected alternatives, the ways it could fail. A generated change can arrive without that model, so the reviewer rebuilds it from the result, which is slower than checking it. That was the 409 question.

The proxies leaders relied on (elapsed time, felt effort, and activity) all move together once the local signal weakens. Confidence rises, throughput rises, and each seems to confirm the other. It’s the autopilot’s steady needle at organizational scale.

Hand-Flying

In 2013, after its data showed manual handling errors rising, the FAA issued a safety alert encouraging airlines to build manual flying into both line operations and training. It kept the automation and paid for the instrument deliberately, once automation stopped providing it for free.

The software equivalent is less dramatic. When a change matters, I ask the author to walk me through the design before I look at the diff: what they considered, what they rejected, and where it could fail. The question works the same whether or not a tool wrote the code, and it’s one the tool can’t answer for them. A thin walkthrough is the old friction signal, recovered on purpose.

The teams doing this well share a pattern. Review load and post-release rework carry the same weight as throughput. Some hard debugging is deliberately left to those who need the reps.

Until the instrument is rebuilt, a steady dashboard means one of two things, and the organization can’t tell which: the work is healthy, or the part that used to complain has moved somewhere nobody’s reading. If it’s the second, the bill arrives in an incident, on a night the tool has no answer. Nobody will know until then whether the person on call has ever flown it by hand.