Skip to content

Codex vs Claude Code Review for GitHub Pull Requests

Compare Codex and Claude Code Review on GitHub PRs: triggers, what each posts, severity filtering, plans, and how to turn findings into a merge decision.

Published 10 min readBy the Warpway team

OpenAI's Codex code review and Anthropic's Claude Code Review both review GitHub pull requests and post their findings as a GitHub review (Claude as inline comments). They differ in how a review starts, what it posts, how findings are filtered, and how you pay. Codex reviews when someone comments @codex review or automatically, flags only P0 and P1 issues, and comes with ChatGPT plans from Plus up. Claude Code Review runs on Team and Enterprise plans, sorts findings into three severities, adds a check run that ends neutral or skipped but never fails, and bills each review as token usage. It never approves or blocks a pull request, and OpenAI's page describes no check run or verdict for Codex, so something else has to make the merge decision.

This comparison uses each vendor's public documentation as of November 2026. It covers the GitHub pull request reviewers, not the coding agents.

Codex vs Claude Code Review at a glance

Codex code reviewClaude Code Review
Starts a review@codex review comment, or Automatic review with a Review trigger settingPer-repository Review runs: once after PR creation, after every push, or manual; @claude review anytime
Who can start oneNot specified for @codex review comments; changing automatic-review settings needs a connected repo and GitHub push or admin permissionAn Owner turns it on; comment commands need write, maintain or admin access; comments from bots don't start reviews
What it postsA review on the pull request, "just like a teammate would"; 👀 reaction on the requestInline comments, a summary in the review body, and a Claude Code Review check run
SeverityOnly P0 and P1 issues are flagged in GitHub🔴 Important, 🟡 Nit, 🟣 Pre-existing
Customization## Code Review Rules in the nearest AGENTS.mdREVIEW.md (read from the base or default branch) and CLAUDE.md
Merge effectNot described; OpenAI says review rules "don't replace tests, branch protections, or required approvals"Never approves or blocks; the check run ends neutral or skipped, never failure
PlansPlus, Pro, Business, Enterprise/Edu (not API-key access)Team and Enterprise; not available with Zero Data Retention, the HIPAA configuration, or customer-managed keys
BillingCounts as Code Review usage on your ChatGPT planToken usage billed through usage credits, separate from plan usage
Code hostsGitHubGitHub, including GitHub Enterprise Server and GHE Cloud with data residency

How each one is triggered

Codex

You connect a GitHub repository to Codex, then turn on code review for it in Codex settings. From then on, mentioning @codex review in a pull request comment starts a review. Codex reacts with 👀 and then posts its review. You can narrow a single review in the comment itself, for example @codex review for issues in the database migration. With Automatic review turned on, reviews start without the comment, at the times you pick in Review trigger. OpenAI's page doesn't list which pull request events count. It also documents a separate @codex security review command, a research preview, that posts security findings and keeps a full report in the linked Codex task.

Claude Code Review

An Owner of the Claude organization installs the Claude GitHub App and sets each repository's Review runs mode. Repositories added from the admin page default to After every push, which runs the most reviews. Automatic reviews skip drafts and pull requests from forks. The comment commands are:

  • @claude review (or @claude review once): one review of the whole pull request, without subscribing it to later pushes.
  • @claude review always: review now and on every later push.
  • @claude review stop (or off or pause): end that subscription.

An Owner also sets a review level, which trades depth against cost: Quick, Standard (the default) or Deep. Reviews run on Anthropic infrastructure with read-only access, and they read the diff and the surrounding code without building or running it.

What each posts and how severity filtering works

Codex: P0 and P1 only

According to OpenAI, Codex in GitHub "flags only P0 and P1 issues so review comments stay focused on high-priority risks." That threshold is the main noise control. To change what gets flagged, add a ## Code Review Rules section to the AGENTS.md closest to the code it covers, with ### headings to group checks. Put repo-wide rules in the root file and service-specific rules in nested files. OpenAI suggests starting with two or three concise rules and leaving formatting and lint to CI.

Claude: three severities and a verification pass

Claude's review has four stages: several agents look for issues in parallel, a verification step checks each candidate against the code and drops false positives, the remaining findings are deduplicated and ranked, and then the results are posted. Each finding gets one of three markers: 🔴 Important (fix before merging), 🟡 Nit (worth fixing, not blocking) or 🟣 Pre-existing (a bug the PR didn't introduce). Reviews that start automatically after a push focus on what changed and post fewer nits and pre-existing findings. The review body says how many it left out.

