GitHub Copilot code review, tuned to how your team works
You know the feeling. You open a pull request and the AI-powered code review is technically correct but beside the point.
It flags a naming nit and misses that the change cuts against an architectural decision your team made three months ago. It doesn't know the pattern you standardized on, the service-level target this code has to hit, or the incident that made you write it this way. So, you talk past the feedback or re-explain context you've already provided a dozen times.
That happens because many AI code review tools read the diff in isolation. They see what changed, but not why, and not the standards your team uses to decide whether a change is any good. Those standards don't live in the diff. They live in your past decisions, your issue tracker, your service catalog, documentation, and the conventions your team carries in their minds. GitHub Copilot code review brings them in: it adapts to how your team works, using your standards, your tools, and your context. Instead of a generic pass over the diff, you get focused, cited comments you can act on, grounded in what your team has already decided matters.
Here's how you make it yours.
Teach Copilot your team's standards
Start with the standards you've already written down. Drop an AGENTS.md file in your repository root and Copilot reads it automatically. If you already keep an AGENTS.md to steer other agentic tools, Copilot uses the same file, so there's nothing new to maintain.
When you need to go further, custom instructions let you spell out exactly what your team cares about, and they're no longer capped at 4,000 characters. You can capture the full nuance of your standards instead of a summary. Write the standard once, and every review reflects it, for every contributor, including the ones who joined last week.
Bring your tools and context into every review
Most of your standards live in systems beyond the diff, so Copilot code review connects to them. With support for MCP servers and custom agent skills, Copilot brings your issue tracking, documentation, service catalogs, and incident tooling into the review itself.
MCP servers let Copilot pull context from any MCP-compatible service during a review.
Custom agent skills teach Copilot to check team-specific policies or enrich feedback with data from your internal APIs.
Copilot also draws on the context already inside GitHub. It discovers relevant prior discussions, design decisions, and related changes across your issues and pull requests. When Copilot notes that “this approach conflicts with the decision in pull request #289” or “the behavior specified in issue #412 needs different handling here,” it’s referencing your real project history, not generic advice.
And this setup carries across Copilot. Skills and MCP servers you configure for Copilot cloud agent work for code review too, so you set things up once. You also stay in control of what Copilot can and can’t see: content exclusion keeps sensitive paths out of scope.
Tailor the depth to the change
Not every pull request needs the same scrutiny. Copilot offers a balanced analysis tier that routes more complex pull requests to a higher-reasoning model, while the lite tier stays a cost-efficient default. Reviews go deep where it matters and stay quick where it doesn’t.
How a review comes together
Copilot reviews code the way an experienced reviewer does. It starts from your change and pulls in the context that actually bears on it, whether that’s a single caller or a dozen. The goal isn’t more context or less, it’s the right context, so feedback stays focused on what your change actually affects.
When a review is triggered, whether automatically on a new pull request or on demand, Copilot:
Analyzes the diff in the context of the full file and repository structure, utilizing file tools to search the repository for relevant context.
Applies your team’s guidelines, including your AGENTS.md, custom instructions, and configured rules.
Calls the external tools you’ve connected, such as MCP servers and custom agent skills, to gather signals from your toolchain.
Produces review comments grounded in all of it, with references and explanations.
You configure what matters to your team, and Copilot handles the orchestration.
What this looks like in practice
Reviews that understand why the code changed.
Say a backend engineer opens a pull request migrating a shared service client to a new resilient wrapper. The approach was agreed months ago in a tracked issue, but neither assigned reviewer was part of that discussion, so they’d be checking whether the code works, not whether it honors the decision that shaped it. A connection to the team’s issue tracker surfaces the original decision and cites it inline, and a connection to the service catalog checks the retry configuration against the live service-level target instead of a stale doc. Reviewers arrive ready to judgment calls, not conduct archaeology.
Consistent standards across teams.
A platform team with a dozen squads standardizes on one API convention: cursor-based pagination, canonical error envelopes, and deprecation headers. A linter catches formatting, but pull requests keep landing that are lint-clean yet semantically off, and the gaps surface weeks later when a partner integration breaks. With custom instructions configured at the organization level, Copilot evaluates every pull request that touches an API surface against the required patterns and points to a prior pull request where the team applied the same standard, giving developers a concrete reference before the change ships.
Catching regressions before they repeat.
A developer refactors an order-total calculation to support a new discount type. The diff is clean and the tests pass, but a nearly identical change once introduced a rounding error that caused a production incident, and the current reviewer wasn’t on the team then. A connection to the team’s incident tooling surfaces that history. It points to the prior incident and fix, links to where the team settled on the correct rounding strategy, and flags that the new approach diverges without explanation. The developer adjusts in minutes, not after a second outage.
Senior-engineer-level judgment on every review, without the bottleneck
A team owns a service where the real risks aren’t style, they’re the load-bearing assumptions a new contributor can’t see: which call paths are latency-sensitive, where a retry can quietly double-charge, which “small” change has broken things before. That knowledge usually lives in one or two senior engineers’ heads, so reviews of anything sensitive wait on them.
An agent skill lets the team encode that context once, so Copilot reviews every pull request with the same hard-won judgment and flags the risky change before it reaches the people who’d otherwise be the bottleneck. Their attention goes to the calls that genuinely need a human, not to being the only line of defense on every review.
What this means for your team
Copilot adapts to your team: your standards, your tools, and your context. Start with what you’ve already written down, and add depth as you go.
Reviews reflect your standards, not a generic default. With agent skills and MCP connections, the rules and tools your team already relies on become part of every review.
Your setup compounds. The more standards you capture in custom instructions and tools you connect, the more each review reflects how your team actually works.
Human reviewers focus on what matters. Context-aware reviews handle the baseline, so your engineers spend their time on architecture, design, and the calls that genuinely need their judgment.
Get started
These capabilities are available on paid GitHub Copilot plans. Start simple: add an AGENTS.md to a repository your team actively reviews, then request a review on your next pull request. From there, sharpen your custom instructions, and when you’re ready, connect an MCP server or a custom skill to bring your own tools into the review. On Copilot Business or Copilot Enterprise, your admin needs Copilot code review policies enabled across your organization or enterprise account. Copilot code review is also available for Azure Repos, in technical preview, for teams working in Azure DevOps.
Visit the Copilot code review documentation to get started.
