A Blog: Rare texts, musing and free range ranting

A report from Faros, that draws on two years of data from 22,000 developers, lands with a pretty clear message: AI coding tools are making developers faster, and that speed is quietly breaking things downstream.

The throughput numbers are pretty impressive. It seems no one actually codes without AI anymore. And as a result, task completion up 34%, big features shipping 66% faster per developer, code-specific work up 210% at the team level. But. You knew there was going to be one. Bugs per developer are also up 54%, the chance of a production incident per merged PR has tripled, and 31% more pull requests are being merged with no review at all. Median time in code review is up 441%. Yikes.

Why is this happening?

AI writes code that looks sort of right. It’s (mostly) clean, idiomatic, well-named. The problem is that a large codebase has years of accumulated context — why a module was built a certain way, what the rest of the system depends on, what breaks at the edges. AI models just can’t know that, so they fill the gaps with plausible-sounding guesses. Usually fine. Sometimes not.

The small interactions with coding decisions changed. Tools like Cursor and Claude Code in agent mode just apply changes directly. You used to make many small accept/reject decisions as you went handcoding. Now you get to review a big diff at the end. The human judgment didn’t disappear, it just got compressed into a single coarser decision, often made quickly. And from experience, keeping those diffs readable and understandable is REALLY hard.

Generation is way faster than review. One developer with AI can produce code way faster than any reasonable number of humans can carefully read it. When both sides move at human speed the system stays in balance. When one side accelerates by an order of magnitude you get exactly what the report data shows: a pile-up at review, people getting buried, eventually merging things without looking.

Your best engineers are doing quality control. AI code has a specific failure mode — it looks superficially fine but has subtle structural problems. The only people who reliably catch those are senior engineers, who now spend their days reviewing AI output instead of solving the actual hard problems. Throughput is up, but it’s not a great use of anyone’s most expensive hours.

The feedback loop is slow. Velocity metrics look great right now. The costs show up in incidents and rework, which take months to accumulate and often get owned by a different team entirely. By the time the pain is visible, the decisions that caused it are six months in the past.

861% code churn

Code churn — lines deleted vs. added — went up 861% under high AI adoption. This shouldn’t really come as an surprise to anyone who has worked with AI at any lenght. It loves refactoring and rewriting things. Sometimes it’s good, however most of the time it’s just completely unnecessary. But at nearly 10× the prior churn rate it’s worth understanding before you take throughput numbers at face value. A lot of it is just refactoring for the sake of it.

What actually helps

Adding more reviewers or stricter QA gates treats the symptom. The problem is at the authoring stage. AI agents work with incomplete context — they can see the current codebase but not why it looks the way it does. This kind of context is hard for AI, it doesn’t do well with “long term memory”. But giving it some of that context (architectural decisions, historical constraints, testing requirements) makes the output substantially better from the start and causes less of a pile-up at the review stage. Doesn’t eliminate it, but mitigates somewhat. But it’s a tradeoff as you’ll be adding more and more things into the AI context window.

The report also makes a clear case against cutting headcount because AI output is up. The engineers who look cuttable on a velocity dashboard are often the ones absorbing the quality gap AI is creating. Remove them and that buffer disappears. Finally some common sense.

It’s nice to start seeing real data and behaviors over longer time scales together with perspective, the entire field needs more of this and less of ..well whatever it is that the hypecycle is serving today.