Where the Bottleneck Moved

hc1, 2025-2026, and carried into SteadyIQ

Architecture review became the constraint, and we stopped trying to fix it.

AI made code cheap. Judgment got expensive. Architecture review, quality gates and earlier decisions are the load-bearing wall.

I spent a good part of this year arguing that AI made judgment the whole job. The fair follow-up question was what that actually changes on a Monday morning. Here is what changed in my org.

When implementation goes from days to hours, the review queue backs up. That part is predictable. The instinct that follows is the dangerous one: speed review up, approve faster, batch more, trust the tests. That is how you generate technical debt at machine speed and call it velocity.

We went the other way. Review got slower and more expensive on purpose, because it is now the only place a human decision actually enters the system.

Quality gates got stricter, not looser

SonarQube thresholds, coverage floors, and pull request review that actually blocks. When code volume goes up 5x, gates stop being bureaucracy and start being the load-bearing wall. Every gate we relaxed to keep the queue moving, we paid for later at a worse exchange rate.

The expensive conversation moved earlier

Not "review this PR," but "should this exist, and where does it sit." Ten minutes of that conversation saves a week of generated code pointed at the wrong abstraction. The cost of a bad architectural call compounds at machine speed now, which means the cheapest place to spend human attention is before the code exists, not after.

The operating form of that conversation is plan approval. The agent reads the repo and produces the plan: files, interfaces, migrations, flags, test surface, blast radius, rollback. A senior human approves or revises it, and only then does implementation start. Reviewing a plan takes five minutes and catches architectural mistakes. Reviewing a 1,500-line diff takes an hour and catches typos. Plan approval is where senior judgment scales, and it is the gate I would build first if I were starting over.

Tier the review, or the queue tiers it for you

Uniform review collapses at volume. When every PR gets the same treatment, the treatment quietly drops to whatever the queue allows, and the industry data on where that lands is not subtle: once an AI review tool is switched on, 80 percent of PRs receive no human comment at all, and in 2026 merges with no human review rose 31 percent while incidents per PR roughly tripled. The alternative is deciding, in advance, where the scarce human hours go.

The tier is classified from the diff against the approved plan and the CODEOWNERS map, not declared by the author. Escaped defects by tier is the metric that says whether the map is calibrated, and no-comment merges by tier is the one that says whether oversight is quietly eroding.

QA stopped being downstream

I taught the quality team to generate Playwright suites with Claude directly. They went from receiving work to producing coverage in parallel. That is not a tooling change, it is an org chart change - and it is the single highest-leverage thing I did all year, because it removed the team that was structurally guaranteed to become the next bottleneck. What that did to the role, and the one grading rule that kept two hundred green tests from becoming decoration, is in AI Did Not Replace QA. It Deleted the Typing.

The gate that belongs on generated tests is mutation score, not coverage. AI writes tests that look thorough and assert nothing, and coverage cannot see the difference. Mutation testing can: it changes the code and checks whether the suite notices. Meta's TestGenEval benchmark had a frontier model at 35 percent coverage and an 18.8 percent mutation score, and another study found generated suites at 100 percent coverage and a 4 percent mutation score. Feed the surviving mutants back to the model and most of that gap closes. Put the gate on the modules that matter: money math, auth, rule engines, adapters.

The benchmark number is from 2024, and the premise may be dating. An August 2026 preprint from Trinity College Dublin scored tests written by recent Claude models against the human-written suites in Django and Pandas and found them no weaker on mutation kill rate, while tests from the older models drew critical flags nearly three times as often. One author, one model family, Python only, so hold it loosely. But notice which metric delivered the good news. Coverage could not have told you the tests got better any more than it could tell you they were hollow. The gate stays, and it is how you find out whether that result holds on your code.

The uncomfortable version: if your senior engineers are still spending most of their time producing code, you are paying architect rates for something that got cheap. Their expensive skill is now review, boundaries, and saying no.

That is a harder job than writing the code was. It is also the one that does not get automated next. The mechanics of how the constraint moves, upstream into requirements and downstream into verification, are in We Did Not Remove the Bottleneck. We Moved It and on the AI Bottleneck Shift section of the home page. The full set of practices the tiers sit inside is in An Operating Model, Not a Tooling Purchase.