Try Pro free

The Pragmatic Engineer · 6 min · Nov 18, 2026

Code review shifts from reading diffs to managing release risk

Harjot Gill argues that humans should judge what to ship and assess its risk, rather than read every diff.

The episode’s best minutes

Full analysis
  1. 20:18Software factories turn each release into a learning loop4 min
  2. 25:29Code review shifts from reading diffs to managing release risk6 min
  3. 55:17Startups have less time to win and need more AI capitalPro pick 8 min
  4. 5 more moments in the full episode
“And once you have like enough strikes, we take your driving license away. We make you go through the code review.”
Harjot Gillat 31:28 · The Pragmatic Engineer
31:28

Takeaways

  1. Human judgment decides whether a change is worth shipping.
  2. Reviewers focus on risk, blast radius, and architectural implications.
  3. Repeated regressions can revoke an engineer's shipping privileges.

About this segment

Harjot Gill argues that humans should judge what to ship and assess its risk, rather than read every diff. CodeRabbit uses production regressions to decide who can ship without review.

Harjot Gill

Harjot Gill is founder and CEO of CodeRabbit.

Co-founded CodeRabbit, the AI code review company that became the most installed AI app on GitHub and GitLab.

  • Gergely Orosz, Host · Host, The Pragmatic Engineer

    Spent four years at Uber heading mobile, web and backend teams; shipped part of its payments system.

From “Software factories and code reviews with Harjot Gill”, Nov 18, 2026. Watch the full episode

Answers “Which jobs will AI replace, and which are safe?” See all 177 answers

Answers “Will AI replace software engineers?” See all 56 answers

Transcript

Transcribed by machine (Whisper) from the episode’s audio, so a word may be off here and there.

  1. 25:36

    Now, I have to ask you this question, is code review dead? Because specifically human code review, there's so many signs that it is on its last legs. The teams who are still doing it, who I talk to, it's kind of theater. It's like, you know, LGTM looks good to me, But people no longer have comments. They no longer read it. And companies like Uber are now making changes to just make it so much easier for people to, you know, like see what a code review does.

  2. 26:05

    Because they also know people no longer, they spend less and less time reading it because there's just more of them, right? You're right. I mean, the human code review is dead, but the human review is not dead. Some review still has to happen. If you look at the software development space, there used to be like a upstream kind of a guard, like when you were like planning the work, because your engineering was an expensive resource.

  3. 26:26

    So when you were using the tools like linear JIRA, one of the reasons to do this Agile and Sprints was to make sure the developers are working on most important tasks. We don't like spend a bunch of time and effort building something that was thrown away. Exactly. So there was a lot of regulation upstream earlier. Now that floodgate has suddenly opened with AI. Now you can go from idea to code without going through planning.

  4. 26:46

    Like you have a support ticket coming in. People will just ask Devin to look at it or code have it slackboard or something, right? At the same time, your designers and people who were not software engineers are now doing coding as they should be because they know what to build. A lot of designers are shipping code. You have background agents like Datadog is now going to be opening PRs. Each time it sees an alert, it's going to say, I'm going to do it for you, right?

  5. 27:07

    So what that means is that your planning layer and the review gate still has to exist somewhere and that becomes a pull request because everything upstream, there's an influx now happening, right? And when you have a pull request open, it doesn't mean that you have to ship it. At that point, you decide whether this is worth spending my time, whether I take it to production or not, because the human taste is the bottleneck now, human judgment.

  6. 27:29

    So when a human is coming in, they're first making a decision. Is this something I need to ship? Is it slop I need to close? I mean, and you make a decision after the code is there, right? Second thing you're doing is like, what's the risk? Can it just go through production without me looking at the code? Or do I need to understand the broader implication? Is it like a database migration it is doing?

  7. 27:47

    Why is it doing the migration? Because you want to sometimes look at the schemas because that's more structural change, right? So we do all that like risk management within CodeRabbit. So some PRs are on fast track to production. We are even letting our interns ship directly to production. So human code review is dead, but I would say humans still review some of the higher order abstraction and how we are like doing this with SOC 2 compliance is also interesting so we don't really so the definition of change at CodeRabbit is now a release so we have a Slack message we kind of get all the indicators around the risk we are taking each PR you have a minimal risk high risk and over there you kind of make a decision on whether this can go or some things have to be rolled back so each release is what we are reviewing now

  8. 28:30

    not PRs as a human And then when you say human review, just to be clear, human means software engineer, or can it also mean non-software engineer? I'm just curious if you still think the accountability needs to sit with people who kind of know the internals, or can it be someone else? Can it be product manager or designer? I think it's still software engineers that code rapid. Like, they're not necessarily looking at the code anymore, but they are actually understanding the risk that we are taking with each.

  9. 28:55

    So it's about who can understand the risk. Yeah, because if something goes bad, then they are going to be the one dealing with it, like rolling back. Like it takes like 10, 15 minutes to roll back. I mean, that's the worst that can happen if something goes bad. But they are still taking the responsibility. So we ideally want like developers to be around when something goes out so they can babysit what they've just shipped.

  10. 29:13

    That's why we try to release so frequently. But at the same time, like with the person who's approving the release, we have SREs and all. So they also like are taking some responsibility at that point. I think it makes perfect sense, especially for a business, because we're talking about a business where you actually have revenue, you users, you know, like if slop goes out and it takes down production, you're going to just lose customers or goodwill or cost frustration and so on. So I think it's great that you're saying, okay, let's have someone accountable. But the problem that us devs have is there's just a lot more changes. And I'm not going to have time to read through all of them. What ways are you thinking either now or in the future? What do you think needs to change so that as engineers,

  11. 29:52

    as the person who's making the decision, I can just have better information to, you know, like focus my attention where I need to focus. Like, for example, I don't really want to review a manual refactoring that just move things around and it compiles. I mean, I could, but, you know, there's good use of my time and there's poor use of my time. And I feel, as you will know from yourself as well, I mean, you've shipped like so many poor requests, you will probably focus your time on the critical stuff.

  12. 30:19

    That's right. I think the human judgment is scarce now, right? And if you want to, like, first of all, not look at the code, there's higher order abstraction. You want to understand the risk, understand the blast area, especially if you are familiar with some area of the code. You might also want to have inputs on the architectural change. Like, for example, like, if you're writing a migration on a large table, like, it's going to crash in production.

  13. 30:39

    You have some of these, like, tribal knowledge you want to bring in, right? Other thing is, like, also, like, I kind of see, like, now driving these agents almost like getting a driver's license, right? So we basically, even on the developers, put some responsibility on them who are shipping. So we let people ship if they are in the review exempt list. So we also have different lists and groups and teams where based on their experience and their past performance, they can either go to production without a human review or we put them in a group where they need a human review.

  14. 31:07

    That sounds like based on a trust that you built up with them. The way we have done that is we do look at how long there was a regression in production. So because we look at the code, when you fix something, we are able to tie that back into the PR that introduced it. And now if someone has been irresponsible, like they did hard prompting there, or they did not follow through their change into production, you will have sometimes a hundred hours of exposure.

  15. 31:30

    I mean, someone had to point out, a customer had to point out that something regressed, you didn't QA it or something. And once you have like enough strikes, we take your driving license away. We make you go through the code review. Then you go through like a proving period with some human reviews, and then we let you ship on your own. So we're trying to set up a culture where I think responsibility is also with the developers to not drive these agents off the cliff.