How does AI code review work?
DEV Community

How does AI code review work?

AI code review is a service connected to your repository that reads a pull request and posts review comments on it.

A review starts with a pull request event, such as opening the pull request or pushing to it, or with a request from a person in the pull request. The reviewer reads the diff together with the surrounding code and the instruction files your team keeps in the repository. One or more model passes, at some vendors several agents working in parallel, produce candidate findings, and vendors describe different ways to check, filter or rank them before anything is posted.

The result is an ordinary GitHub review: comments on the changed lines, usually a summary, sometimes a suggested change and a check. By default the reviewer comments, and people and branch rules decide the merge: Anthropic writes that its review never approves or blocks the pull request, and GitHub writes "By default, Copilot's reviews do not count toward required approvals for the pull request."

The steps below come from each vendor's own documentation, read on 16 November 2026; none of the vendors saw this text before publication.

What happens from opening a pull request to the comments

Something starts it. Most hosted reviewers react to pull request events or to a request in the pull request; Anthropic also documents a GitHub Action you run in your own workflow.

Anthropic's managed Code Review is set for each repository to run "once when a pull request opens, after every push, or only on request.", and "A review reaches your repository through the Claude GitHub App".

GitHub's own reviewer is Copilot code review, where "By default, Copilot only reviews a pull request if you assign it to the pull request.", and users, repository owners and organization owners can turn on automatic reviews; for Codex, "In a pull request comment, mention @codex review.", or turn on Automatic review in Codex settings, which needs no comment.

The Action is the workflow path: "You can also give the Claude Code GitHub Action a prompt to run automatically on any GitHub event."

It reads the change in context. The diff is the starting point, and vendors describe reading past it: the surrounding code, a graph of the repository, earlier comments on the pull request, outside systems and the instruction files a team writes. Codex, for example, names the pull request diff and your repository guidance as what it reviews. Each vendor's words on this are in the section after the list.

One or more model passes look for issues. Anthropic and CodeRabbit describe several agents working in parallel; Qodo describes "specialized review agents that evaluate code from multiple perspectives." CodeRabbit's architecture page names Review and Verification among its agents and puts static analyzers, linters and SAST tools next to them. On GitHub's side, "Copilot code review uses GitHub Actions to run the agentic capabilities, including full project context gathering and passing suggestions to Copilot cloud agent."

Which model runs is the vendor's choice on most hosted reviewers, and a comparison of what AI code reviewers say they check and which models they run on gives each vendor's words on that.

Some vendors narrow the findings before posting. Anthropic, Codex and Qodo each describe a step that narrows what gets posted, and Greptile describes filters plus learning from your team's reactions. Their own words are in the section on what happens before a comment is posted.

The review lands on the pull request. What arrives is an ordinary GitHub review: comments on the lines, at most vendors a summary, and at some a check or status. Copilot "labels each comment with a severity level", and "You can apply suggested changes with a couple of clicks."; by default it leaves a Comment review. Anthropic posts inline comments "with a summary in the review body" and a check run, and "The check run doesn't conclude as a failure." Bugbot adds its summary to the pull request description, and "Bugbot publishes a status for each review run."

People decide what happens next. People reply to the comments, resolve them or react to them, and at Greptile and CodeRabbit that feedback shapes later reviews. With Copilot, for example, a person can also ask for a fix from the pull request, and by default the merge stays with people and branch rules. The last section gives the vendors' words.

What the reviewer reads besides the diff

Greptile "builds a graph of your repository (functions, classes, imports, dependencies) and uses it during reviews to reason about ripple effects beyond the diff."

CodeRabbit describes agentic exploration "that autonomously investigates your codebase for context", and Qodo's agents "assess changes as a principal software architect would, not as isolated diffs."

Copilot can bring in outside context, since "Copilot code review can use MCP servers to pull context directly into the review from the third-party platforms and internal systems your team uses", and Bugbot "reads connected PR comments (top-level and inline) to avoid duplicate suggestions and build on prior feedback".

Instruction files count as context too: Copilot takes in the repository's custom instructions, CodeRabbit finds guideline files such as .cursorrules, CLAUDE.md and AGENTS.md by itself and uses them as review criteria, and Codex applies "the root and more-specific guidance that covers each changed file" from its AGENTS.md files.

What each reviewer says it reads, vendor by vendor, is in a comparison of what AI code reviewers say they read and check.

What happens before a comment is posted

Anthropic, Codex and Qodo each describe a step that narrows what gets posted. Anthropic writes "A review runs on Anthropic infrastructure in four stages:":

  • Find, in which "several agents examine the diff and the surrounding code in parallel."
  • Verify, in which "a verification step checks the candidate findings against the code and filters out false positives."
  • Rank, in which "the findings that remain are deduplicated and ranked by severity."
  • Post, in which "the review posts its results on the pull request."

