Vibe Coding All Day? Stop Delivering PrototypesㅣGraphite, Merrill Lutsky

Merrill Lutsky co-founded Graphite after noticing that engineers coming from Big Tech firms like Meta experienced severe productivity drops when forced to use traditional GitHub pull requests. By pioneering stacked pull requests and partnering with Anthropic to power an agentic AI code review companion called Diamond, Graphite streamlines the outer-loop code review process. The company recently announced a $52 million Series B after growing 20x in a single year and cutting development cycle times by 3x at companies like Ramp. In this interview, Lutsky explains why AI code generation makes code review the true bottleneck, why software engineering is shifting toward product-level review, and how to build enterprise trust progressively.

Hi, I'm Merrill Lutsky, co-founder and CEO of Graphite. Graphite is the code review platform for the age of AI. We take best-in-class workflows and tooling from companies like Google and Meta and combine them with our agentic AI code review companion to help engineers create, review, and merge code changes faster than ever. We work closely with the team at Anthropic to power our AI code review agent, which is called Diamond. The Series B that we just announced was $52 million, and Graphite has grown 20x in the past year.

Graphite started on a completely different idea. We actually had two pivots, one small pivot in the beginning during the first three months and then the iOS tool. We had hired a few engineers in the process, a few of Tomas's ex-coworkers from Meta, and we had this really peculiar thing happen when they onboarded.

They would start on their first day and we would get them set up on GitHub. We would show them how we do code review at the company, and all of them had this kind of allergic reaction to it immediately. They all said that this feels so much slower than the tooling that I'd had at Meta. I feel like a caveman using this.

Google and Meta have both built amazing internal tools to help their teams of thousands or tens of thousands of engineers, all working on one monorepo at once, even across time zones and spanning these massive code bases. If you go outside of those walls, though, it's very hard to get that same level of productivity and to have that same tool chain. That was a lot of why we started Graphite, because we saw the gap between what we had at the large companies that all of us on the founding team had worked at and what was available to every company when they are just getting started. That was really what inspired us to build Graphite.

I think it's so important to deeply understand and care about the user that you're building for. If your company is successful, you're going to spend 10 plus years talking to these people every single day. And if you don't genuinely care about making their lives better, about solving their problems, and about building a product experience they really enjoy using and get a ton of value from, it's going to be really hard to sustain your level of enthusiasm about that.

One of the things that's so fun about Graphite, and one of the best parts about getting to work on this, is that it is something we all use on the team every day. A lot of great companies use it every day. Our friends at these companies are using it and are constantly texting me with feedback. It's just fun to be able to build something for a user that we're so deeply familiar with, and that we genuinely care about and want to make their lives better.

So in the beginning we started with a tool for creating stacked pull requests. The idea of stacked pull requests is that instead of having all of that be one pull request, you break it up into a series of small dependent changes that all chain together and build upon each other. And the advantage of this is that, first of all, nobody likes to review a thousand line pull request. There is that meme where a thousand lines just gets a looks good to me.

And I think that really is what you see play out in the data. Nobody wants to give a detailed review to a change that big. That's really why stacking is so powerful, because it gives you so much time back that you would have spent sitting on your hands or trying to find something else to build.

And we've seen really meaningful improvements in development speed at many of our top customers. Asana was the one where we saved seven hours per developer per week. At Ramp, we increased their development speed by 3x. One of our advisers famously said that once you stack, you don't go back. And I think that's really true in terms of both the user excitement and also the retention numbers and the engagement that we see with Graphite pretty much every day.

As every engineer has tools like Cursor and Windsurf and Copilot, and even some of these more agentic code generation tools now, they're able to write code faster than ever. They're creating more code changes than they ever have before. That's only really the first part of the story. I think even what we're seeing with vibe coding right now is that a lot of those products are kind of MVP like.

You still need to take that change and get it through code review. You still need to test it. You still need to deploy it and measure the impact. That whole outer loop process, where you're collaborating with your teammates, is a huge part of your life, in many cases almost as much as the inner loop of how I'm writing code, testing locally, and getting it ready to push up to a pull request.

So I think that as you have this idea of vibe coding and AI code generation, it's almost not enough to be just an engineer anymore. The best engineers are also great product thinkers and great business thinkers, and great designers in some cases. It used to be the case, I think, that the limiting factor on creating anything was asking how do I actually build this and how do I implement it. Now you have these great tools that can help you answer that question and get to an early version, like a working prototype of something, quite quickly.

So then the question shifts from how do I build this to something a little bit further upstream, which is what should I build in the first place that's actually going to be of value. How do I actually interact with this, and what is the optimal experience here? Then how do I differentiate that? In a world where anybody can go on Replit Agent and with a few prompts make a working prototype of something, how is that different from anybody else's vibe-coded version of this? I think that software engineering looks a lot more like reviewing, or even designing, or PMing in the future, versus writing code as we know it today.

The transformation of software engineering with AI code generation has just been the sort of seismic shift that's happened as we've been building the company. We were fortunate in that we were working on solving a problem that was now made 10 times worse by AI code generation. Code review, and this outer loop of review and testing and deployments, has always been a bottleneck at large companies, and it's always been an area that needs better tools. That was true before AI, but now with all these great AI code generation tools, that need is all the more acute.

And I think that's one of the things where we were lucky that we were building the right thing at the right time. Because we built tooling for accelerating the outer loop and we got that into a lot of great enterprise customers, we also built the trust with those organizations to be able to now deploy AI to help them review code faster.

It's really hard, if you're just starting an AI code review company, to convince an enterprise or a company like Shopify to give you access to their entire GitHub repo from day one. It's taken us a long time to build up that level of trust, and I think there are a few factors there. One is just building and adding value progressively over time, shipping features constantly, and showing the customers we worked with early on that we are consistently able to deliver on our promises and continue to add more and more great features to the Graphite platform.

We spend a lot of time making sure that everything we do follows best practices for security. We're pentested very regularly. We really want to invest in making sure that that piece is central to what we're doing. And then part of it is just climbing the ladder.

I think you have to start with smaller companies first, because you're always going to have smaller companies that are willing to adopt tools in the beginning, and then you build up trust over time. I think now that snowball has really started to roll. We have some of the largest technology companies out there trusting Graphite every day, and we're really privileged to be able to serve them.