Most of my changes don't wait for a reviewer anymore
At my last job every PR needed a review. Now I land most changes myself, and an agent ships them and watches the rollout. These are the numbers, and what I still review.
At my last job every PR needed a review, and it decimated velocity. With how fast you can generate code with AI now, not being blocked waiting on people is a huge advantage.
In my opinion code review is mostly dead. There are some high-risk changes that need one or two extra people to look at them, but most changes should be landed by the engineer who made them, with no blockers and no external approval to wait for.
That's how I work now. Most of my changes don't wait on another person. I own them, and an agent ships them and watches the rollout.
What the wait costs
Now if a change needs a second set of eyes, it often ships substantially slower than a change I land fully myself. I went back through four weeks of my merged PRs on one of my main projects to see how much slower.
| PRs | Median time from opened to merged | |
|---|---|---|
| No one else reviewed | 116 | 1.2 hours |
| A teammate reviewed | 16 | 18.8 hours |
55 of the 116 merged in under an hour. And for me, review bots don't count as a teammate here.
The reviewed PRs were bigger, but size doesn't actually explain the gap. Breaking down all the PRs over 1,000 lines, the 16 I landed myself had a median of 1.1 hours and the 14 that got a review had a median of 20.2, that's a huge difference and a lot of that is waiting. The first comment or review from a teammate arrived a median of 13.5 hours after I opened the PR. It's not that my team is slow, but breaking out of deep work, gathering all the context on a change, and thoughtfully reviewing it takes time.
116 PRs that no one else reviewed merged a median of 1.2 hours after I opened them. 16 PRs that a teammate reviewed merged a median of 18.8 hours after I opened them, and the first comment or review from a teammate came a median of 13.5 hours in. After each merge an hour is marked for the agent watching the release, with checks at 20, 40 and 60 minutes.
The agent ships it and watches
My agents often do the merge, monitor the release and keep watching for a bit of time after to ensure everything goes smoothly. I have them do that even when I get a second opinion on the change.
Most of the time the whole instruction is one line.
Merge it in and then monitor it to ensure everything works correctly
Here is what an agent did on one change. Before it merged, it recorded a baseline of the environment, with how many containers were running, how many had restarted and which jobs were failing. Then it merged, monitored the release, and then scheduled three checks, at 20, 40 and 60 minutes. Each check confirmed the new version was running, compared container health and restarts against the baseline, and searched the logs for performance benchmarks and errors from the code it had changed.
Releasing code and monitoring the rollout with agents has been a huge unlock for me, and it really cemented this being the future. The trick is you need a real environment that the code ships into, and the agent needs read access to it. Give it the environment and the logs. In my opinion that's what you should be doing anyway.
A lot of where I've come from on this is the Amp team. They've talked about it a bunch on their podcast and in their posts, and I'm really aligned with their thoughts. They push to main with no mandatory review, and in one episode Quinn describes the same step: "Let's push it to main. Let's have it monitor for when it's deployed."
When it goes wrong
A few times I've shipped a change that didn't do exactly what I intended, or that had some edge cases. Honestly, most of those wouldn't have been caught by a second reviewer. But since I had an agent monitoring the release, it could flag the problem right away and revert the change without impacting users.
One of them was a fix for external calls that kept timing out. In the hour before the merge, ~80% of calls timed out. After the merge the agent checked again and told me "The fix isn't working", because about 80% were still timing out, and then it went looking for the real cause. The diff did what it said it did. It just didn't fix the problem, and I only found that out because something was still watching after the merge.
What I still review
There are changes I will always read myself. Those are infra changes, most data model changes and auth changes. Normally I have a good idea of what we're doing before the agent starts, so mainly I'm checking that it did it faithfully.
For destructive changes we require a second reviewer. I send those to a teammate after my agents and I are happy with them, and by then three models have usually reviewed the change in a loop and I've read it.
What it takes
This only works if you have a lot of ownership over your code. You need good processes in place to make sure you're not shipping slop. The code has to work and it has to be clean, and it can't make it hard for other agents to make changes in the future. It also can't make a big change that negatively affects the business without you knowing.
It helps that I work with a group of experienced devs who have the ownership, skill and confidence to tackle features and changes end to end.
Amp's How We Build page puts it this way: "We merge it, we own it. We make sure it works, keep fixing it, and don't merge what we can't own."
I'm not blocked waiting on people anymore, and the few changes that need a second set of eyes still get them.