Cursor Bugbot Gets 3× Faster + Pre-Push Review — Catch Bugs Before They Hit CI
TL;DR
Cursor shipped the biggest Bugbot upgrade since launch on June 10, 2026 — the automated code-review agent is now 3× faster, with 90% of runs finishing under 3 minutes, 22% cheaper per review, and finds 10% more bugs per pass. A new pre-push review command lets developers run Cursor's full review locally before pushing, shifting defect detection earlier in the workflow. Gains are powered by harness improvements and the Composer 2.5 model that now underpins Bugbot.
3× faster
90% of Bugbot runs now finish in under 3 minutes (down from ~5 min)
22% cheaper
Cost reduction per Bugbot review run — direct savings at any review volume
10% more bugs
More bugs found per review pass — quality rose alongside speed
Cursor 3.7+
Required version — pre-push review and incremental review available now
Cursor's June 10 Bugbot update delivers three concrete metric improvements alongside two new workflow features that shift where in the development cycle code review happens. The update is available in Cursor 3.7+ and at cursor.com/agents.
The three headline metrics. Bugbot is now 3× faster overall — 90% of runs now complete in under 3 minutes, down from roughly 5 minutes previously. Each run is 22% cheaper per review, a direct reduction to automated-review cost at any scale. And Bugbot now finds 10% more bugs per review pass, meaning the quality bar rose alongside the speed and cost improvements. Cursor attributes all three gains to harness engineering improvements combined with the Composer 2.5 model that now powers Bugbot — the same model that positions Cursor against GitHub Copilot as a vertically integrated coding environment.
Pre-push review: the workflow shift. The most substantive new feature is pre-push review. Developers can now run the /review command (or the aliases /review-bugbot and /review-security) locally inside Cursor before pushing — Bugbot analyses the diff and surfaces bugs, security issues, and code-quality problems before the branch ever reaches CI. This is a meaningful shift: historically, Bugbot was a post-push, PR-triggered tool. Pre-push review moves the detection point earlier, where fixes are cheaper and faster — no CI queue, no PR comment loop, no waiting for a teammate to triage. Bugbot syncs with GitHub and GitLab to skip re-analysing already-reviewed diffs, so running /review locally before push doesn't produce duplicate comments when the PR opens.
Incremental review. The second new feature is incremental review — Bugbot can now review only the delta since its last review pass rather than re-analysing the full PR on every push. For long-lived PRs that accumulate many commits, this cuts review time and cost substantially. The combination of incremental review and the baseline 3× speed gain means that even large, iterative PRs now get near-real-time feedback on each new commit.
Composer 2.5 as the engine. Cursor explicitly links the quality and speed improvements to Composer 2.5, its in-house frontier coding model trained on Cursor's own post-training pipeline. The implication is that Bugbot's review quality will continue to improve as the underlying model is updated — unlike tools that rely on a fixed third-party model API. For teams comparing options, Cursor vs Claude Code covers where the GUI-first and terminal-native approaches differ on agentic review workflows.
CI economics and team impact. Sub-3-minute Bugbot runs change the economics of automated code review. At 5 minutes, Bugbot was async — you pushed, Bugbot ran, you checked results later. At under 3 minutes, and with pre-push running locally, Bugbot is close enough to real-time that it fits inside a normal commit-review loop. The 22% cost reduction compounds at scale: a team running Bugbot on 100 PRs a month saves meaningfully across the year, and those savings justify expanding review coverage to branches that previously weren't worth the cost. Engineering teams that have been deferring Bugbot adoption on cost or latency grounds now have fewer reasons to wait.
Why It Matters
Sub-3-minute Bugbot runs move automated code review from async to near-real-time CI feedback. At the previous ~5-minute runtime, Bugbot sat outside the commit loop — developers pushed, waited, then checked. At under 3 minutes, and with pre-push `/review` running locally before the push, Bugbot fits inside the active development cycle. The 22% cost reduction improves automated-review economics at scale — teams running high PR volumes see compounding savings, and the lower per-run cost makes it viable to expand coverage to branches previously excluded on cost grounds. Pre-push detection is the bigger structural shift: bugs caught before push are cheaper and faster to fix than bugs caught in PR comments or CI failures. The Composer 2.5 underpinning also signals that Bugbot quality will improve with the model, not stay fixed — a meaningful durability advantage over tools that route review to a static third-party API.
Who's Affected
- — Engineering teams using Cursor for CI review — the 3× speed improvement and incremental review directly reduce CI cycle time. Teams running high PR volumes should recalculate Bugbot costs under the new 22% reduction and consider expanding coverage.
- — Cost-conscious teams evaluating automated review — at 22% cheaper per run and sub-3-minute runtimes, the prior objections (cost and latency) are both weaker. Worth re-running the build-vs-buy comparison now.
- — Solo developers wanting pre-push checks — `/review` runs locally before push, catching issues before CI. No PR queue, no waiting for a teammate review — Bugbot surfaces problems at the moment they're cheapest to fix.
- — Teams comparing Cursor vs GitHub Copilot for PR review — Bugbot's pre-push capability and incremental review have no direct equivalent in Copilot's current PR review tooling. This is a concrete workflow differentiator, not a benchmark claim.
What To Do Now
- 1. Enable pre-push review this week. Run `/review` or `/review-bugbot` before your next push and compare what Bugbot surfaces versus what makes it to CI. The GitHub/GitLab sync means no duplicate comments — there's no downside to turning it on.
- 2. Recalculate your Bugbot cost baseline. If you've been running Bugbot at volume, the 22% reduction is real money. Update your cost model and decide whether the savings justify expanding review to additional branches or repos that were previously excluded.
- 3. Use incremental review on long-lived PRs. For PRs with many commits — large features, migrations, refactors — incremental review cuts both runtime and cost to near-zero for subsequent pushes after the first full pass. Configure it for your highest-churn branches first.
- 4. Track Bugbot quality over time. The 10% more bugs claim is Cursor's reported figure. Measure it against your actual codebase — log bugs Bugbot caught before push versus bugs that reached PR or CI. That data justifies or challenges expanding automated review coverage.
More on this topic — Best AI Coding Tools
Independent Review
Cursor
Pricing, pros and cons, real-world verdict — no affiliate spin.
Read the Cursor reviewMore from ToolNav News