I review pull requests for a 4-engineer team. I use AI to help. I had been using ChatGPT for most of 2024. In December I started reaching for Claude more. In May I decided to run an actual blind test instead of going by feel.

What follows is one engineer's small sample. Take it for what it is.

setup

For 7 working days, I copied every PR I reviewed into both ChatGPT-4o and Claude Sonnet 4. I gave each the same prompt:

Review the following PR for bugs, security issues, performance problems, and design concerns. Be specific and cite line numbers.

I then closed both windows and reviewed the PR myself first. After I committed my own review, I opened the AI responses and graded them on three things:

1. Real issues caught: things that were genuinely problems

2. False positives: things flagged that were fine

3. Time to first useful insight: how long before the model said something worth keeping

The PRs covered: a TypeScript migration, two React refactors, a Python data pipeline, a database schema change, a CI script update, and one Go service rewrite.

Sample size: 7 PRs. Not enough to publish. Enough to change how I work next quarter.

the seven PRs

PR 1: TypeScript migration of a legacy service

Claude flagged a missing Record<string, T> type that would have caused runtime errors on a code path none of us had tested. ChatGPT flagged the same area but framed it as "consider adding a type" without naming the bug.

Winner on this one: Claude. ChatGPT was right but vague.

PR 2: React component refactor (state management)

ChatGPT caught a useEffect dependency issue that would have caused a re-render loop. Claude missed it on the first pass and caught it when I followed up.

Winner: ChatGPT. Faster on a classic React bug.

PR 3: React component refactor (Suspense boundary)

Both models identified that the Suspense boundary was wrapping a server component that didn't actually suspend. Claude explained why more clearly. ChatGPT recommended a refactor that would have introduced a separate bug.

Winner: Claude. Better reasoning.

PR 4: Python data pipeline (pandas)

ChatGPT immediately spotted that we were chaining .iloc[] calls in a way that would produce a SettingWithCopyWarning. Claude flagged the same area but recommended a refactor that involved a dependency we don't have.

Winner: ChatGPT. Pragmatic.

PR 5: Postgres schema change

Both models caught that the migration was missing an index on a foreign key column we had queried in a hot path. Both also caught that the new NOT NULL column had no backfill plan.

Tie. Both useful.

PR 6: CI script update (GitHub Actions)

Claude noticed that the new workflow used actions/checkout@v3 while the rest of our pipeline was on @v4. Small inconsistency. Real one. ChatGPT noticed nothing.

Winner: Claude. Picky in a useful way.

PR 7: Go service rewrite

ChatGPT and Claude both flagged a missing context.Context cancellation check in a long-running goroutine. ChatGPT also recommended a code style change ("use errors.Is instead of ==") that was already enforced by our linter. Claude did not raise that.

Tie on the real bug. Claude wins on signal-to-noise.

scoring

ChatGPT was faster. Claude was more accurate per token of output.

where each excelled

ChatGPT was better at fast, opinionated answers about idiomatic code. It also knew more recent React patterns than Claude did. (Both models have cutoffs in early 2025, but ChatGPT's training seemed to over-index on React docs and patterns.)

Claude was better at reasoning about state across multiple files, picking up small inconsistencies (like the GitHub Actions version mismatch), and explaining why a recommendation matters. The explanations made me a better reviewer, not just a faster one.

where each failed

ChatGPT's worst failures were confident-sounding recommendations that would have introduced new bugs. Three of my false positives were ChatGPT recommending refactors that broke abstractions our team had agreed to.

Claude's worst failure was missing the React re-render bug in PR 2. It got there on follow-up, but a missed bug on first pass is what an AI reviewer is supposed to catch.

what I do now

I run both. I paste the PR into Claude first because I trust its first-pass signal more. If I want a second opinion or I want a fast scan, I throw the same PR into ChatGPT.

This costs me $40/month combined. For a senior engineer's monthly salary, that ratio is comical. The tools are not yet a replacement for a competent reviewer. They are a second pair of eyes that doesn't get tired.

For code review specifically, my advice after seven days:

• Use Claude as the primary

• Use ChatGPT as the speed-check

• Never trust either's "this is fine" without your own read

• Always verify the line numbers (both models occasionally hallucinate one)

honest caveats

• Sample size of 7 is not science

• I work in TypeScript, Python, Go. Your mileage in Rust, Haskell, C++ may differ

• Both models will be different next quarter

• I am one reviewer at one company with one coding style; weight accordingly

I will run this again in October. I expect the gap to narrow either way.