Review and ship with Cursor

Shipping Cursor-written code safely means stacking checks between the diff and production: a review before push, Bugbot on the pull request, deterministic CI gates, rule-based approval for low-risk changes only, and a monitored rollout. Cursor’s reviewers report findings; tests, CI-computed risk classes and a named owner decide what merges.

This hub is for developers and tech leads whose Cursor agents open more pull requests than the team can read. Tidy diffs hide loosened assertions, missing authorization checks and migrations without a backfill; these pages replace line-by-line reading with checkable gates.

How the Cursor facts in this section were checked

cursor.com was unreachable on 2026-09-26. On 2026-10-12 it was reachable again: Cursor’s skills page confirms /review-bugbot and /review-security as built-in skills, and Cursor’s changelog entry of 2026-09-23 confirms Rollouts and Security Review. Bugbot, Security Agents and PR Routing & Approval were confirmed on cursor.com on 2026-08-28. Agent Review is still described from an unofficial GitHub mirror of Cursor’s docs, read on 2026-09-26, so treat those details as provisional until cursor.com confirms them. Cursor’s Rollouts feature is documented on cursor.com (checked 2026-10-12); this page states nothing about how it behaves, and Rollouts and PR Routing & Approval covers what Cursor says about it.

Which Cursor ship page answers your question?

Your question	Page
Which Cursor reviewer runs where, and how do I triage a pull request?	Code review in Cursor
How do I tune Bugbot’s rules and Autofix?	Bugbot: learned rules and Autofix
How do I let Cursor approve low-risk pull requests safely?	Rollouts and PR Routing & Approval
How do I build a GitHub Actions pipeline, or run a read-only agent in CI?	CI/CD pipelines with Cursor
How do I write Terraform, Docker and Kubernetes configuration?	Infrastructure as code with Cursor

A review gate is only as strong as the tests behind it; write those first with testing and debugging with Cursor.

In what order should a Cursor change go out?

Run the cheap, private checks first.

1. Before push. Run tests, type check and lint, then one review pass on the branch: Agent Review against main, or /review-bugbot. Put your review checklist in .cursor/BUGBOT.md: Bugbot and Agent Review both read it (Cursor docs, unofficial GitHub mirror read 2026-09-26), and Bugbot ignores .cursor/rules/ (Cursor’s help, checked 2026-10-12).

2. On the pull request. Bugbot reviews the diff, and, on Teams and Enterprise plans, Security Agents run the checks you enable: a Security Reviewer for pull requests on Origin, GitHub and GitLab, and a Vulnerability Scanner that runs on a cron schedule (Cursor’s Security Agents docs, checked 2026-10-12). A Bugbot run that finds issues ends neutral by default, so requiring the check proves only that Bugbot ran. A pre-push /review-bugbot pass on the same diff makes Bugbot skip the pull request; on high-risk paths, skip /review-bugbot before pushing or change the diff. A bugbot run comment on the pull request may re-run the review, but Cursor’s documentation does not say it overrides the skip, so confirm the check actually ran.

3. In CI. Tests, types, lint and the evidence bundle check run on the head commit with workflow definitions taken from the base branch, and compute the risk class: low, standard or high. A custom Cursor reviewer in CI gets read-only tools and no write token.

4. At approval. PR Routing & Approval requests reviewers by ownership and may approve low pull requests that meet your criteria. A GitHub ruleset owns the merge; CODEOWNERS keeps migrations, auth, billing, public APIs, tests and CI configuration with a named human.

5. After merge. standard changes ship behind a flag or a canary; high changes get a staged rollout. Your CD system’s own gate must stop promotion when a signal is missing or inconclusive, with a revert path you have rehearsed. For Cursor’s Rollouts feature and the acceptance test any rollout monitor must pass, see Rollouts and PR Routing & Approval.

Copy-paste prompt: prove this branch is ready before you push

Review this branch cold; you did not write it. Do not edit any files.
1. Run `git diff main...HEAD --stat`, then our test, typecheck and lint commands
   from package.json. Report each command and its exit code; never claim a result
   you did not run.
2. List every change to an existing test or assertion as stricter, neutral or
   looser, quoting before and after for each looser one.
3. List every changed path under migrations, authentication, billing, public API
   routes, tests or .github/, so a code owner can review those first.
4. Apply .cursor/BUGBOT.md to the changed lines only; one line per finding with file:line.
End with one line: READY, or NOT READY and the reason.

Copy-paste prompt: write the rollout and rollback plan

Read the diff against main, .github/workflows/ and any migration in this branch.
Write docs/releases/rollout.md: deploy order, the flag or canary step, three
signals to watch for 30 minutes, the exact revert command, and whether a
migration makes rollback unsafe. Run no deploy or migration command.

How do you know a Cursor change is safe to ship without reading every line?

Each gate produces evidence with an owner. Open the diff only where the evidence points.

Evidence	What it proves	Owner
CI green on the head commit: tests, types, lint, evidence bundle	Existing behaviour holds; the change declares what it touched	CI, configured from the base branch
Risk label computed by CI, not by the agent	The agent can raise the class, never lower it	Owner of .github/ under CODEOWNERS
Code-owner approval on escalation paths	A person accepted the risk where a miss is expensive	Named code owner
Rollout monitor that passed an injected-failure test	Production confirms the change, or you can undo it quickly	On-call engineer

The triage is in reviewing an agent’s pull request without reading every line; the argument is in reading evidence instead of code. Measure the reviewers’ seeded-bug catch rate as the Bugbot page shows.

What breaks between Cursor’s review and a running deployment?

Symptom	Cause	Recovery
Bugbot ignores your review checklist	Bugbot does not read .cursor/rules/	Move it to .cursor/BUGBOT.md; point a short project rule at it
A pull request with a bug merges with Bugbot green	Findings end neutral and gate nothing	Treat Bugbot findings as one input to the standard risk class, not a merge gate; tests and the code owner decide. Where available, enable fail-on-unresolved findings
Cursor approves a pull request that touches billing	The risk class came from the agent’s description	Compute the class in CI from paths; the agent’s declaration may only raise it
A contributor’s pull request weakens its own review	The workflow or prompt loaded from the pull request branch	Load both from the base branch; see agent identity and secrets
A rollout monitor reports a change healthy that broke production	The signals it checked had no telemetry (an instrumentation gap)	Instrument those signals before merge; treat missing data as a failed check in CD
Rollback fails in production	A migration dropped data the old code needs	Split it with expand and contract; follow progressive delivery

Where to go next with shipping Cursor changes

Operate what shipped Monitoring, performance and security in production.

Shipping workflows for every agent Evidence bundle, pull request review and progressive delivery.

The same stage for other agents: review and ship with Claude Code and review and ship with Codex.