How do Cursor Bugbot rules work?

Short answer

Bugbot does not read your .cursor/rules files. It reviews with its own rules: .cursor/BUGBOT.md in the root plus nested BUGBOT.md files near changed code, team rules set by admins for all repositories, rules it learns from merged and closed pull requests, and manual rules with optional path scopes. They are merged in that order into one review-rules block.

Bugbot has its own rules

The first thing to know: the .mdc files in .cursor/rules/ that steer Agent do not apply to Bugbot runs. Cursor’s help says the same from the other side: rules only apply to Agent (Chat), not to Bugbot pull request reviews. If you wrote “never use eval()” as a Cursor rule and expected Bugbot to flag it in review, it will not, unless Bugbot finds the problem on its own.

Bugbot reads four sources instead:

Source Where Who manages it Scope
Team rules Bugbot Automations in the dashboard Team admins Every enabled repository of the team
Project rules .cursor/BUGBOT.md, plus nested BUGBOT.md files Anyone who can commit One repository, or one folder of it
Learned rules Generated from your GitHub activity Bugbot itself One repository
Manual rules Bugbot repository rules Admins One repository, optionally limited to paths

When several apply, Bugbot merges them into one review-rules block in this order: team rules, project BUGBOT.md files, learned rules, manual rules.

BUGBOT.md files

Bugbot always includes the root .cursor/BUGBOT.md. It also walks upward from each changed file and picks up any other BUGBOT.md it finds on the way. So backend/.cursor/BUGBOT.md only joins the review when backend files change. That lets each part of a monorepo carry its own review checklist.

A useful BUGBOT.md reads like a reviewer’s checklist. Cursor’s docs give examples such as:

  1. Flag any use of eval() or exec() as a blocking bug, assign it to the author, and label it “security”.
  2. When dependency files change, block licenses the company does not allow, such as GPL-2.0, GPL-3.0 or AGPL-3.0.
  3. Flag componentWillMount in React code and suggest moving to useEffect.
  4. Require tests when backend code changes without test changes.
  5. Flag TODO and FIXME comments as non-blocking.

Each rule says what to look for and what to do about it: block, comment, label. That is the difference with an Agent rule, which tells the AI how to write code. A Bugbot rule tells it what to reject.

Learned rules

Bugbot can also learn. Learned rules are generated from your team’s GitHub activity on a repository: Bugbot learns from a pull request when it is merged or closed. It posts nothing on the pull request while doing this, and each learning run counts toward usage like a review. You can also backfill from the repository’s history.

Two things to know:

  • You can teach it directly: comment @cursor remember followed by a fact on any pull request, and it becomes a learned rule.
  • Admins can turn off Automatically Learn Rules for the organization. Where that switch exists, turning it off also stops manual rules from applying. Learning does not run on repositories set to manual-only reviews.

Cursor turns learned rules on or off over time as it learns more, and rule analytics show per rule how many issues it found and how many were accepted.

Limits and checking what was used

Each rule is cut off at 30,000 characters, every linked .md or .mdc file counts as its own rule, and all rules together are capped at 100,000 characters. When the cap is hit, required team rules go first. To see what a review actually used, comment cursor review verbose=true or bugbot run verbose=true on the pull request. Bugbot then posts a table that marks truncated and omitted rules.

The common mistake: one rule file for everything

Teams that set up Cursor rules carefully often assume code review follows the same rules. It does not, so the agreements end up in two places that drift apart: .cursor/rules/ for writing, BUGBOT.md for reviewing. A practical split is to keep how to write code in the Agent rules and AGENTS.md, and keep what must never pass review in BUGBOT.md and team rules. Rules can link to .md or .mdc files, and each linked file counts as its own rule against the limits above. Note that Cursor’s rules docs also warn that AI guidance should not be your only security control.

What this means for a team

Bugbot is the one place in Cursor where rules grow from the team’s own behavior: every merged or closed pull request can add to them, and @cursor remember turns a review comment into a lasting rule. But that knowledge stays inside Bugbot, per repository. Agent in the editor does not read it, and neither do other AI tools. For the editor side, see Cursor rules best practices and How do you share context and team rules in Cursor.

Where Bombos fits

Bugbot learns from your pull requests, but what it learns stays in code review for one repository. Bombos is a plugin that gives every AI tool your team uses, Cursor, Claude Code, Copilot, Codex and your own agents, one shared memory, including rules learned from corrections, so a lesson from review can also reach the agent that writes the next change. It is traceable, and runs in the cloud or on your own server. One developer can try it first for their own agents.

Related questions

Why does Bugbot ignore my Cursor rules?

Because project rules in .cursor/rules/ do not apply to Bugbot runs, by design. Put review instructions in .cursor/BUGBOT.md, or in team or repository rules for Bugbot.

How do I teach Bugbot something from a pull request?

Comment @cursor remember followed by the fact on any pull request. Bugbot saves it as a learned rule.

How can I see which rules a review used?

Comment cursor review verbose=true or bugbot run verbose=true. Bugbot posts a table that also flags rules that were truncated or left out.

Is there a size limit?

Each rule is cut off at 30,000 characters and all rules together are capped at 100,000. Required team rules take priority over optional ones when the cap is reached.

Sources

  1. Cursor docs: Bugbot
  2. Cursor help: Rules
  3. Cursor docs: Rules
The first half hour · free

What does your AI forget?

  1. 01You tell us which AI you use and where it keeps starting over.
  2. 02We show what a shared memory changes there, on your own examples.
  3. 03You keep the plan, with or without Bombos.
Piet Baudoin
Piet BaudoinYou talk to Piet, from the Bombos teamDutch team from Utrecht and Nijmegen · data in Europe
We reply the same working day.