Bugbot Custom PR Review Depth: Cursor Team's New Approach to AI Code Review

Bugbot Launches Custom PR Review Effort Feature

The Cursor team recently announced that their AI code review tool, Bugbot, has added a practical new feature — developers can now customize Bugbot's "thinking depth" during PR (Pull Request) reviews. This means teams can flexibly adjust the intensity of AI code review based on the importance of code changes, directing analytical resources where they matter most.

Pull Requests are a core collaboration mechanism in modern Git-based software development. When a developer completes a code modification, they submit a PR to the main codebase, requesting team members to review and merge the changes. Traditional code review relies entirely on manual effort — senior developers read through code diffs line by line, checking for logic errors, security vulnerabilities, code style issues, and more. This process is time-consuming and prone to oversights due to reviewer fatigue. AI code review tools emerged precisely to address this bottleneck — they perform an automated scan before human review, flagging potential risk areas so human reviewers can focus their energy on higher-level architectural and logic decisions.

Bugbot and the Cursor Ecosystem

Bugbot is an AI code review tool developed by the Cursor team, part of the same product ecosystem as the Cursor editor. Cursor itself is an AI-native code editor built as a deep modification of VS Code, integrating large language model capabilities with support for code completion, code generation, codebase Q&A, and more. Bugbot extends AI capabilities into the code review phase, typically operating as a GitHub integration — when a developer submits a PR, Bugbot automatically triggers a review process, analyzes the code changes, and provides feedback as comments on discovered issues. Together with the Cursor editor, it forms a complete AI-assisted loop from writing to reviewing code.

What Is Review Effort?

Review effort, or Bugbot's "thinking depth," determines how much computational resources and analytical energy the AI invests when reviewing code. Specifically:

• Higher review effort: Bugbot performs deeper, more comprehensive code analysis, uncovering more potential issues
• Default review effort: Strikes a balance between efficiency and quality, suitable for routine code changes

The logic behind this tiered review design is straightforward — not all code changes deserve the same level of attention. A minor UI copy tweak and a major core infrastructure refactor clearly require vastly different depths of review.

From a technical implementation perspective, the "thinking depth" behind AI code review tools involves the inference cost of large language models. Deeper analysis typically means: the model needs to process a larger context window (looking beyond the current diff to understand related files or even the entire codebase structure), perform multi-step reasoning (similar to Chain-of-Thought, progressively deducing potential issues), and potentially invoke models with more parameters. All of these significantly increase token consumption in API calls and response times. Using OpenAI's pricing as a reference, a single deep analysis might consume tens of thousands of tokens, costing several times more than a surface-level scan. Therefore, performing maximum-intensity reviews on every PR is economically impractical, which is exactly why tiered review mechanisms exist.

Cursor Team's Own Usage Strategy

The Cursor team has already adopted this feature in their daily development workflow and publicly shared their configuration strategy:

• High Effort: Specifically used for infrastructure and backend code changes. These types of code directly impact system stability and data security — any overlooked bug could trigger serious incidents, so they require Bugbot to perform deeper analysis.
• Default Effort: Covers all other routine PRs. This ensures baseline review quality while avoiding unnecessary resource consumption and wait times.

This dogfooding approach both validates the feature's usability and provides other development teams with a directly referenceable set of best practices. Dogfooding is a product validation culture in the tech industry where internal teams use their own products in daily work. This practice can be traced back to a Microsoft internal memo in 1988. Its value lies in enabling development teams to discover product defects and experience pain points from a real user's perspective, while also signaling confidence in their own product to the outside world. The Cursor team's public sharing of their specific configuration strategy is not only a classic dogfooding case but also an effective product communication approach — it transforms abstract feature descriptions into concrete, replicable best practice templates.

Practical Impact on Development Workflows

Precise Allocation of Review Resources

The computational cost of AI code review is significant, especially in deep analysis mode. Custom review effort allows teams to concentrate limited resources on the most critical code changes rather than scanning every PR at the same intensity, thereby improving overall ROI.

Adapting to Different Teams and Project Needs

Code review requirements vary enormously across teams. A fintech company's payment module and an internal tool's frontend pages have completely different needs for review rigor. Adjustable review effort enables Bugbot to cover more diverse use cases instead of forcing all teams to accept a single standard.

The Evolution of AI-Assisted Code Review

This feature also reflects an important trend in AI code review tools: moving from one-size-fits-all automation toward finer-grained controllability. Developers are no longer passively accepting AI review results — they can proactively set the AI's focus areas and analysis depth. This human-AI collaboration model often fits real-world development scenarios better than fully automated approaches.

It's worth noting that the AI code review space where Bugbot operates is increasingly competitive. Major competitors include: CodeRabbit (an AI review service supporting multiple code hosting platforms), GitHub's own Copilot Code Review (deeply integrated within the GitHub ecosystem), Sourcery (an AI review tool focused on the Python ecosystem), and Qodo (formerly CodiumAI, offering AI test generation and code review). These tools differentiate along various dimensions — some emphasize deep integration with specific platforms, others focus on optimization for particular programming languages, and still others invest in customizability. Bugbot's new review effort customization feature establishes a differentiation advantage precisely along the controllability and fine-grained configuration dimension, giving development teams more flexible options.

Conclusion

Bugbot's custom review effort feature may seem like a minor update, but it sends a clear signal: mature AI development tools should adapt to a team's workflow, not the other way around. As AI code review gradually becomes mainstream in software development, this kind of fine-grained control will become one of the key metrics for evaluating tool quality. If your team is currently using or planning to adopt an AI code review tool, this Bugbot feature is well worth a serious evaluation.

Key Takeaways

• Bugbot adds custom PR review effort, allowing users to control the depth of AI analysis
• Cursor team's own practice: high effort for infrastructure and backend code, default effort for other PRs
• The feature helps optimize AI review resource allocation, concentrating deep analysis on critical code changes
• Reflects the evolution of AI code review tools from one-size-fits-all automation toward fine-grained controllability
• Bugbot builds differentiation through customizability in the increasingly competitive AI code review space