REVIEW.md is the tuning file. It can redefine what counts as Important, cap the number of nits ("Report at most five Nits per review"), skip generated paths, and add checks that run on every PR. Claude reads it from the base or default branch, never from the pull request's own changes. Some instructions, such as lowering severity, excluding paths and capping nits, only apply when the root file sits on a protected default branch.

The practical difference is where the filter sits. Codex filters by a fixed priority threshold. Claude posts lower severities as well and lets you recalibrate what counts as severe.

Plans and pricing (as of November 2026)

Codex. OpenAI's pricing page lists "GitHub code review and automatic PR reviews" on Plus, Pro, Business and Enterprise/Education, but not on API-key access. Plus is listed at $20 per month. Business is $20 per user per month billed annually for two or more users, or $25 billed monthly. Code Review usage applies only when Codex reviews through GitHub; reviews you run locally count toward your general usage limits. The page gives no per-review price or count.

Claude Code Review. It's available on Team and Enterprise plans, and there's no flat per-review price. Reviews are billed on token usage through usage credits, separately from the plan's included usage, and charged to the organization. Cost per review grows with the review level, the size of the change and the number of candidate issues to verify. Cost per pull request also multiplies with After every push. Admins can set a monthly spend limit for Code Review. When the budget runs out, reviews are skipped and the pull request gets a comment saying why. Anthropic suggests a pilot on a few repositories, set to Once after PR creation or Manual, to estimate spend.

Running both on the same pull request

Before running both, check these points:

  • Two severity scales. Codex's P0 and P1 don't map one-to-one onto Claude's Important and Nit, and nothing reconciles the two. If both tools flag the same bug, you see two comments on it. If they disagree, a person has to decide.
  • Trigger collision. If the repository also runs the Claude Code GitHub Action with its default @claude trigger phrase, an @claude review comment starts the Action too. Anthropic recommends setting the Action's trigger_phrase to something else.
  • Two bills that grow differently. Codex review draws on ChatGPT plan usage. Claude review draws on organization usage credits for each review, and push-triggered modes multiply that.
  • Still no gate. Claude Code Review's check run never concludes as a failure, and OpenAI's page describes no check run or verdict for Codex, so neither gives you a documented merge gate on its own.

Both are advisory: turning findings into a merge decision

Anthropic says: "A review never approves or blocks the pull request, so the decision to merge stays with your team." It also notes that a review with no findings "doesn't mean your code is error-free or secure." If you want findings to block merges, you have three ways to do it.

Gate on Claude's check run yourself

Anthropic documents a machine-readable line at the end of the check run's details: <!-- bughunter-severity: {...} -->. In it, normal is the count of Important findings. The script below uses Anthropic's documented gh and jq commands. Run it as a CI job after the Claude Code Review check finishes, then make that job a required check:

bash
#!/usr/bin/env bash
# Fail when Claude Code Review left open Important findings.
set -euo pipefail
: "${OWNER:?}" "${REPO:?}" "${SHA:?}"

run_id=$(gh api "repos/$OWNER/$REPO/commits/$SHA/check-runs" \
  --jq '.check_runs[] | select(.name == "Claude Code Review") | .id' | head -n 1)
[ -n "$run_id" ] || { echo "No Claude Code Review run on $SHA"; exit 1; }

title=$(gh api "repos/$OWNER/$REPO/check-runs/$run_id" --jq .output.title)
case "$title" in
  "Code review not repeated"*) echo "Earlier Important findings still open"; exit 1 ;;
  *"no new changes") exit 0 ;;
esac

