I Left a Test Out on Purpose. Cursor Bugbot Found It in 26 Seconds.

Cursor Bugbot is a second reviewer that never saw the conversation that wrote the change, and a newcomer can watch it catch a deliberately missing test in under half a minute, as long as they know that a neutral check is a finding, not a pass, and that Bugbot reads only its own rule file.

Rick Hightower

Cover image for “I Left a Test Out on Purpose. Cursor Bugbot Found It in 26 Seconds.” by Rick Hightower

Day 16 of Cursor, Day-to-Day: give Bugbot one rule, open a pull request that breaks it, read the finding the right way, fix it with the agent, and merge with thirteen passing tests.

You know a pull request should carry a test for every new keyword, and you know that on a busy afternoon you will forget one. You want a reviewer that catches it before a teammate has to, without paying for reviews you did not need.

In this article: Day 16 of an 18-day guide. Start here merges yesterday's Cloud Agent pull request after a local /review-bugbot review, adds a one-line .cursor/BUGBOT.md rule, turns Bugbot on, and opens a pull request that leaves out a test on purpose so Bugbot can catch it. Going deeper covers when Bugbot runs, why a neutral check never blocks a merge, how /review-bugbot and the GitHub review share a diff, the rule and settings files, and what each review costs.

Tested on Cursor CLI 2026.11.13-eacade1 and Bugbot on GitHub, November 17, 2026, on a legacy Ultra plan with usage-based billing turned on for Bugbot. Editor steps: written from the docs, not yet run.

Every team has a rule that lives in someone's head: a new keyword gets a test named after it. The rule holds until a busy afternoon, when one small change goes up without its test and nobody notices until the next bug. A reviewer who never saw the conversation that wrote the change is the cheapest way to catch that, and Cursor ships one for pull requests.

Yesterday a Cloud Agent added squashed on its own branch, and you opened a pull request from that branch. Today you merge it, give Bugbot one rule, and then break that rule on purpose to watch it work.

Start here

At the end of today, yesterday's pull request is merged, Bugbot has reviewed a second pull request and found a missing test, you fixed it, and main has thirteen passing tests.

Starting fresh or fell behind? Run git switch -C main cursor/day-15. This replaces your main with the end of Day 15; to keep your own work, run git branch my-backup first.

Today's path: check the start state, run /review-bugbot locally on yesterday's branch, add a BUGBOT.md rule, merge, turn Bugbot on in the dashboard, open the add-bent pull request without a test, read Bugbot's finding, add the test with cursor-agent, and merge with 13 passing tests

The path runs mostly on your machine. Only two steps happen in Cursor's cloud: turning Bugbot on, and the review itself.

Check your starting state

Start where Day 15 ended. Run these checks in ~/code/ticket-triage.

cd ~/code/ticket-triage
git status --short
git log --oneline -1
npm test
gh pr list

git status --short prints nothing, the last commit on main is Add smashed to the damaged keywords, npm test shows ℹ pass 11, and gh pr list shows the open squashed pull request. If not, finish Day 15 first.

gh pr list lists the open pull requests in this repository. The first column is the pull request's number, and the branch column shows the agent's branch. This article writes them as <number> and <branch>.

What Bugbot is

Bugbot is Cursor's reviewer for pull requests. It reads the changes in a pull request, posts comments on likely bugs, and reports a check on GitHub named Cursor Bugbot (Bugbot). It runs on Cursor's machines, not on your computer.

Bugbot reads its own rule file, .cursor/BUGBOT.md. Cursor's project rules in .cursor/rules/ "do not apply to Bugbot runs" (Bugbot). A review rule you want Bugbot to follow goes in BUGBOT.md.

Check your plan. Bugbot needs Premium or higher (Models & Pricing); this guide could not test a Premium plan. Each review uses your plan's usage. Going deeper explains the cost.

Review yesterday's branch on your machine

Yesterday's pull request has no Bugbot check, because Bugbot is not on for your repository yet. You turn it on after this merge, so you pay only for the review you learn from. If gh pr checks <number> already shows a Cursor Bugbot line, Bugbot is on already: read its comments as described below before you merge.

Review the branch on your machine with the built-in /review-bugbot skill (Agent Skills). It runs the same reviewer with your normal agent usage.

git switch <branch>
cursor-agent
/review-bugbot Review the changes on this branch compared with origin/main.

The sentence after /review-bugbot names the branch to compare with, main on GitHub. Going deeper explains why this guide always names it.

Allowlist: in testing, the agent showed a Bugbot card and reported "Bugbot found no bugs." with no approval prompts. Auto-review: in testing, the agent printed "I'll launch Bugbot to review this branch against main.", showed the same card and result, and asked for no approval.

Type /quit.

Give Bugbot one rule

Add a rule file on the same branch, so it reaches main with this merge:

