Review the Evidence, Not the Diff
When agents write most of the code, reading every line stops scaling. What scales is making them prove the work: run the app, record it, check the state machine.
A few years ago I'd start the morning by reviewing two or three pull requests from teammates. Now agents open more than that before I've finished coffee. Reading every diff line by line was already the slowest part of shipping. At this volume it's impossible.
The answer isn't to stop reviewing. It's to change what gets reviewed. I want the agent to show me the thing working, and I want proof that it understood what I asked for. The diff is the least useful part of a pull request for either question.
Runtime verification: let the agent run the code
The most basic form of verification is also the most skipped: give the agent a way to run the app and look at it.
An agent that can only read and write files is guessing. An agent that can start the dev server, open a browser, click through the flow, read the console, and take a screenshot is checking. The tools are the same ones a person uses to debug. A browser driven over the DevTools protocol, Playwright, the app's own logs.
Two things make this work much better.
A feature map. This is a site map of the app from the user's point of view: every screen, every panel, what each one is called, how you get there. Without it, when I say "the filter chips on the articles page," the agent has to guess what I mean and how to reach it. With it, we share a vocabulary, and the agent goes straight to the right place.
A small CLI for driving the app. If every agent writes its own browser script from scratch, you pay for that in tokens every time, and every script is a little different and a little broken. A reusable driver ("open this route as this user, wait for hydration, screenshot this region") is cheaper, and you can test the driver itself.
The pull request becomes a package of evidence
Once agents can run the code, code review turns into reviewing artifacts:
- a short video of the flow working
- before and after screenshots, in both themes if the app has them
- test output, including the new test that failed before the fix
- a diagram of the states the feature can be in
I can check a video in thirty seconds. Checking whether a 400-line diff does what the video shows would take me twenty minutes, and I'd still miss things.
Flaky tests are lies you tell your pipeline
Verification only builds trust if the results mean something. A test that fails one run in ten trains everyone, human and agent, to rerun it until it goes green.
I have a couple of these right now. One end-to-end test clicks a filter chip before the page has hydrated, so the click sometimes does nothing. Another sometimes times out waiting on the database during a cold start. My merge script reruns the failed job once before it gives up. That works, and every time it fires I'm teaching my pipeline that red doesn't mean broken.
The fix is boring and worth doing: wait for the thing you actually depend on, not for a timer, and treat a flake as a bug with the same priority as the bug it's hiding.
Property-based tests for the UI
Example-based tests check the cases you thought of. Property-based tests generate inputs and check that something stays true across all of them. For a UI, that means generating sequences of clicks, typing, and navigation, and asserting things like "the selected item is always visible" or "the count in the badge always matches the list."
These were expensive to write and maintain, so most teams didn't bother. An agent will write and fix them for you, and they find the bugs that only happen on the fortieth action in a strange order.
Formal methods are finally affordable
Model checking and proof assistants used to be for distributed databases and aerospace. You'd need someone who knew the tools, and the specs went stale the moment the code changed.
Now it's practical to have an agent write a model of a user flow, such as notifications that have to stay in sync across a phone and a laptop, and have a model checker explore every interleaving. Or to prove a small algorithm correct, like the math behind a virtualized list that must never skip or repeat a row while scrolling. These checks find real bugs. They're not a silver bullet; they're one more layer.
The side benefit is bigger than I expected. Writing the state machine forces the question of what the feature is supposed to do. When an agent turns my request into a state chart, I can see in a minute whether it understood me. A missing state or an arrow in the wrong place is much easier to spot in a diagram than in code.
Most of the tokens go here
Teams that trust their agents tend to spend most of their tokens on verification rather than generation. That sounds wasteful until you remember what the alternative is: a person reading every line, or subtle bugs landing anyway.
None of these techniques are new. Runtime checks, screenshots, property tests, model checking: all of it has existed for decades. What changed is the cost. Writing and maintaining this kind of verification used to be too expensive for most product teams. Agents brought that cost down, so we can verify far more than used to make economic sense.
That's the trade I'm making. Let the agent write the code quickly, and make it spend real effort proving the code works.