Your Code Review Bottleneck Isn’t What You Think
Your teammate builds a feature with AI in 20 minutes, and you spend the afternoon working out what it does. If you’ve started to wonder whether you’re the bottleneck, here’s how I think about it: the review burden usually has two different sources, and they need two different fixes.
This video separates the amount of code coming at reviewers from the understanding that hasn’t happened before the code reaches them. It uses one example (a spreadsheet import that quietly brings back an old phone number) to show what understanding a change actually involves, and ends with two things to try on your next few pull requests.
Loading the video…
Still loading. A slow connection can take a moment. The transcript is below.
Transcript
00:00 Am I the bottleneck?
Your teammate uses AI to build a feature in 20 minutes. The code looks tidy. There are tests. There’s even a detailed pull request description. Beautiful! Then you start reviewing it.
You ask what happens in a particular situation. The author isn’t sure, so you trace the implementation, work out what it does, discover a problem, and explain it back to them. And by the time you finish, another PR has arrived.
On screenA pull request mock-up: “#482 Import customers from spreadsheet”, built in 20 minutes, 12 tests passing. The review thread follows, and a second PR lands on top of the first.
If that sounds familiar, you might be wondering, “Am I becoming the bottleneck for the team?” I think that question hides two different problems. One is the amount of code coming at you. The other is the amount of understanding that hasn’t happened before the code reaches you. And addressing one won’t necessarily fix the other.
00:50 Two sources of review burden
So let’s start with the volume. If your team produces changes faster than people can review them, the queue grows. Even well-written code from capable developers still requires someone’s attention.
Then there’s a second problem. An author submits an implementation they don’t understand well enough to explain or evaluate. Now the reviewer has to figure out how it works, assess whether it’s appropriate, and bring the author up to speed. Some of the work that appeared to be finished is still waiting for someone to do it.
Research suggests that experience still affects how developers work with AI tools. In one study, researchers analyzed about 23,000 pull requests created with AI assistance. They found that pull requests from less-experienced developers received more review comments and took longer to resolve than those from more-experienced developers.
On screenThe study: Novice Developers Produce Larger Review Overhead for Project Maintainers while Vibe Coding (Asdaque et al., arXiv, February 2026). 22,953 pull requests from 1,719 developers; pull requests from less-experienced developers received 4.52× more review comments and stayed open 5.16× longer before resolution.
Now there is a caveat to this that I should call out though. More comments don’t necessarily prove the code was worse, and the study doesn’t establish that AI caused the additional review overhead. In other words, the study compared less-experienced developers using AI against more-experienced developers using AI. They did not establish how those same experience groups would have performed without AI. But it gives us a reason to question the idea that producing an implementation means the difficult work is over.
02:27 What understanding a code change involves
So what does understanding a code change actually involve? Imagine your team needs a feature that imports customer information from a spreadsheet. A new customer should be created, and an existing customer should be updated. A developer uses AI to build it. They try a file, the customers appear in the database. They try updating an existing customer, and that works too. The tests pass, and they submit the change for review. So far, everything looks reasonable.
Then you ask, “What happens if somebody imports a spreadsheet they exported six months ago?” Let’s say a customer recently changed their phone number. Your database has the new number, but the spreadsheet still has the old one. The import finds the matching customer and replaces their phone number with the value from the spreadsheet.
The old number is back, nothing crashed, and the test still passes, but the test checks that the importer replaces the existing value with the spreadsheet values. That tells us the update logic behaves as the test expects. It doesn’t establish whether overwriting new information is what we want.
On screenCustomer 1042: the database has the phone number changed last week (555-0199); the six-month-old spreadsheet still has 555-0142. After the import, the database shows 555-0142 again. The test that still passes: expect(customer.phone).toBe(row.phone).
And maybe it is. Maybe the business treats the spreadsheet as the authoritative source. Or maybe the import should flag conflicting information for someone to check. The point is, we need to establish that before deciding whether this behavior is acceptable. That is part of what the review process needs to examine: how the code behaves in situations that matter, and whether that matches the outcome we intended.
04:04 When the author understands the code
Now the author hadn’t considered this scenario at all. That’s normal as reviewers sometimes bring another perspective, they discover things the author missed. But watch what happened next.
Imagine the author says, “I didn’t think of that. I checked that the import worked. But I’m not sure how it decides which customer to update or which fields it replaces.” So you as the author start tracing the implementation. You find the matching logic, follow it into the update function, and check whether anything protects the existing information. Then you explain it back to the author. You’re now doing two jobs: reviewing the change and helping the author understand the implementation they submitted.
Now let’s replay that scenario with an author who understands the code. So the same implementation, same tests, same missed case. The author may say something like: “I didn’t think of an old export scenario either. We match customer by email and copy the imported fields onto the existing record. But let me check whether anything in that path compare how recent the information is.” They go back, they trace the path, and they come back with: “There’s no freshness checks. I reproduced it. The older number replaces the current one. Our test checks that the values get replaced, but it never tries stale data. So we need to establish which source should take precedence.”
In this case, the reviewer still discovered the problem. But the difference is that the author has something to learn. They investigated the concern themselves. They were able to explain the consequence and resolve it.
That’s what I mean by understanding the code you submit. You don’t have to anticipate every question the reviewer might ask or remember every line of code. But as the author of the code, you should be able to work through the important behavior and check your explanation against the implementation.
LLVM, a widely used open-source project offering a collection of tools and libraries for building and optimizing software, makes a similar expectation explicit in its AI contribution policy. Contributors must review generated material before submitting it and be able to answer questions about their work.
On screenLLVM’s AI Tool Use Policy, with its two relevant sentences highlighted: contributors must read and review all LLM-generated code or text before asking others to review it, and should be “able to answer questions about their work during review.”
06:18 Making the volume manageable
That helps with the second problem: understanding being passed downstream. But we still have the first problem: the volume.
Suppose the import PR also reorganizes the customer service, renames several classes, and adds a reusable framework for future imports. The reviewer now has several decisions to evaluate together.
Before submitting, ask yourself, which changes actually belong together? Could the unrelated refactor be separate? Do we need that additional framework for the current feature? The goal is a change with a clear purpose that someone can follow. For example, keep the changes needed for the import together, including its tests, separate unrelated refactoring, and leave out conditions the feature doesn’t require.
A line limit can warn you that a PR is getting large. But even a short PR can mix unrelated changes, so keep that in mind. So, the useful question is, can the reviewer follow one clear purpose through this change? Google’s engineering guidance actually recommends small, focused changes and generally separating refactors from feature changes.
On screenGoogle’s engineering practices, Small CLs: the right size for a change is one self-contained change, and refactorings usually belong in a separate change from feature work or bug fixes.
And if the review queue keeps growing, the team needs to make room to finish that work. That might mean helping with reviews, responding to feedback, or removing whatever is blocking a change before starting another one. Generating more code looks like progress. But when work is piling up in a review, it’s easy to miss that review is where things are stuck.
07:52 Using AI to build understanding
So there’s an obvious question here, couldn’t we use AI to explain the code or review it too? Yes, but a clear explanation can feel convincing before you even check whether it’s correct.
So here’s a simple approach I would try. Take one important behavior in the change, before asking AI to explain it, write out what you think will happen. For this CSV importer example, we can ask: if this customer already exists, which fields will change? Then use AI to help locate the relevant code and trace the path. Compare that path with your prediction. If they differ, find out why. Finally, run a small example or check a meaningful test. Does the observed behavior agree with your explanation?
On screenThe four steps: Predict, Trace with AI, Compare, Check.
You can also ask AI to suggest a situation you haven’t considered, then investigate it yourself, using the code and tests as evidence.
In a small study from Anthropic, participants who use AI to ask conceptual questions or understand generated code tended to score higher on a follow-up comprehension quiz than those who relied on AI to complete the coding or fix errors for them.
On screenAnthropic, How AI assistance impacts the formation of coding skills (January 2026), a study with 52 developers learning a new Python library. Participants who used AI to build understanding averaged 65% or more on the quiz; those who relied on it to write or debug code averaged under 40%.
Now this doesn’t prove that this particular practice will make your review faster. But it does suggest that how we use AI deserves attention, and not just whether we should use it.
09:17 What to try on your next PR
Now, I acknowledge that all of this takes time. If authors spend longer on their pull requests, does that reduce repeated investigation and rework? Does useful work reach completion sooner? Does quality improve? A shorter review by itself isn’t enough to answer those questions. But the goal is to arrive at review able to help evaluate and improve your own code without that burden falling on the reviewer entirely.
So for your next few PRs, I would try two things. As an author, make sure you can explain and evaluate the important behavior you’re submitting. As a team, keep changes focused and make room to review the work already in progress.
Reviewers will still discover things authors missed. That’s valuable. The goal is for the author to be able to help investigate those discoveries, and for the reviewer to have a manageable change to review.
AI can shorten the path to an implementation. But understanding that implementation is still part of the definition of done.
So, if you’ve been wondering whether you are the bottleneck for the team, look at what’s actually taking your time. If it’s the amount of code, that’s a team problem. If it’s understanding that should have happened before the code reaches you, that’s a different problem, with a different fix.
And for the authors, before you submit your next pull request, ask yourself this: “Could I help someone reason through what this code will do? Or would they have to explain it to me first?”
Loading comments…
Comments aren’t loading right now.
The post is unaffected; the comment service didn’t respond. Try again in a moment, or come back later.
Replies from Bluesky and Mastodon