cat > .cursor/BUGBOT.md <<'EOF'
- Every new keyword in src/classify.js has a test in test/classify.test.js named after the keyword.
EOF
git add .cursor/BUGBOT.md
git commit -m "Add a Bugbot rule for keyword tests"
git push

The rule repeats line 3 of your AGENTS.md, because Bugbot does not read your other rule files.

Merge yesterday's pull request

gh pr merge <number> --merge
git switch main
git pull
npm test

gh pr merge --merge merges the pull request with a merge commit, and git pull brings that commit to your main. npm test shows ℹ pass 12. If Bugbot left comments on this pull request, answer them first, as described below.

Turn Bugbot on for the repository

Bugbot reviews a repository only when its switch for that repository is on. The docs say that connecting GitHub turns it on (Bugbot). In this guide's test it was off after Day 15. A bugbot run comment, which asks Bugbot to review a pull request, got this reply:

Skipping Bugbot: Bugbot is disabled for this repository. Visit the Bugbot dashboard to update your settings.

Turn it on:

  1. Open the Bugbot dashboard.
  2. If the dashboard asks you to turn on usage-based billing for Bugbot, turn it on. Each review then costs about $1.00 to $1.50; Going deeper explains the cost.
  3. Find your repository and turn its switch on.

The account owner did these clicks for this guide, on a legacy Ultra plan that needed usage-based billing. This guide did not record the dashboard screens. After the switch was on, Bugbot reviewed the next pull request within seconds.

Open a pull request that Bugbot can review

The next ticket says a customer's frame "arrived bent". Make the change by hand, on a new branch, and leave out the test on purpose. This is the mistake your rule is for.

git switch -c add-bent

git switch -c creates a branch and switches to it. Open src/classify.js in any editor. On the damaged line, add || t.includes("bent") after t.includes("squashed"). The end of the line becomes:

|| t.includes("smashed") || t.includes("squashed") || t.includes("bent")) return "damaged"

Then test, commit, push the branch, and open the pull request:

npm test
git commit -am "Add bent to the damaged keywords"
git push -u origin add-bent
gh pr create --fill

git commit -am commits every changed file that git already tracks. git push -u origin add-bent creates the branch on GitHub. gh pr create --fill opens a pull request into main and takes its title from the commit. npm test still shows ℹ pass 12, because nothing tests bent yet, and gh pr create prints the pull request's link. The number at the end of the link is the new <number>.

Read Bugbot's review

Watch the checks:

gh pr checks <number>

In testing, Bugbot started 8 seconds after gh pr create and finished 26 seconds after it. If the list is empty, wait a minute and run it again. The expected result:

Cursor Bugbot	skipping	18s	https://cursor.com/docs/bugbot

Sequence: gh pr create opens the pull request on GitHub, Bugbot starts after 8 seconds in testing, reads the diff and BUGBOT.md, posts a line comment on src/classify.js line 6, and ends its check neutral at 26 seconds; gh pr checks prints skipping, and gh api returns the comment Missing test for bent keyword

The word skipping is the trap on this screen. It does not mean that Bugbot skipped the review. Bugbot ends its check neutral when it finds something (Bugbot), and gh prints a neutral check as skipping. Bugbot's finding is a comment on a line of code. gh pr view --comments does not show line comments, so print them with the GitHub API:

gh api 'repos/{owner}/{repo}/pulls/<number>/comments' --jq '.[] | "\(.path):\(.line) \(.body | split("\n")[0])"'

gh api calls the GitHub API, and gh fills in {owner} and {repo} from your repository. The --jq filter prints the file, the line, and the first line of each comment. The expected result:

src/classify.js:6 ### Missing test for bent keyword

Infographic: a neutral Bugbot check is a finding, not a pass; gh prints it as skipping, the finding lives in a line comment that gh api prints, and a neutral check never blocks a merge

A neutral check means Bugbot found something, gh labels it skipping, the finding itself sits in a line comment that only the API call prints, and nothing about the check stops a merge, so you are the gate.

Open the pull request on GitHub to read the whole comment. In testing it said "Medium Severity", said that bent "is the only one without coverage", and ended "Triggered by project rule:" followed by your BUGBOT.md line. The comment describes the problem but does not include a fix. Its Fix in Cursor and Fix in Web buttons start an agent; this guide did not click them. If Bugbot finds nothing, your rule did not trigger; add the test yourself in the next step anyway.

Scene: a developer at a desk, eyebrows raised, reading a Bugbot review comment about the test they left out on purpose

The scene is the moment the day turns: a reviewer with no memory of how the change was made pointed at exactly the line you left untested.

Fix the finding

For each finding, you either fix it or reply on GitHub with the reason you think it is wrong. This one is right. Start a session on the same branch:

cursor-agent

