Code review is theater now, and quality has to move somewhere else

Code review became theater before most teams admitted it. Gergely Orosz's analysis of the tech industry in 2026 names it plainly: with agents generating far more code than before, engineers are stamping PRs with LGTM without reading them. GitHub data shows agent-authored PRs exceeded human-authored ones on the platform by August 2026 — a ninefold increase over eight months. Nobody can review that volume carefully, so most people don't.

This raises a real question: if nobody is reading the code, what does "quality" actually mean?

Our answer: quality never lived in code review. It lived in the things code review was supposed to catch — regressions, bad assumptions, subtle logic errors, unintended behavior. The mechanism is changing; the goal isn't.

The signal has moved

When an engineer reads a diff, they're doing several things at once: checking for bugs, understanding intent, spotting design problems, and maintaining shared context about the codebase. Agents under load can't preserve that last one. What they do well — and what Orosz confirms companies are investing in — is generating tests, running evals, and flagging observable failures.

Jarred Sumner, creator of Bun, now at Anthropic, makes this point directly in the piece: the time spent on tests relative to code has not changed. The AI writes the code and the AI writes the tests. The test suite is still the contract. If anything, the volume of agent output makes automated validation more important, not less.

The companies doing this well — Ramp's Inspect harness, OpenAI's agentic deploy system, the long list of internal AI harnesses now standard at mid-sized companies — are rebuilding quality into the CI/CD pipeline rather than into a human reviewer's attention span.

What the trade-off actually is

You gain speed and volume, but you lose the ambient understanding that comes from humans reading code. Shared architectural intuition, the working mental model of how a system behaves — that has to be maintained some other way. Planning phases, architecture documents, and what the article calls "tracer bullets" — a concept from The Pragmatic Programmer, rediscovered as a reliable way to guide agents — are now doing work that code review used to do as a byproduct.

This is why the finding that planning still matters for complex projects isn't a surprising holdover. It's the new primary mechanism for maintaining coherence across a codebase that no single person is reading end to end. Katelyn Lesse, Head of Engineering for Claude Platform at Anthropic, describes a planning process for their Managed Agents project that looked indistinguishable from pre-AI planning: documents, floating ideas, circling back. The tooling changed; the coordination didn't.

What we'd prioritize

For small teams, the practical implication is straightforward: invest in your test harness and evals before you scale up agent usage, not after. If your automated suite can't catch a bad agent output reliably, you're building on a foundation that degrades silently. The theatrical code review problem gets worse as you add more agents, not better.

Quality in an agentic workflow is observable behavior under tests — not code that looks clean on review. That's not a lowering of the bar. It's a more honest version of what the bar always was.

Sources

• The state of the tech industry in 2026 (original)
• Found via the TLDR newsletter