Shipping code without human verification

There's a blunt question every engineering leader is going to have to answer soon: how much code can go to production without a human ever looking at it? Not "how do we review faster," because that's a dead end—like optimizing a horse when what you need is a car. Agents now generate code at a pace no reviewer can sanely keep up with, and teams that insist on eyeballing every line are going to become the bottleneck in their own pipeline.

The piece draws a sharp line between testing and verification, two things that traditional code review smashed together. Testing checks whether code works. Verification checks whether it matches your standards—error handling conventions, API structure, scalability expectations. Review used to do double duty, forcing knowledge-sharing and quality-checking into one meeting that happens whenever a human has spare attention, which is a terrible way to guarantee anything. The argument here is that this was always inefficient, even before agents showed up.

The proposed fix is a role called an automated verification engineer, something like a hybrid of a QA lead and a developer-experience engineer. Instead of checking PRs by hand, this person builds and owns two systems: a test harness that enforces adversarial coverage, and a verification harness that checks whether a change actually does what it claims and follows house rules. When something slips through, the response isn't to blame a person—it's to improve the harness so the same failure can't happen again. This is basically Andy Grove's 1983 chip-manufacturing playbook, ported to software: find where defects leak through, build inspection at that exact point, tighten continuously.

The practical starting point is small and specific. Pick one percent of commits—maybe a well-understood, low-risk corner of the codebase—and figure out what it would take to ship that slice with zero human verification. A CODEOWNERS tweak might be step one. From there you're meant to grow that percentage the same way teams grew toward continuous deployment: not by trusting everything at once, but by proving out rollback mechanisms and monitoring until skipping a human stops being scary. Anthropic is already running this playbook internally, and the piece points to the recent leak of the Claude Code repo as a sign the approach isn't without friction.

The framing that sticks is the shift from artisan to factory. Engineers stop being people who personally touch every line and become people who maintain the machine that checks the lines—human on the loop instead of in it. A designer maintains a design-enforcement harness instead of reviewing every UI diff; a security engineer builds tooling that hunts for exposed secrets instead of manually auditing each PR. It's not that quality stops mattering. It's that quality becomes something baked into the system rather than something one tired reviewer catches at 4pm on a Friday.