Paste the finding into your message:

Fix this Bugbot finding on the current branch: Missing test for bent keyword. The new bent keyword was added in src/classify.js without a corresponding test named after the keyword in test/classify.test.js. Then run npm test.

Allowlist: in testing, no approval prompts. The agent read both files, added a test named bent with "The frame arrived bent", ran npm test, and reported "All 13 tests pass." Auto-review: in testing, the same result with no prompts: one new test named bent, and 13 passing tests.

Type /quit, then check and push the fix yourself:

npm test
git add -A
git commit -m "Fix the Bugbot finding"
git push

npm test shows ℹ pass 13 and ℹ fail 0 before you commit.

Bugbot may review the fix as well. In this guide's test it did not; Going deeper shows the reply it gave. If a new finding appears, fix it the same way.

Tell reviewers what you did, in a comment on the pull request:

gh pr comment <number> --body "Fixed the Bugbot finding: added the bent test."

gh pr comment posts a comment on the pull request.

Merge

gh pr merge <number> --merge
git switch main
git pull
npm test

npm test shows ℹ pass 13 and ℹ fail 0.

The same steps in the editor

Every step here is written from the docs, not yet run.

  1. (written from the docs, not yet run) On a pull request's branch, type /review-bugbot in the Agent panel and read the review.
  2. (written from the docs, not yet run) Open the pull request on GitHub and wait for the Cursor Bugbot check.
  3. (written from the docs, not yet run) Fix or answer each finding, merge on GitHub, then pull main and run npm test.

Your win

Run the check now.

gh pr view <number> --json state --jq .state
gh api 'repos/{owner}/{repo}/pulls/<number>/reviews' --jq '.[].user.login'
git log --oneline -1
npm test

--jq .state prints only the pull request's state, and the second command prints who reviewed it. The expected result: MERGED, then cursor[bot], which is Bugbot, then a merge commit named Merge pull request #<number> from <your account>/add-bent, and ℹ pass 13.

gh pr checks <number> now prints no checks reported, because gh shows the checks for the newest commit only, and Bugbot's check is on the first one.

You can stop here. Going deeper explains why this works and where it breaks.

Going deeper

This section is for readers who want to control when Bugbot runs, how its checks affect merging, and what it costs. It assumes you finished Start here in Parts 1 to 16. Results from this guide's test say "in testing"; the rest comes from the docs.

When Bugbot runs

With Bugbot on for a repository, it reviews new pull requests and, by default, each push. Personal settings can limit it to runs when someone comments cursor review or bugbot run, or to one run per pull request (Bugbot). On an individual plan, Bugbot runs only on pull requests you author, which is why Day 15 had you open the pull request yourself.

In testing, the first review ran on its own. After the fix, no check came for the new commit in 8 minutes, and a bugbot run comment got the reply "Skipping Bugbot: your auto mode classified this PR to skip." The account's Bugbot effort level was Smart. In this test, Smart effort routing skipped the follow-up review; this is an observed result. The docs say that Smart picks Low, Default, or High effort from your instructions and the pull request, and they do not mention skipping a review (Bugbot).

By default, Bugbot reviews only the changes since its last review; turn off Incremental Review to review the whole diff each time (Bugbot).

Decision flow for one pull request event: with the repository switch off, Bugbot replies that it is disabled; on an individual plan it reviews only your own pull requests; a diff already reviewed by /review-bugbot is skipped with a comment; Smart effort routing skipped a follow-up in testing; otherwise a review runs at about $1.00 to $1.50

The flow gathers every reason this guide saw or read for a review not to run. Four of the five exits are skips, and each one leaves a different trace: a "disabled" reply, no review at all, a comment about a matching diff, or the Smart routing reply.

/review-bugbot and the review on GitHub

/review-bugbot stores an ID for the diff it reviewed. When Bugbot on GitHub sees a diff with the same ID, it skips the review and leaves a comment that says so (Bugbot). Today you ran the local review on yesterday's branch, not on add-bent, so the review on GitHub ran.

/review-bugbot compares your branch with the repository's default branch. This guide's tests ran in a shared repository whose default branch has no history in common with the test branch, so the first try reported "Bugbot could not complete the review. Blocker: it could not compute the branch changes diff in this repository." Naming the base branch in the message fixed it. Your repository's main holds your whole history, so plain /review-bugbot should work there too. This guide did not test that, so Start here names the branch.

Checks do not block merges by default

Bugbot's check reports neutral when it finds issues. A required check that ends neutral still lets the pull request merge, so requiring the Cursor Bugbot check makes sure Bugbot ran, not that its findings were fixed (Bugbot). Answer the comments yourself before you merge.

When Bugbot finds an issue its check ends neutral, which gh prints as skipping; whether or not the check is required, the pull request can still merge, so you answer every comment before you merge

