Skip to main content
Back

GitHub Copilot's Smarter Code Review Cuts Costs 20% While Catching Subtle Bugs

GitHub Copilot code review now routes complex PRs to a higher-reasoning model, giving teams a configurable depth dial for security-sensitive and cross-service changes.

  • Medium-depth review in public preview: GitHub Copilot code review now routes PRs to a higher-reasoning model at the Medium effort level.
  • Targeted use cases: Medium is designed for security-sensitive code, cross-service changes, and repos with strict quality standards; Low remains the fast default.
  • Org-level controls: Admins can set a default review effort level across all unconfigured repositories, with per-repo overrides still available.
  • 20% cost reduction: GitHub reports a ~20% drop in Copilot code review costs from switching to native Copilot CLI/SDK file exploration tools.
  • Available now: Public preview for all paid Copilot plans (Pro, Pro+, Business, Enterprise); enable via repo Settings → Copilot → Code review.
  • Higher cost for Medium: Medium reviews consume more AI credits and GitHub Actions minutes; larger or self-hosted runners are recommended for best performance. Docs

GitHub Copilot code review just got a meaningful upgrade: a Medium effort level is now in public preview, letting teams route pull requests to a more capable reasoning model when the stakes are high. It is a small setting change with a real impact on review quality for complex code.

One dial, two very different reviewers

Copilot code review now supports multiple review effort levels so you can match thoroughness to the criticality of your code. Low is the standard default, offering fast, targeted feedback on common issues like bugs, security vulnerabilities, and style inconsistencies. Medium routes pull requests to a higher-reasoning model for longer analysis of complex logic, security-sensitive code, and cross-service changes.

Think of it as a thinking budget. Lower levels give fast, shallow responses, while higher levels allow deeper analysis and more structured thinking. At higher settings, the model plans, evaluates, and reasons before responding rather than pattern-matching against common issues.

The practical difference matters most at the edges of what a quick scan can catch:

  • Medium delivers more actionable comments with fewer false positives and catches subtle bugs that lighter reviews miss.
  • Use Medium for security-sensitive code, multi-service pull requests, or repositories with strict quality standards.
  • Use Low for routine changes where fast feedback is more important than exhaustive analysis.

How to turn it on

These features are available in public preview for existing Copilot Pro, Pro+, Business, and Enterprise users. Enabling it is a three-step repo settings change:

  1. Navigate to your repository Settings
  2. Go to Copilot then Code review
  3. Next to "Review effort level," select the effort level for automatic reviews in this repository.

Organizations can also set a default review level for unconfigured repositories, while repositories under that organization can still override the default setting if desired. That org-level default is a useful lever for platform teams who want to enforce a baseline without touching every repo individually.

One infrastructure note: Medium reviews use more GitHub Actions minutes and AI credits. If you use Medium effort, consider configuring larger or self-hosted runners for better performance.

The cost picture

Medium consumes more AI credits than Low, with clear cost signals so admins can manage spend under usage-based billing. GitHub has not published a specific credit multiplier for Medium vs. Low, so the right approach is to enable it selectively on your highest-value or highest-risk repositories first, then expand based on observed value.

There is also good news on the efficiency side. These efficiency gains have reduced Copilot code review costs by about 20% while maintaining the same standard of review quality, observed in both offline and online evaluation. That reduction comes from Copilot code review now using the built-in file exploration tools available in the Copilot CLI and SDK, significantly improving review cost efficiency with no change to your existing workflow.

What the review actually sees

Both effort levels share the same agentic foundation. Copilot code review uses agentic tool calling to gather full project context, including source files, directory structure, and references, before it weighs in. That deeper knowledge means feedback that is precise, relevant, and grounded in how your change fits into the bigger picture.

Medium layers a more capable reasoning model on top of that context. Copilot code review can also use repository-level agent skills and MCP servers when they are relevant to the review. It is more likely to use those skills and MCP context when your repository or pull request gives clear signals, including review-focused skill directory names, custom instructions that reference MCP context, and pull request descriptions that include identifiers referencing configured MCP servers such as issue keys or incident IDs.

One important caveat: Copilot always leaves a "Comment" review, not an "Approve" or "Request changes" review. This means that Copilot's reviews do not count toward required approvals for the pull request, and Copilot's reviews will not block merging changes. It is a collaborator, not a gatekeeper.

Where this fits in your workflow

The clearest wins for Medium-depth review are the PRs that already slow down your senior engineers: authentication changes, cross-service refactors, anything touching payment flows or data pipelines. This means senior engineers stop being the bottleneck for consistency across repositories.

A reasonable rollout strategy:

  • Keep Low as the default for most repos, especially documentation and internal tooling
  • Enable Medium on repositories with strict compliance requirements or frequent security-sensitive changes
  • If you are in the Medium analysis depth public preview, the PR overview comment now labels medium analysis depth runs so you can quickly confirm which level generated the review
  • Monitor AI credit consumption for a billing cycle before expanding Medium to more repos

The feature is still in public preview and subject to change, but the direction is clear: GitHub is building a review system where compute investment scales with code criticality, not just PR size.