Cursor Origin
Who Reviews Agent-Written Code? The Capacity Problem
Nobody can hand-review code produced at agent speed; a demo slide at Cursor's Compile event claimed 22.6 commits per second on one repo, and Hacker News asked who reviews it. The working answer today is three mechanisms stacked together: smaller units of review (stacked diffs), automated first-pass review like Bugbot, and merge queues that keep main green.
On this page
Why is review the bottleneck for agent-written code?
Coverage of Cursor's Compile demo carried one figure that did more work than the rest of the launch combined: a slide claiming Origin handled 22.6 commits per second against a single repository. Treat the number the way this site treats every pre-launch figure, as a demo claim rather than a benchmark. The reaction it produced is the interesting part, because even at a hundredth of that pace, no team on earth reads every change.
Human review capacity is measured in diffs per day, not per second. A careful reviewer reconstructs intent, checks the change against what was asked, and decides whether to trust it, and none of those steps got faster because a model wrote the code. So the queue moves. Writing stops being the constraint and everything after it, review, merge, CI, becomes the place work piles up.
That mismatch is not a flaw someone forgot to fix. It is the design problem this whole product category exists to answer, and it is worth being suspicious of anyone who claims it is already solved.
This is covered hands-on in Cursor Compile 2026 — 1 short module, free to read.
What did Hacker News say about Origin's launch?
Origin's launch thread went up on June 16, 2026, pointing at a page that was a tagline and a signup form. The thread was small but the objections were the right ones, and they have aged well precisely because Cursor still hasn't answered them.
One commenter: "I've never seen a waitlist for such little information." Another asked how Origin differs from GitHub at machine speed, and whether a human is "still in the loop of reviewing the AI slop." A third argued the opposite corner: LLM-generated code still fits fine with normal pull requests and review.
The middle objection is the sharp one. Storage and merge throughput are engineering problems with known shapes; review capacity is a human limit. Speeding up how fast machines write and land code does nothing for you if nobody can vouch for what landed. Any honest answer to the thread has to describe who, or what, is doing the vouching.
How do teams review code at agent speed today?
Three mechanisms carry the load right now, and none of them requires Origin. Each attacks a different part of the capacity problem, and each has a failure mode worth naming up front.
- Mechanism
- Stacked diffs
- What it fixes
- Breaks one big change into small units a human can actually read
- What it doesn't
- Total volume. Five small PRs review faster each, but they are still five reviews
- Mechanism
- Automated first pass (BugbotCursor's automated PR reviewer that posts inline findings and can push fix commits from isolated VMs. Press Enter for the full definition., Graphite's Diamond)
- What it fixes
- Triages likely bugs so humans start from a flagged diff, not a blank one
- What it doesn't
- Intent. A bot can say a change looks safe, not that it's the change you wanted
- Mechanism
- Merge queues (Graphite, GitHub)
- What it fixes
- Validates each change against the latest main so merges don't break the branch
- What it doesn't
- Judgment. Correct-looking code that does the wrong thing still merges green
| Mechanism | What it fixes | What it doesn't |
|---|---|---|
| Stacked diffs | Breaks one big change into small units a human can actually read | Total volume. Five small PRs review faster each, but they are still five reviews |
| Automated first pass (BugbotCursor's automated PR reviewer that posts inline findings and can push fix commits from isolated VMs. Press Enter for the full definition., Graphite's Diamond) | Triages likely bugs so humans start from a flagged diff, not a blank one | Intent. A bot can say a change looks safe, not that it's the change you wanted |
| Merge queues (Graphite, GitHub) | Validates each change against the latest main so merges don't break the branch | Judgment. Correct-looking code that does the wrong thing still merges green |
All three ship today on GitHub and GitLab. Origin's bet is that they work better built into the host.
They compose. Stacks shrink the unit of review, bots clear the mechanical findings, and the queue makes landing safe, which leaves human attention for the one thing none of the three can do: deciding whether the change matches the intent. That composition, not any single tool, is the current answer to the capacity problem.
What does Origin inherit from Graphite?
All three mechanisms have shipped for years at the company that now builds Origin. Cursor acquired Graphite in December 2025, and Graphite's products map onto the table above almost one to one: stacked pull requests are its signature workflow, its merge queue promises to keep your main branch green with CI optimizations that skip redundant runs, and Diamond is its AI reviewer. Tomas Reimers, a Graphite co-founder, gave the Origin demo at Compile.
That lineage is the strongest evidence about what Origin's review layer will look like, stronger than anything on the waitlist page. What remains unconfirmed is the integration: whether Origin bakes stacks, queue and AI review natively into the host, and what that changes versus running Graphite's tools against GitHub the way teams do today. The review guide tracks what coverage has reported there.
Graphite's stacked diffs, merge queue and Diamond reviewer are confirmed shipping products. The 22.6 commits-per-second figure and Origin's native review features come from coverage of a demo, not from Cursor documentation. The distinction is the whole game when you're deciding what to plan around.
What can't review tooling fix?
The honest ceiling: tooling changes what humans review, not whether they must. The skill shifts from reading every line to judging a stream of triaged changes and knowing which ten of the hundred need a careful human eye. That is a real skill, it is trainable, and it is still a finite budget of attention.
Three limits survive every tool in the table above.
- Bot approval is not accountability. When a change breaks production, the person who merged it owns it, and no first-pass reviewer changes that.
- Intent-checking can't be delegated. Only the person who asked for the change knows whether the diff does the right thing, as opposed to a passing thing.
- Volume pressure breeds rubber stamps. A queue of green-checked diffs invites approve-on-vibes, and the failure is invisible until something merged that nobody understood.
Today: a person, with bots doing triage and stacks keeping the units small. That answer is unglamorous and it is the true one. A platform that claims the review problem is solved is describing a policy choice about how much goes unreviewed, and you should read it that way.
Frequently asked questions
Did Cursor Origin really demo 22.6 commits per second?
The figure comes from a slide at Cursor's Compile demo, shared widely in coverage. It is a demo claim, not an independently verified benchmark, and Cursor has published no production numbers for Origin. Treat it as a statement of intended scale rather than a spec.
Can Bugbot replace human code review?
No. Bugbot reviews pull requests and flags likely bugs, which makes the human pass faster and better targeted. It cannot confirm a change matches what you actually wanted, and that intent check is the part of review that stays human.
Do stacked diffs reduce the total amount of review work?
They reduce the cost of each review, not the count. Splitting a 1,200-line change into five small PRs makes each one readable and catches problems earlier, but a reviewer still handles five changes. The win is quality and speed per review, which is where big PRs fail.
Who is accountable when agent-written code breaks production?
The human who approved and merged it. No current tool or platform transfers that responsibility to a bot, which is why teams running agents keep a person at the merge gate even when automated review handles the first pass.
Sources & last verified
- Hacker News — Origin launch thread
- Cursor — Origin (waitlist)
- Cursor — Bugbot
- Graphite — Merge queue
- GitHub Docs — Managing a merge queue
Cursor ships frequently. Facts verified against primary sources on July 16, 2026.