Reviewing diffs is a dead practice. With agents writing the code, reviewing every change makes no sense. Agree on what done means before any code exists, and let the machine prove it. On November 7th, 197 changes landed this way, and no person read a diff. This is how it works.
Built for a slower world #
Code used to arrive at human speed. A teammate wrote it, another read it over coffee, and a dozen changes made for a busy day. The pull request was perfect for that world: the reviewer could always keep up.
Enter coding agents. They write a change in minutes or even seconds. Great. But a careful review still takes ten minutes or longer. One reviewer can give maybe a dozen diffs per day real attention. A few agents can produce that many before finishing the morning's first coffee.
You see, pull requests were designed for a world where a team understands the codebase and already agrees on the direction. In that world, reviewing a PR is a second set of eyes to confirm the plan is on track, the team is aligned, and the code is well understood. In some companies the humble pull request serves as a record of compliance too, that another human reviewed it.
Agents weren't in that meeting. They don't know the plan, they don't share the team's sense of direction, and they will cheerfully build the wrong thing very well. So the pull request becomes the first and only place anyone checks the direction, after the code already exists. The poor reviewer has few options at this stage: accept or reject.
So the reviewing gets thinner. The process quietly turns into rubber-stamping. The approval says a human looked, but it's less and less true. As a compliance record, it now records a click. And over time nobody can stop the machine from churning more of the codebase into something unrecognizable.
Code laundering #
There's a name for this. Machine-written code goes in one end, human-approved code comes out the other, and at no point did anyone establish that it's correct. That's code laundering. Adding agents only speeds up the wash cycle. And everybody pretends.
And yet, when something breaks, people blame the humans. The builder should have written a better prompt and tested more. The reviewer should have caught it; that's literally their job. The reviewer points at the builder, the builder points at the agent, and the agent points at nobody, because it's already three tickets further along. It's the Spider-Man meme with a production incident in the middle.
Nobody in that picture did anything unusual. The process asked a person to vouch for code at a speed no person can read, then asked whose fault it was when they couldn't. Working harder won't close that gap. Changing where the judgement happens will.
Blame the pull request process, then change it #
Move the judgement to where it's cheap: the very beginning. Decide what done means once, before any code exists, and let the machine hold every change to it.
We call that decision the bar. It's a short list of what has to be true when the work is done, and how a machine will prove each line. Say you want a password reset, with these criteria:
Three lines. You can read them in ten seconds and know exactly what shipping means. Nobody reads the diff behind them in ten seconds, and happily, nobody has to.
The bar doubles as the paper trail. Months later, anyone can open the item and see what was asked for, which run proved each line, and who checked it. Compare that with a pull request approval, which mostly tells you someone found the green button.
Only the first step needs you #
You do one thing: agree on the bar with a teammate, on what must be true and how a machine proves it. Pullboard does the rest:
- Agents build against it. The bar freezes the moment an agent claims the item, so nobody moves the goalposts mid-game.
- The gate runs the tests. On runners, at the exact commit the agent submitted.
- A reviewer from another model family checks the proof. Line by line against the bar. No recorded run, no pass.
- The work lands on main. All by itself.
Same four steps on every change, Monday morning or Friday night.
Bar setting holds at volume #
Pullboard is built with Pullboard. One ordinary Saturday, November 7th:
- 197
- items landed
- 293
- agent verdicts
- ~30 min
- claim to landed
- ~12/hr
- evening pace
No human in the review loop, and yet a full day of work shipped. Nobody sat in a review queue wondering where their life went wrong. Humans wrote the bars the agents had to reach. Humans watched and tuned the machine. And humans questioned whether the agents got it right, and asked for the proof.
Yes, but… #
Isn't skipping review risky? Nothing skips review. It just stopped being a person's eyeballs. Every change is checked against every clause of its bar, by a model that didn't write it, using tests that ran on the exact commit. A tired person skimming a diff checks less, and writes down nothing about what they checked.
What if it comes out wrong? Then the bar let it through. Sharpen the bar, and every later change meets the sharper one. Pull requests make you fix the same mistake diff by diff, forever. A bar lets you fix it once, with agents both building and reviewing.
What about the architecture? It's written down, so the machine can hold every change to it. Doctrine (the house rules) lives in the repo as rows the agents and gates enforce: file size limits, banned patterns, which modules may import which. Break one and the change is refused before a reviewer even gets a chance to see it. Human judgement goes into writing the rule, once, instead of rereading it into every diff.
Doesn't writing bars take time? Yes. Far less than reading diffs. A bar is a few lines, written once per item, and it comes before the work. The bar shapes what gets built, and sharper bars produce sharper work.
Congratulations, you've been promoted #
You're no longer the person squinting at diffs at six in the evening. You decide what done means, you set the bars, and you keep the machine humming. When something runs slow, you fix the factory, not the widget. Your judgement finally goes where it counts.
Prompting is for discovery. Declaring is for delivery.