re:Invent 2025: Accelerating Development Velocity with Graphite's AI-Powered Code Reviews

Introduction

By transcribing various overseas lectures into Japanese articles, we make hidden, high-quality information more accessible. The presentation featured in this project, based on that concept, is as follows!

For transcriptions of re:Invent 2025 sessions, please refer to the information summarized in this Spreadsheet. Please check it out.

📖 re:Invent 2025: AWS re:Invent 2025 - Accelerate development velocity with better code reviews (DVT344)

This video introduces Graphite's AI-powered code review platform. Adopted by companies such as Shopify, Snowflake, Robinhood, and Duolingo, it has enabled Shopify to merge 33% more PRs per developer and Asana to ship 21% more lines of code per engineer. In the age of AI, code generation is accelerating, but reviews have become a bottleneck, and simple LLMs are insufficient. Graphite integrates specialized AI review agents, a smart workflow inbox, and self-healing CI features, providing agents capable of direct collaboration on the PR page. 55% of Graphite Agent comments lead to actual code changes, achieving an accuracy rate that surpasses the 49% of humans. At Shopify, three-quarters of all PRs are merged through Graphite, saving hundreds of engineering hours.

https://www.youtube.com/watch?v=xWf6zkw2Ni0

• Note: This article was automatically generated while maintaining the content of the original lecture as much as possible. Please be aware that there may be typos, omissions, or incorrect information.

Main Content

A New Bottleneck in the Era of AI Code Generation: The Importance of Code Review

Amazing. Hello, re:Invent. First, I'd like to share a little secret with you all. This is the best part. Many of the world's fastest-moving companies and engineering teams no longer use GitHub for code reviews. Now, what does this mean? It means they have realized that in this new era of agentic software development, they need an entirely new code review platform that can keep up with the speed at which software is being written. And that is exactly what we have built at Graphite. We are building an AI-powered code review platform for this new era of agentic software development.

Before we dive in, let me give you a quick introduction to Graphite. We have had the privilege of working with some of the fastest and largest engineering teams in the world. Teams like Shopify, Snowflake, Robinhood, and Duolingo. And this isn't just about hype. We have provided them with real business value. For example, after adopting Graphite, Shopify began merging 33% more PRs per developer. Asana is shipping 21% more lines of code per engineer, and we have achieved this time and time again for hundreds of thousands of engineers across the industry.

Before we get into exactly how we do this, I want to talk about why code review is important right now and why this cannot be done by a simple AI model alone. Let's start with the first thing: why should you care about code review? Isn't that enough on its own? Can't we just leave it to AI and have it write all the code for us today? If you think about it, the answer is that writing code is just the first part of the story. How many of you here are engineers? Please raise your hands. Yes, almost everyone here. So, you know that writing code is just the beginning.

After writing the code, you build it locally and debug it. But after that, you still have to go through the entire outer-loop process of getting the code reviewed, testing it, reviewing it, merging it, and deploying it. At enterprise scale, this is often more of a bottleneck than writing the code in the first place. Even before this AI era, my co-founders and I all came from large companies like Meta and Google, and it was often the case that we spent more time waiting to get code reviews from colleagues than actually building features.

So, code review has always been a bottleneck in the enterprise, and it has always been important. But now, AI is making this 10 times worse. Because every engineer is now using fantastic tools like Claude, Cursor, and Windsurf to build features faster than ever before. But again, this is just shifting that bottleneck to the right. All that code still needs to be reviewed. It still needs to be tested, merged, and deployed. And now, what we are hearing from many of our largest customers is that their engineers are drowning in PRs. They cannot find enough time in the day to review the PRs that their teams can now create.

I thought this tweet really summed it up well. The new bottleneck is no longer doing the work, but reviewing the work. This is our conclusion number one. In this new era of AI, code generation needs AI code review. If we really want to unleash the power of LLMs for code generation, that is. Put another way, applying AI to the IDE is just not enough. If you want to truly maximize what LLMs can do for software development, you need to apply AI to the entire toolchain.

So that answers my first question, but now you're probably wondering, why can't we just rely on base LLMs? Aren't Claude or GPT-5 good enough as reviewers? Couldn't we just cobble something together and throw it into a GitHub action? Actually, that's exactly what we did when we first tried to build this. In the early days, before AI was truly powerful, we were just building workflow tools, and our first approach while experimenting was to take the diff of the code, feed it to Claude, and see what happens. So we tried that.

And these are some of the typical responses we got. For example, 'You should update the code to do what it was already doing,' or 'CSS doesn't work this way,' or 'You should add comments here'—this is a classic one. Or, 'You should revert this code to do exactly what it was doing before.' It was like putting an intern into the codebase on their first day and asking them to perform a complex refactoring.

This was our second major insight. While LLMs are RL-trained to generate code in seconds, reviewing and understanding code is a much harder problem that requires a lot of specialized engineering. This is an example of what's known in LLM research as the "Generator-Validator Gap," where LLMs are excellent at generating valid examples of something, but far worse at understanding and verifying why it is valid. They cannot accurately introspect and teach you why this is correct or why it matches the patterns we desire.

And that was the second major insight, which leads to this third point, and the most interesting question: How does Graphite accomplish this? How are we helping enterprises ship code faster in this new era of AI?

Graphite's Multi-Faceted Approach: AI Review Agents and End-to-End Platforms