Codex says that in GitHub it flags P0 and P1 issues and nothing below them, to keep its review comments on high-priority risks.

Qodo writes "Combining multiple review agents with shared context lets Qodo catch what a single-pass review misses, while filtering out low-impact or irrelevant comments before they reach the pull request."

CodeRabbit names Verification among the agents behind each comment.

Greptile describes filters and learning rather than a verification step: "Focus on issues that matter by default; control verbosity with strictness and comment-type filters.", and its list of team learning features includes "Suppresses suggestions your team routinely ignores".

The same steps in each vendor's words

Each cell is the vendor's own wording or a close paraphrase, read on 16 November 2026; this list covers the reviewers whose pages were read and is not a judgment about others.

  • Reviewer: Claude Code Review (Anthropic)

    • How its docs describe the review: four stages on Anthropic infrastructure: Find, Verify, Rank, Post
    • Before a comment is posted: a verification step against the code, then deduplication and ranking by severity
    • What lands on the pull request: inline comments, a summary in the review body and a check run that does not conclude as a failure
  • Reviewer: GitHub Copilot code review

    • How its docs describe the review: "It reviews your code from multiple angles to identify issues and suggest fixes."
    • Before a comment is posted: not described on the pages read
    • What lands on the pull request: review comments with a severity label, suggested changes and "the pull request overview comment"; a Comment review by default
  • Reviewer: CodeRabbit

    • How its docs describe the review: specialized agents working in parallel, among them Review and Verification, with static analyzers, linters and SAST tools
    • Before a comment is posted: Verification is among the agents its architecture page places behind each comment
    • What lands on the pull request: review comments and a walkthrough comment at the top of the pull request thread; "The walkthrough is on by default and fully configurable."
  • Reviewer: Codex (OpenAI)

    • How its docs describe the review: reviews the pull request diff and follows your repository guidance
    • Before a comment is posted: in GitHub, flags P0 and P1 issues and nothing lower
    • What lands on the pull request: "a standard GitHub code review"
  • Reviewer: Cursor Bugbot

    • How its docs describe the review: reviews pull request diffs for bugs, security issues and code quality problems, on each pull request update or when someone triggers it
    • Before a comment is posted: reads earlier comments on the pull request so as not to repeat them
    • What lands on the pull request: comments, a summary in the pull request description and a status for each run
  • Reviewer: Greptile

    • How its docs describe the review: a graph of your repository, used during reviews
    • Before a comment is posted: "Focus on issues that matter by default; control verbosity with strictness and comment-type filters."; learning from reactions, not verification: "Suppresses suggestions your team routinely ignores"
    • What lands on the pull request: review comments and a review summary; "Comments resolve when you push the fix"
  • Reviewer: Qodo

    • How its docs describe the review: "Qodo analyzes pull requests using specialized review agents that evaluate code from multiple perspectives."
    • Before a comment is posted: by its overview, it filters out low-impact or irrelevant comments before they reach the pull request
    • What lands on the pull request: "All feedback appears directly inside your pull requests, where you already work."
  • Reviewer: Sigma (Mnemoverse, the author's company)

    • How its docs describe the review: its homepage: "Sigma checks potential issues and brings the evidence back to your code."; "Prefer GitHub? Comment /sigma review on the PR."
    • Before a comment is posted: its docs: "only confirmed candidates are verified findings"; suspicions no verifier confirmed stay labeled separately
    • What lands on the pull request: its docs: "Up to five verified findings are posted inline, on the line they point to."; "The check is never a merge gate; its conclusion is always neutral."

What stays with people

Copilot leaves a Comment review by default, and GitHub itself writes "Always validate Copilot's feedback carefully. Supplement Copilot's feedback with a human review."

On Copilot's comments, GitHub notes "You can add reactions to them, comment on them, resolve them and hide them."

Greptile "adapts over time using thumbs up/down and short replies.", and CodeRabbit's architecture page describes a part "that learns from your feedback, PRs, issues, and coding guidelines".

On Copilot's review comments, Fix with Copilot lets a person instruct Copilot and choose whether it applies the suggestions in a new pull request against your branch or in a commit to the same pull request.

Whether the comments that land are worth acting on is a separate question, and a summary of what companies measured when they ran AI code review covers it.

Sources and method

Every page linked below was read on 16 November 2026, each quotation matched its page word for word that day, and this text describes those pages as they stood on that date. The list of reviewers is not exhaustive: it covers the vendors whose pages are linked here.

  • GitHub: Copilot code review, using Copilot code review
  • Anthropic: Code Review, Claude Code GitHub Actions
  • CodeRabbit: architecture, code guidelines, walkthroughs
  • OpenAI: Codex code review in GitHub
  • Cursor: Bugbot
  • Greptile: key features
  • Qodo: how Qodo code review works
  • Sigma: docs
Read on DEV Community ↗ ← Back to News

Comments

No comments yet. Start the discussion.