A required check proves only that the review happened. The decision to merge stays with the person who reads the comments.

Rules and settings

  • .cursor/BUGBOT.md at the root always applies; a BUGBOT.md in a subfolder's .cursor/ applies to changes under that folder (Bugbot). In testing, the finding named the root rule that triggered it.
  • Bugbot can learn rules from your pull requests, and @cursor remember <fact> in a comment adds one (Bugbot).
  • bugbot run verbose=true posts a table of the rules a review used (Bugbot). In testing, Smart effort routing skipped that comment's review, so this guide never saw that table.
  • .cursor/config/bugbot.yaml holds repository settings. Bugbot reads it from the branch the pull request merges into, so a pull request cannot change how Bugbot reviews itself (Bugbot).
  • Effort levels, Low, Default, High, and Smart, trade cost against how much Bugbot looks for (Bugbot). In testing, the review said it used "default effort".

What Bugbot reads: the root .cursor/BUGBOT.md always, a subfolder BUGBOT.md for changes under that folder, and .cursor/config/bugbot.yaml from the base branch; it does not read .cursor/rules/, AGENTS.md, or CLAUDE.md

The split matters for anyone with rules already written. Everything your local agent obeys stays local, and Bugbot sees only the files on the right-hand path.

Infographic: Bugbot reads one rule file; .cursor/BUGBOT.md applies, subfolder BUGBOT.md files apply to their folders, bugbot.yaml comes from the base branch, and project rules, AGENTS.md, and CLAUDE.md never reach it

Remember one rule from this section: if a review rule matters, copy it into .cursor/BUGBOT.md, because no other rule file in the repository reaches Bugbot.

What it costs

Bugbot is usage-based on individual plans: it bills your included usage first, then on-demand usage if you turned it on (Bugbot usage-based billing). The docs give an average cost of $1.00 to $1.50 per review, depending on the size and complexity of the pull request. Each review that runs costs one review, whether a push or a bugbot run comment starts it. Today's path ran one review in testing.

Why a second reviewer helps

On Day 12 you wrote a reviewer that starts with an empty context, because an agent that wrote a change tends to trust it. Bugbot is the same idea on GitHub: it reviews the pull request without the conversation that produced it. Today it caught a rule that you broke on purpose; on a real day, it catches the one you forgot.

If you already use Claude Code: your CLAUDE.md and AGENTS.md instructions do not reach Bugbot; it reads .cursor/BUGBOT.md. Put the review rules you care about there as well.

Do this today

Everyone

  1. Repeat the win. Run the check again on main:

    gh pr view <number> --json state --jq .state
    gh api 'repos/{owner}/{repo}/pulls/<number>/reviews' --jq '.[].user.login'
    npm test
    

    The expected result: MERGED, cursor[bot], and ℹ pass 13.

  2. Start one habit: run /review-bugbot before you open a pull request. On your branch, in a cursor-agent session, type:

    /review-bugbot Review the changes on this branch compared with origin/main.
    

    The result: /review-bugbot reports no findings on your branch before you run gh pr create. The docs say that Bugbot on GitHub then recognizes the same diff and skips it, so it does not review the same changes twice. This guide did not test that.

If you read Going deeper

Each check only reads. None of them starts a Bugbot review, so none of them uses your plan's usage.

  1. Check for a repository config file.

    git ls-files .cursor/config
    

    The expected result: no output, because Ticket Triage has no .cursor/config/bugbot.yaml. Bugbot uses your dashboard and personal settings instead. Reset: the step only reads, so git status --short prints nothing.

  2. Check that your rule reached main.

    git show main:.cursor/BUGBOT.md
    

    The expected result: your one rule line about keyword tests. Bugbot reads .cursor/BUGBOT.md at the root for every future pull request. Reset: the step only reads, so git status --short prints nothing.

  3. Look at your Bugbot settings (not yet run). Open the Bugbot dashboard and find Incremental Review, Run only when mentioned, and Effort Levels. Do not change them. The expected result, from the docs: incremental review is on, because it is the default. Reset: you changed nothing, so git status --short prints nothing and npm test shows ℹ pass 13.

A reviewer that never saw the conversation

The test you left out today was deliberate, and Bugbot still had to find it the hard way: by reading a diff with no idea how it was written. The distance is the whole value. The agent that wrote a change trusts it, and a reviewer that starts cold does not.

Two habits keep the reviewer honest. Put every review rule you care about in .cursor/BUGBOT.md, because nothing else in the repository reaches it, and read a neutral check as a finding, because nothing about it stops a merge. The gate is still you.

Bugbot will not remember your rule for you. It will only notice, every time, when you forget it.


This is Part 16 of "Cursor, Day-to-Day," an 18-part guide to using Cursor's agent every day, from the CLI and the editor.