30 Years of Code Review: How Every Fix Created New Bottleneck Until Now | Santosh Yadav, CodeRabbit

This talk discusses the evolution of code review processes, beginning with Fagan inspection in the 1990s, which involved physical code reviews using printed copies and manual annotations. The speaker outlines how, with the advent of email and the internet in the 2000s, teams began leveraging asynchronous collaboration to share code changes across distances. The introduction of platforms like GitHub in the 2010s marked a significant shift towards modern, web-based pull requests, allowing for more efficient code reviews. In the current landscape of the 2020s, the integration of CI/CD and AI capabilities has improved the code review process, enabling real-time feedback and reducing bottlenecks. The speaker also highlights the innovative tools being developed by Code Rabbit to enhance both human and AI-assisted code reviews, promoting faster and more reliable development cycles.

Okay, so I I work at a code review company, you know, I started working for them 5 months ago, Code Rabbit. And when I joined them, I was like, "Oh, how did this all process of code review started?" Because my earliest memory is not reviewing the code at all. Like I started as a person who was working in a single company, single person company. Uh I was

the one who was a developer who was actually writing code, building it, shipping it, deploying it. So, my first introduction to actually reviewing a code was GitHub. I think most of us, right? I think that's where we started. We started seeing the UI and that's where we started collaboration. So, it So, I thought like why not to go deep and see the history. So, that's what I'm

going to share with you. So, let's see. So, earlier invention in code review happened way before 2000. So, it was 1990s. What do you think people these people are doing? Wasting time. >> [laughter] >> No, actually they are doing code review. So, this was the earliest invention which happened in 1990. It's called Fagan inspection, named after the guy Fagan, uh he who invented this process. So, what

they used to do is, you know, they do use the paper. The papers are nothing but the copy of your code. multiple people in the team used to take the printout of the code, review it, like they used to actually write it with pen and pencil, like where this might go wrong, come together and discuss if this code is something which can be pushed to the production.

So, this is 1990s, so the process was very, you know, tedious, time-consuming. People used to meet in person, so it's like planning, overview, preparation, then meet finally. If there is a rework, then whole process happens again. Someone takes the printout, goes ahead, and then yeah, I if there is no no follow-up question, people think it's all good. There is no infinite loop. Let's go and merge the

PR. So, this is what 1990s happened. And then the era of email or internet came in, 2000. I think I came to know about this when I was actually looking at some of the emails from Daniel Steinberg. I think that guy is a legend, like so everyone knows curl. And he actually mentioned in one of his post. So, he he pushes everything as a blog post on

his website, and you can see there is actually mention of emails. I was like, really, people used to do this? So, in 2000, what happened is, of course, internet came. And this was the era where collaboration started. Like people who have internet access sitting there in other country apart from US, of course, and then they can actually raise a patch to another person who is sitting somewhere

else in the world. So, this is the era where asynchronous, no in-person meeting started happening. People used mail and diff tools to share the code and say, "Hey, this is the this is the PR you need to push and merge." And really happened over email. So, it was like a big trail of email. If you see, I think that curl is the best best example. I think

you can still find some of the some of the email trails there. And I was at FOSDEM, and there were so many projects who are like decades old, and they also have this mail trail somewhere. Then 2010, this is where I think most of us started our career. Yep, we are old now. So, this is the era of pull request, right? GitHub came in. Now you can

actually see the diff in the UI. So it was the birth of modern code review. This is it started happening asynchronous, more collaborative. It was more web-based review using GitHub or GitLab. And no one needs to actually wait until the code is approved, right? Uh sorry, need to wait until the code is approved. So now you can actually put guardrails, which was not there before, right? And

but I think there are still many in-person reviews which was happening with the introduction of GitHub because, the It was still not the era of remote work. Remote work was not there, like it Maybe there are few companies which has been doing it. GitHub has been doing it for years. And then 2020s, the remote and CI/CD, now actually it started asynchronous, global, efficiently everyone started working from

anywhere. More checks on CI. So now I actually code review became a little bit easier. You got your linting. You have your hooks on CI/CD. You can actually check like what what can go wrong. You can also build check the build status before you actually go ahead and review the PR. But there was still one thing missing. Developers were waiting for days to get their PR reviewed,

right? Still that is This is something which is still happening like because number of PRs a team is raising is exponential like with the introduction of AI. So this is 2020s, lot of new checks started coming into the GitHub and people started using it to actually reduce the time. Then code review became a bottleneck again. And this is me asking my senior engineer to review my PR

again. So yeah. Then the era which is now, 2024, which is AI augmented. Now it's asynchronous and the future of code review which we are all going through. So, no need to wait for your senior engineer to review your code. You can actually just ask AI agent and it reviews your code. It gives you the initial signals if you are like it's if it's a good code

or if there is any bugs. All the AI code agents can actually give you bugs as well as part of your code. You can actually get instant feedback on GitHub, IDE, CLI. There are multiple channels now apart from just And now more ship more code is actually shipped with confidence. So, I'll just skip the slide, but what is next? So, this is what people are already doing.

So, CLI. So, people can use go ahead and use CLI to actually review their code. People are using agentic AI to review their code where actually the agent can work in a loop and look through all your code base, review, fix, and actually give you the final code which has no comments. Uh at CodeRabbit we are trying to actually change how uh code review looks like. And

it can be used for agents as well as humans. So, this is our new UI we are actually experimenting with it. So, if you have an open source project, go ahead and give it a try. It's available for everyone. Uh sorry. Uh someone was taking a picture. Uh I'll just go ahead and say share and you can meet me afterwards. I can I I'll show you uh

it's it's free for open source as as well. And before you do decide not to do code review, I read this poem a lot. You we can You can trust in a god, but before you do your code review, like don't trust any anyone blindly. So, go ahead and have a code review tool. So, that's it from my side. Sorry. Uh yeah, that's it. Thank you. >>

[applause]