Short answer: Bugbot is a good reviewer with one assumption baked in: your team writes code in Cursor. If that's true, it's hard to beat on noise and the fix buttons are useful. If it isn't, you're paying per run for comments whose "Fix in Cursor" link half your engineers can't click. The alternatives below work from any editor. One of them isn't a reviewer at all, and it's the only one that can tell you whether the PR works once it's deployed.
Why people look past Bugbot
Three reasons come up, and they're worth separating because they point at different tools.
The editor. Bugbot's whole design, from the Fix in Cursor links to the Autofix that spawns Cursor cloud agents, assumes the person reading the comment is a Cursor user. Teams split between Cursor, VS Code, JetBrains and Claude Code in a terminal get a reviewer that's only half integrated.
The bill. Cursor announced in May 2026 that Bugbot was moving from a flat $40 a seat to usage pricing (existing customers switch at their next renewal after 8 June), and Cursor's own number is an average of $1.00 to $1.50 per run, varying with PR size and the effort level you pick. For a team pushing 100 PRs a week that's cheaper than most per-seat tools. For a team pushing 500, finance will ask questions, and there's no published per-effort rate card to answer them with.
The misses. Bugbot is quiet on purpose, which is the thing people like about it, and it still gets things wrong. One agency that ran it for a month counted around ten real bugs caught alongside false positives like parameters flagged as swapped that weren't. A Cursor forum request from February asks for a way to mark false positives so the team can tell real findings from noise. Cursor's own claim is that 80% of bugs identified are resolved by merge time, which is a vendor figure and also an admission that one in five isn't.
What Bugbot does, per Cursor's docs, is analyse PR diffs and leave comments with explanations and fix suggestions. There is no sentence in the documentation about running code, running tests or opening the application, and it's worth holding onto that fact as you read the alternatives, because it's true of them too.
Five alternatives that don't care which editor you use
GitHub Copilot code review is the closest thing to Bugbot's temperament outside Cursor. It's quiet, GitHub-native and already paid for on any paid Copilot plan. Reviews draw AI credits, about $0.05 to $1 each on Lite effort or $0.25 to $5 on Balanced. GitHub, with Azure DevOps in public preview, and it skips dependency manifests, lock files and SVGs. When our own team ran it on a monorepo it was a gentle assistant more than a reviewer, good at summaries and light on line-level findings.
Greptile if the misses are what bother you. It indexes the full repository so it can see a change in one file break a caller in another, and its TREX beta writes and runs targeted tests in a sandbox, which no other code reviewer on this page does during review. $30 per seat per month with 50 credits a month, and a free tier for one developer. Greptile's own benchmark puts Bugbot at 58% and itself at 82%; Greptile picked the 50 PRs, so read 58% as Greptile's number, not Cursor's.
CodeRabbit if you'd rather have too many comments than too few. $24 to $72 per developer per month annually, every major git host, 50-plus linters and security tools under the model, and an IDE fix link that isn't tied to one editor. It is the opposite of Bugbot on noise, by design: CodeRabbit would rather leave a comment you close than miss one.
Sourcery is the cheap per-seat option that still gates merges: $12 or $24 per developer per month annually, GitHub and GitLab including self-managed, skips draft PRs and dependency-bot PRs by default, and posts a Sourcery review status check that can gate merges.
Anthropic's Claude Code Review if you're already on a Claude Team or Enterprise plan and want the heaviest review you can get. It's in research preview, runs multiple agents over the diff and surrounding code, and averages $15 to $25 per review and about 20 minutes. The check it posts is always neutral, so it never blocks a merge. That price makes sense on a 2,000-line PR and not on a typo fix.
Four more worth a look: Qodo Merge (credit-priced, on-prem on Enterprise), Graphite (GitHub only, unlimited AI reviews on the $40-a-user Team plan), Macroscope (usage-priced, no public rates), and OpenAI's Codex review, included with ChatGPT plans.
Quick comparison
| Tool | Pricing (1 Oct 2026) | Needs a specific editor? | Runs anything in review? |
|---|---|---|---|
| Cursor Bugbot | ~$1.00–$1.50 per run | Fix links assume Cursor | No |
| Copilot code review | AI credits per review + Copilot seat | No (GitHub; Azure DevOps in preview) | No |
| Greptile | $30 per seat + credits; free for 1 dev | No | TREX beta: tests in a sandbox |
| CodeRabbit | $24–$72 per dev/month | No | Linters and scripts, not your app |
| Sourcery | $12–$24 per dev/month | No | No |
| Claude Code Review | ~$15–$25 per review | No (GitHub) | Verification step against code; test execution not documented |
| QA.tech PR testing | Metered on test executions; Growth and Enterprise | No | Yes: runs the deployed PR, mobile build or API |
The check no reviewer does
Every reason above for leaving Bugbot points at a different reader of the diff, and a reader is what the whole category is. Any of them can tell you a null check is missing; none can tell you that after this change the checkout button does nothing on mobile Safari, because nothing in the review ever loaded the page.
Vilhelm von Ehrenheim, QA.tech's co-founder and Chief AI Officer, frames it as two different judges on the same PR. The reviewer reads the diff. A verifier runs the product and interacts with it. The practical step he gave came first: a preview environment on every PR, because without one there's nothing for a second judge to run against.
There's old evidence that this matters. Microsoft Research reached the same conclusion from its own teams' review comments in 2015, in a paper titled Code Reviews Do Not Find Bugs, where only about 15% of comments pointed at a possible defect.
And the thing that pushed you to Bugbot in the first place, more PRs than reviewers, is the same thing that makes this gap expensive. Faros's AI Acceleration Whiplash research puts median PR review time at five times longer where AI adoption is high. A cloud-security team on a two-week cycle told us their front-end version number now jumps 30 to 50 times per test cycle, and nobody is testing most of those versions. A faster reviewer gets you through more diffs without checking whether any of those versions still work.
Pair Bugbot, or its replacement, with a verifier
QA.tech's dynamic PR testing is the other judge, and nothing about it depends on an editor. It reads the PR description, linked ticket, changed files and commits, works out which user flows the change can reach, runs the existing tests for those flows on the preview deployment, adds one to three new ones only where there's a gap, and posts a review with a verdict and a results table. If the run never reached your change it says unverified rather than green, so a quiet verdict means something. The QA.tech / PR Review check can be a required status in branch protection.
What the review looks like on the PR. This one is from a pull request on our demo CRM: the new health badge worked on the pipeline board and the deals list, and was missing on the deal's own detail page. A diff reviewer had no way to see that.
It posts to GitHub or GitLab, and starts from Bitbucket, Azure DevOps or any CI through the API. It runs the web app in Chromium with mobile-web presets, or a native iOS or Android build your CI uploads. The review carries no code quality opinions and no references to other bot comments, so it sits cleanly next to Bugbot's thread rather than arguing with it.
If your team is fully on Cursor and happy with Bugbot, there's nothing to swap, only something to add. If it's split, pick a reviewer above and add the same verifier; that's the gate that changes what gets caught.
Also in this series: CodeRabbit alternatives, Qodo alternatives, GitHub Copilot code review alternatives and Greptile alternatives.