By ByteBot
Cursor, the AI code editor valued at $29.3 billion, acquired code review startup Graphite on December 19, 2025 for “way over” $290 million, marking its third acquisition in 18 months. The deal highlights a problem nobody’s talking about yet: code review has become the new bottleneck now that AI can write code faster than humans can review it.
AI Writes Code Faster Than Humans Can Review It
Cursor CEO Michael Truell cut to the heart of the issue: “For most engineering teams, reviewing code looks the same as it did three years ago, and it’s becoming a larger portion of people’s time as the time to write code shrinks.” Industry analysis confirms this shift. Teams using tools like GitHub Copilot and Cursor generate thousands of lines of code in minutes, but review processes haven’t evolved. Developers drown in pull requests while reviewers struggle to keep up.
Google engineer Addy Osmani warns that “vibe coding is prioritizing speed and exploration over things like correctness and maintainability.” The velocity gains from AI code generation are real, but they’ve exposed a critical weakness: human review can’t scale at AI speed. What was once the solution—writing code faster—has created a new problem.
Graphite’s Solution: Stacked Pull Requests
Graphite tackles the bottleneck with a workflow called stacked pull requests. Traditional development blocks developers: write code, create PR, wait days for review, context switch, lose flow. Stacked PRs flip this model. Developers write code, create PR1, immediately start PR2, continue to PR3—all while reviews happen in parallel.
The benefits are concrete. Hundreds of thousands of engineers at Shopify, Snowflake, Figma, and Perplexity use this approach. PRs shrink from 50 files to 5, making reviews faster and higher quality. Developers maintain their coding streak without blocking on approvals. For distributed teams, this eliminates timezone delays—developers in San Francisco submit PR stacks, continue coding, while reviewers in Europe handle reviews overnight.
This isn’t just faster review. It’s a process innovation that decouples writing from reviewing. Velocity increases without sacrificing quality because smaller PRs get better scrutiny.
Cursor’s Third Acquisition Raises Vendor Lock-in Questions
Cursor has made three acquisitions in 18 months: Koala talent (July 2024), Supermaven (November 2024), and now Graphite. The Supermaven precedent worries developers—Cursor sunset it after just one year despite assurances. Hacker News commenters voiced concern: “An acquisition like this makes relying on the acquired product a giant risk.” Founders lose control post-acquisition, and promises of independence mean little.
Cursor is building a moat by owning the full development stack: code writing (Cursor IDE) plus code review (Graphite). What comes next? Testing? Deployment? For teams invested in Graphite, this raises real questions about vendor lock-in. The productivity gains are tempting, but the Supermaven precedent suggests caution. Cursor’s acquisition strategy looks less like integration and more like building a closed ecosystem.
The End-to-End AI Development Platform Vision
Cursor plans to keep Graphite operating independently while building “deeper integration between local development environments and pull request workflows.” Graphite CEO Merrill Lutsky said they joined Cursor to create “the end-to-end platform for building with AI.” The vision: connect local development, background agents, and pull requests into one unified system.
Cursor’s announcement hints at “more radical ideas we can’t share just yet.” Read between the lines: AI agents that span writing and review. AI generating code, AI pre-reviewing that code, humans verifying at the end. This could accelerate development dramatically—or create a “garbage in, garbage out” cycle if review quality suffers. Integration is expected in the coming months.
But Is Faster Review the Right Solution?
Not everyone agrees code review is the problem. Some developers argue the real issue is AI writing too much mediocre code. If AI writes 5x more code but introduces 2x more bugs, automating review could just mean shipping more bugs faster. CodeRabbit founder Harjot Gill notes that “human judgment remains essential for architectural decisions, security considerations, and maintainability concerns.”
The tension is real: velocity versus quality. Cursor and Graphite bet that the bottleneck is review speed. But what if it’s review quality? What if we’re papering over the fundamental problem—AI-generated code lacks the architectural thinking and edge case handling that experienced developers bring?
Stacked PRs help by enabling smaller, more focused reviews. That’s a process win. But they don’t solve the underlying question: Are we building faster workflows for reviewing code, or should we be building better code in the first place? The answer is probably both, but this acquisition only addresses one side.
Key Takeaways
- Code review is the new bottleneck as AI accelerates writing 2-5x faster than humans can review
- Graphite’s stacked PRs offer a process solution that maintains developer flow while improving review quality through smaller changes
- Cursor’s acquisition spree raises vendor lock-in concerns, especially given the Supermaven precedent (sunsetted after 1 year)
- The end-to-end vision is powerful but risky—AI reviewing AI-generated code could accelerate development or amplify quality issues
- Velocity vs quality tension remains unresolved—faster review doesn’t address whether AI writes good code in the first place