It’s a multi-faceted approach. Simply introducing an agent to review code isn't enough; you need to completely rebuild the entire platform for code review and the end-to-end pull request experience. And that is exactly what we have achieved. First, we have an AI review agent that scans every pull request in seconds. It can find bugs, security vulnerabilities, and common issues that developers look for in code reviews. But instead of waiting hours or overnight to get a review from a colleague, it provides feedback in seconds.

This means you can save hours of back-and-forth communication. What used to take multiple review cycles can now be condensed into one. However, we combined that with a best-in-class code review experience. We provide an inbox that integrates workflows, showing exactly which PRs are waiting for your review and where your changes are in progress. It is surprising that even after ten years, GitHub hasn't built a way to organize workflows and see what needs to be done. That is the first thing you see when you log into Graphite.

We also offer smarter, self-healing CI. If a test fails, the Graphite Agent suggests a fix. You can re-run it or re-queue it to unblock yourself. We are also planning to introduce merge conflict resolution soon. If something fails during a merge, the Graphite Agent will fix it and leave it in a state where you can continue with a simple approval. We can also measure developer productivity, consolidating everything into a streamlined platform.

This is a quick view of our new PR page. Let’s see if we can play this. Basically, you have a PR, but there is a full chat window right next to it. In Graphite, you can ask questions, understand the changes, or highlight specific issues. You can actually give instructions and work with it. In this case, we are asking the Graphite Agent to swap out a model. It actually makes the change inline and proposes the code modification.

You can open the full editor, see the generated diff, and apply that change with a single click. Previously, you would have had to go back to your IDE, make the change, pull the changes, add them, push again, and wait for another review—a process that took minutes or even hours. Now, this is all happening in seconds directly on the new Graphite PR page. Yes, just as Cursor did for VS Code by embedding AI directly into the IDE, we are doing the same for pull requests with Graphite, introducing an agent that can collaborate in real-time directly on the PR page.

Now, regarding the Graphite Agent—it doesn’t just exist there to work alongside you. You can actually verify its results and see the acceptance rate of its comments. Less than 4% of Graphite Agent’s comments are downvoted or marked as inaccurate, and 55% of its comments actually lead to underlying code changes. This is how we measure and verify that every change Graphite Agent makes—or every change it suggests—is a good one, and that the code actually warrants a change. For comparison, humans are at about 49%, so we have actually surpassed that. Graphite Agent is now superior to the majority of human code reviewers in terms of the percentage of comments that ultimately result in actual code changes.

Proven Impact on Enterprise: 33% Productivity Gain at Shopify

I want to return to the enterprise impact and talk about this. Shopify is one of our major clients, a company that has worked with us and pushed us to ensure their engineering team can move as quickly as possible. As you can imagine, they have been in the middle of a full-speed sprint leading up to Black Friday and Cyber Monday over the last month or two. This represents massive code pushes for them. They have been processing tens of thousands of PRs. And with Graphite, they have seen actual results in terms of developer efficiency.

They have shipped 33% more PRs per engineer. Currently, nearly three-quarters of all PRs at Shopify are merged through Graphite rather than GitHub. Again, this covers hundreds of thousands of PRs. If you really want to dig into what the enterprise impact of this is, we have saved development time equivalent to hundreds of additional engineers. Even if you save an hour or two of review time on every PR, or save time waiting for someone to unblock you, that adds up to a massive amount of time over an entire year. It returns a huge amount of engineering time to the team, allowing them to spend less time on reviews and more time on the important things—actually building.

When we look at the big picture, we are truly excited and proud to be able to partner with some of the industry-leading companies.

I mentioned Shopify, but we are also working with teams like Robinhood, Snowflake, and Ramp, as well as AI-native companies like Harvey, Replit, and Vercel. We are seeing widespread adoption across the industry, and we are witnessing growing excitement for what AI can do not just in the IDE, but across the entire outer loop.

Going back to the graph I showed earlier, what we have built is a world-class code review platform on top of GitHub. We are trusted by some of the best developers and teams in the industry, and we are introducing AI into the pull request process, transforming what code review looks like in this new era of software development.

There are a few key points I want to leave you with. First of all, LLMs are generating a massive amount of code for enterprise engineering teams—more than they can safely review. Not only is more code being generated than ever before, but approximately 70% more code is being generated per engineer compared to 2023. The volume of changes being created with the help of LLMs is truly exploding.

It is not just that the volume of code is increasing; it may also be that the code is less valid and less secure than ever before. Let’s be honest: is every engineer scanning every line of generated code? Probably not. They are in a rush and pushing code, but we need better tools to ensure that, in addition to handling the volume of code, the AI-generated code is reviewed, safe, and verified.

There is more code than ever before, and AI code review is needed more than ever. With traditional tools or LLMs, you cannot just throw Claude or GPT-5 at it and expect it to work. You really need a completely new platform for code review in this new era, and that is exactly what we have provided.

Graphite has built that platform. We have integrated AI into the entire pull request lifecycle—from the moment it is created to the moment it is merged—and by doing so, we have delivered measurable, superior enterprise outcomes. Thank you. That is all.

You can find us at graphite.com, so please check it out. You can try the platform for free for 30 days. We are also right there at booth 535, so please stop by. We have plenty of staff available to talk more about the platform and the details, and we look forward to speaking with all of you. Thank you very much, everyone.