How Graphite Solves the AI Code Review Bottleneck That's Slowing Down Development Teams
AI has fundamentally changed how we write code, but it's created an unexpected problem: the faster we generate code, the bigger our review bottleneck becomes. Merrill Lutsky, Co-founder and CEO of Graphite, has been watching this shift unfold across development teams and believes we're entering a new phase where code review—not code generation—is the primary constraint on shipping velocity.
The New Reality of AI-Accelerated Development
"The biggest problem right now that teams are having with AI code generation is that it's an amazing lever that gives you the ability to build features faster than ever, but it also creates a ton more code that then needs to be reviewed," Lutsky explains. This isn't just about volume—it's about quality and security concerns that come with rapidly generated code.
The challenge compounds because engineers often don't scrutinize AI-generated code as carefully as they would their own work. "A lot of times, engineers aren't necessarily looking at every single line, so there's both more code to review and a greater need to inspect every line of code that's being written," Lutsky notes. The result is teams finding themselves in a position where they can generate features quickly but struggle to get them through review and into production.
From Code Generation to Code Validation
Graphite's approach addresses this bottleneck by combining proven workflow solutions with AI-native code review capabilities. The company started before AI code generation became mainstream, focusing on workflow solutions that help large-scale engineering teams manage code review effectively—the same tools that enable companies like Meta and Google to scale code review across thousands of engineers working in monorepos.
Their key innovation is Diamond, an AI code review agent that scans every code change within seconds and provides human-like feedback. "Diamond is able to find and help you iterate on your change and find all the bugs and security vulnerabilities before a human even needs to look at it," Lutsky explains. This saves hours of back-and-forth in the traditional code review process.
The Agent-to-Agent Review Loop
One of the most interesting developments Lutsky has observed is how cutting-edge teams are implementing agent-to-agent workflows. "We're seeing some companies that have adopted both an AI code generation tool and then pair that with Diamond, and you get a back-and-forth where the code generation agent writes the pull request, Diamond reviews it, the agent makes updates based on Diamond's comments—you have an agentic iteration loop before a human even enters the process."
This creates a new development paradigm where multiple AI agents collaborate to refine code before human developers need to intervene. The result is that by the time a human reviewer sees the code, it's already been through multiple iterations and is closer to production-ready quality.
Preparing for the Asynchronous Development Future
Lutsky predicts significant changes to how developers work day-to-day. "We're not going to be in IDEs and terminals entering commands, editing line by line. It's much more that we're going to be writing prompts, kicking off agents that are working in the background, and then coming back to us with pull requests."
This shift toward asynchronous, agent-driven development means developers will spend more time reviewing and validating code than writing it line by line. The local development experience as we know it will largely disappear, replaced by remote development environments where agents do the heavy lifting while humans focus on architecture, validation, and strategic decisions.
Practical Tools for Today's Challenges
While the future vision is compelling, Graphite addresses immediate needs that development teams face today. Their platform includes:
Stack Pull Requests: Managing complex, interdependent changes that are common when AI generates larger code modifications.
Merge Queues: Handling the increased volume of pull requests that result from accelerated development cycles.
Automated Code Review: Diamond's ability to catch bugs, security vulnerabilities, and performance issues before human review.
Preview Environments: Allowing teams to test AI-generated code in isolated environments before merging.
The Infrastructure Scaling Challenge
As teams adopt AI code generation tools, they're discovering that everything downstream of code creation needs to scale dramatically. "Everything that happens after creating code now needs to handle 10 times the volume it used to," Lutsky observes. This includes deployment systems, testing infrastructure, and monitoring capabilities.
Graphite helps teams prepare for this scaling challenge by providing the workflow tools and automated review capabilities needed to maintain code quality while handling increased throughput.
What This Means for Your Team
For developers, engineers, and architects, the message is clear: the bottleneck in software development is shifting from "how quickly can we write code?" to "how quickly can we validate and ship code safely?" Teams that recognize this shift and invest in better review processes, testing infrastructure, and validation tools will have a significant competitive advantage.
The companies succeeding with AI code generation aren't just those using the best generation tools—they're the ones that have solved the review and validation challenge. As Lutsky puts it, "Now that it's much easier to write code, we're removing the next biggest bottleneck, which is the code review process and what needs to happen to actually get this out to production."
The future belongs to teams that can move fast while maintaining quality, and that requires rethinking how we approach every step after code generation. The question isn't whether AI will change how we develop software—it's whether your team will be ready for the new bottlenecks that emerge.