important=$(gh api "repos/$OWNER/$REPO/check-runs/$run_id" --jq '
  (.output.text | split("\n") | last
    | scan("^<!-- bughunter-severity: (.*) -->$")[0] | fromjson)?
  // error("no severity line") | .normal') \
  || { echo "No verdict from Claude Code Review"; exit 1; }

[ "$important" -eq 0 ] || { echo "$important Important finding(s) open"; exit 1; }

As Anthropic advises, treat a missing severity line as "no verdict," not as zero findings. Failed, timed-out, cancelled and superseded reviews don't have one, so the script fails instead of passing. How to block merges on AI code review findings covers the GitHub ruleset side.

Codex

OpenAI's page documents no check run or severity summary to script against. Gating on Codex therefore means building on its review comments yourself. OpenAI's own position is that review rules don't replace branch protections or required approvals.

Use an orchestration layer

The script above turns one reviewer's output into a pass or fail. It doesn't handle the cases where the answer is a product or ownership question that no reviewer can settle from the code. An orchestration layer such as Warpway sits there.

Warpway is a GitHub App that runs its own review through lenses: Correctness, Security, Testing / Reliability and five others. Each lens ends in one of four states: Cleared, Issue found, Human decision required or Incomplete. Deterministic code, not a model, checks your policy against those stored results and reports one check, Warpway / Review. At trust level 2 (Gate) and above, it concludes:

  • success only when the policy is satisfied;
  • action_required when only human questions remain;
  • failure for blocking findings, incomplete lenses or failing required CI.

At Observe, and at Assist (the default for new repositories), every finished review reports neutral.

Questions it can't settle go to the person most likely to know, in GitHub or Slack, along with why that person was picked. See how reviews work and merge gating.

Warpway can run alongside Codex or Claude. Its lenses have read-only tools for the pull request's comments, review comments and CI results, and they treat that text as data, not instructions. To make the Claude gate job above part of Warpway's policy, list that job, not the Claude check itself. Warpway counts neutral as passing for merge_gate.required_ci_checks, so listing Claude Code Review there directly would only make it wait:

yaml
version: 1
required_lenses:
  - correctness
  - security
  - testing
merge_gate:
  block_on_severities:
    - critical
    - high
  require_zero_open_human_tasks: true
  required_ci_checks:
    - build
    - claude-review-gate   # your job from the script above

Limits to know:

  • Warpway works with GitHub only.
  • Gating needs the Team plan ($30 per developer per month) and the Gate trust level. On the Free plan the trust level is capped at Assist, so Warpway / Review reports neutral and doesn't block merges.
  • The hosted service runs on OpenAI's GPT-6 Sol. The review engine also runs on Anthropic's Claude models, but Warpway sets the model, not each customer (model providers).
  • It never merges.

For an example of the output, see the Hono c.json(undefined) case study. It's a replay, run on 2026-10-07, of a merged pull request as it stood before merge. Warpway did not review it while it was open, and the replay does not mean Hono uses Warpway.

How to choose

  • You're already on ChatGPT Plus or Business and want a reviewer that only comments on high-priority risks: Codex. Setup is a repository connection and a toggle.
  • You're on a Claude Team or Enterprise plan and want severity tiers, per-repository cadence and depth, and a check run you can script: Claude Code Review. Budget for per-review usage and pilot it first.
  • Your Claude organization uses Zero Data Retention, the HIPAA configuration or customer-managed keys: Code Review isn't available. Anthropic lists other review options, such as /code-review in Claude Code or Claude in your own CI; check whether they fit your data-retention setup.
  • You need findings to become a merge decision: keep whichever reviewer you like and add a gate: the script above for Claude Code Review, or an orchestration layer that runs its own review and routes open questions to people. For tool-by-tool detail, see the Codex code review alternative and Claude Code Review alternative guides.

Frequently asked questions

Can Codex and Claude Code Review run on the same pull request?

Yes. They are separate GitHub integrations with different triggers, so each posts its own review and the two don't share findings. One collision to watch: if the repository also runs the Claude Code GitHub Action with its default @claude trigger phrase, an @claude review comment starts the Action too, so Anthropic recommends giving the Action a different trigger_phrase.

Does Claude Code Review review draft pull requests or pull requests from forks?

Automatic reviews skip both. You can still request one by commenting @claude review, as long as you have write, maintain or admin permission on the base repository. On a draft, pushes don't start reviews even after @claude review always, and on a fork that subscription doesn't apply to later pushes.

Can I point a Codex review at one specific concern?

Yes. You can add a focus after the mention, for example @codex review for issues in the database migration. Rules that should apply every time belong in a Code Review Rules section of the AGENTS.md file closest to the code they govern.

Can I choose which model Claude Code Review uses?

No. Code Review chooses its own Claude models, and the admin settings don't offer a model choice. What you control is the review level: Quick, Standard (the default) or Deep. An Owner sets it for the organization and can override it per repository.

Does Warpway replace Codex or Claude Code Review?

Not necessarily. Warpway runs its own review and reports one check, Warpway / Review, which you can make a required check at the Gate trust level or above; it can run alongside either tool on GitHub. Its hosted service uses OpenAI models, it works only with GitHub, and merge gating requires its Team plan.

Sources

  1. Code Review – Claude Code Docs
  2. Read and request reviews on a pull request – Claude Code Docs
  3. Customize Code Review – Claude Code Docs
  4. Code Review costs and usage – Claude Code Docs
  5. Review GitHub pull requests with Codex – ChatGPT Learn
  6. Pricing – ChatGPT Learn (Codex)