
Harjot Gill remembers finding around 600 pull requests open at once. Agents opened them from Datadog alerts and support tickets, and all of them had gone through code review. But whether those changes were necessary was still an open question.
On this episode of The Merge, the CodeRabbit founder compares notes with Ryan Vogel of OpenCode. Ryan’s open-source project was getting around 200 new PRs a day when they spoke. They both agree that while AI-written code is useful, the harder part is deciding what to merge, what to push back on, and what to drop.
The deciding starts before there’s a diff
Before any code exists, someone has to spell out what the software should do and how much complexity the problem deserves. Ryan’s example is a kitchen to-do app. Give the job to an agent and it adds a database, then a caching layer, then more infrastructure. None of those decisions look wrong at the time, but the app ends up far more complicated than a to-do list needs to be.
Ryan’s answer is to keep asking what the app needs to do and whether each decision helps. He has agents lay out their architecture so he can challenge the parts that aren’t needed, and he runs a separate agent that checks intermediate work against the original direction. The checks give the work a reference point. Without one, each decision justifies the next, and a project can drift far off course even though the individual steps look productive.
Reading a change in the order it was built
Once the code exists, the reviewer needs to understand how it fits together, and a raw diff doesn’t show that. Harjot explains that CodeRabbit works out the order in which the changes would have been made and reviews them in that order. The review runs in three layers, from the bottom up.
- Data and schema changes sit at the bottom.
- Functions, business logic, and API routes build on those.
- The interface and its tests sit on top.
A schema change explains why an API behaves differently, and the API change explains what the interface now needs to handle. A reviewer reading in that order checks the assumptions that connect the pieces instead of inferring them from filenames.
After an agent has worked for hours, its full session history is one more long thing for the reviewer to read. A useful handoff shows the important decisions, how they depend on each other, and where the reviewer should look more closely.
Evidence over confidence
An agent sounding confident about its work doesn’t mean the work is correct. CodeRabbit ran into this early with hallucinations, Harjot explains, because a model forced to produce an answer will make one up. The team’s fix was an escape hatch, so a model without enough information can ask a question, investigate further, or write a script that checks its hypothesis. Hallucination rates came down once it had those options.
In review, the same discipline means treating a suspected bug as something to test before it becomes a comment a developer has to act on. The person receiving the finding can inspect how the conclusion was reached, run the check, and challenge its assumptions. A script can still be wrong or incomplete; its value is that it makes part of the claim testable.
Agents are best suited to tasks with a clear end condition, like adapting a working integration for another platform, because the agent and the reviewer both have a concrete result to check. Open-ended design work needs more frequent human decisions, because the desired result is still taking shape while the agent runs.
The handoff between people
The handoff from agent to developer gets most of the attention, but the handoff between people matters just as much. Code alone doesn’t show why an approach was chosen, what was tried and abandoned, or which choices were deliberate and which were defaults.
Ryan’s team shares the sessions behind their changes, so a teammate examining code can also see the prompt and the decisions that produced it. Harjot points to the same principle in CodeRabbit’s collaborative memory, where feedback from one developer’s review informs later reviews. Either way, the next person can see what was attempted and decide what still needs validation.
Not every change deserves the same scrutiny. A small interface change that rolls back in minutes doesn’t carry the same consequences as a change to a mature code path that many people depend on, and review effort should reflect the difference. More generated code doesn’t make every change equally urgent or equally risky.
A good handoff, wherever it happens, shows the problem being solved, how the change is structured, and the supporting evidence. It also makes clear which decisions are still left to a person. The next reviewer should be able to understand the work well enough to decide whether it belongs, without starting the investigation again.
Watch the full conversation
Harjot and Ryan also talk about CodeRabbit’s first prototypes in the GPT-3.5 era, the early bet on code generation over tool-calling, and what collaboration between humans and agents could look like next. Watch the full episode of The Merge. Deciding what to keep starts with understanding.
If your team has a long PR queue and no clear way to decide what to merge, CodeRabbit Review checks pull requests with codebase context, and CodeRabbit Explain organizes related changes into layers with explanations tied to the code.



