Pull Request Reviews Separate Evidence From Judgement

Claude Code reads the diff before it reads the intent

A pull request arrives as a shape before it arrives as a story. The shape is a set of changed lines, renamed symbols, and deleted branches. The story is the reason a teammate believes those changes belong in production. Claude Code can hold both at once, but the review gets sharper when you hand it the intent in plain sentences first and then ask it to argue the change back against that intent. That inversion is the whole method, and it is the point of a side-by-side reading: your judgement and the model's reading sit next to each other before either one hardens into a verdict.

Start the session with the author's summary, the surrounding design notes, and the full diff split into chunks small enough that nothing is silently skipped. Ask Claude Code to restate the intent in its own words before it comments on anything. A mis-paraphrase at that stage is the cheapest defect a review can catch, because every later observation would rest on the wrong premise. Then request the mechanical pass: changed signatures, renamed identifiers, new error paths, tests that moved or quietly disappeared. Keep that pass separate from judgement so the moment where the two of you begin to differ is visible instead of blurred.

Only then open the interpretive pass. Have the model describe the behaviour a user would notice after the change lands, the behaviour that stops existing, and the assumptions the code now makes about its callers. Compare that description with your own before reading a single comment the model writes. If both readings describe the same system, the disagreement that follows is about quality rather than about reality, and those arguments settle far more easily.

Explicit criteria turn taste into a checklist the author can answer

Vague reviews produce vague fixes. A note such as this feels risky leaves the author guessing, and the next push often solves a problem nobody meant. Criteria make the review answerable, repeatable, and fair across authors with very different levels of confidence.

• Correctness: the change does the thing the summary claims, including the edges of input, time, and state.
• Compatibility: public interfaces, stored data, and existing callers keep working, or the break is announced and migrated deliberately.
• Failure handling: errors surface with context, retries stay bounded, and partial work never masquerades as success.
• Tests: new behaviour has new coverage, and the tests fail for the right reason once the change is reverted.
• Readability: names match the domain, control flow stays shallow, and the next reader needs no archaeology.
• Security and data handling: inputs are validated at the edge, secrets stay out of logs, and permissions are checked where the action happens.
• Performance and resource use: the hot path stays predictable, allocations are justified, and expensive work is not hidden inside a helper.
• Operations: the change is observable, reversible, and safe to deploy while the previous version still serves traffic.

Score each criterion as pass, concern, or blocker, and attach the observation that moved the score. The judgement belongs to the reviewer, while the evidence can come from either reader. A criterion that never changes a decision deserves to be dropped from the checklist, and one that catches the same defect twice deserves to move to the top.

Running the tests beats trusting the claim that tests pass

A review that stops at reading inherits every assumption in the author's head. Ask Claude Code to run the relevant suite, then to write the smallest test that reproduces the bug the branch claims to fix. If that test passes on the untouched revision, the fix is decorative and the real defect lives elsewhere. If it fails before the change and passes after it, the review rests on evidence rather than confidence.

Beware the tests that assert only that no exception was thrown, and the ones whose fixtures encode the bug as expected behaviour. Have the model trace the report each new assertion would give once the change is reverted, then look for branches the suite never touches. Unreachable error handling is usually either dead code or an untested disaster waiting for a bad day in production.

Mechanical work suits mechanical readers, and a quick, inexpensive model such as Claude Haiku 4.5 handles it well. The final judgement, where taste and trade-offs carry the decision, deserves the stronger reader, such as Claude Sonnet 5.5. Splitting the session keeps expensive reasoning on the questions that actually change the outcome.

The model sees scale while the human sees intent

Side by side, the two readers are not redundant. A human reviewer carries the roadmap, the incident history, the unspoken conventions, and a sense of the code the team is prepared to maintain for years. Claude Code carries stamina: it reads every hunk, notices the helper copied into three modules, and finds the pattern that breaks at the ninth call site rather than the first.

That difference should shape the division of labour. Let the model enumerate call sites, error branches, and tests that touch the changed interface, then let the human weigh whether the abstraction earns its weight, whether the deadline justifies a temporary shape, and whether the plan still fits the system a year from now. When the two accounts disagree, the disagreement is the most valuable artifact the review produces, and it deserves a paragraph instead of a shrug.

Trust deserves the same treatment. Ask the model to flag anything in the change that touches authentication, authorisation, input validation, logging of personal data, or the boundaries between services. It will not know your compliance obligations, but it will surface every place where those obligations might be tested, and that list is exactly where a careful reviewer should spend attention.

Writing the verdict keeps the author moving

Order findings by blast radius. Blockers come first: correctness, data loss, security, anything that makes the change unsafe to ship. Concerns that need a decision from someone with more context follow. Nits come last, batched so they do not dilute the serious points. Every finding names a location, a consequence, and the smallest change that removes the risk. Every criterion that passed gets a short confirmation, because an author who hears only complaints learns nothing about the standard being applied.

BestRelay, the publication behind this article, is a quality-first API relay that forwards each request to the official model named in it, with no substitution, covering Claude, GPT, Gemini, DeepSeek, Kimi, GLM, Qwen, Grok and more. It works with Claude Code, Codex, Gemini CLI, and any OpenAI SDK through a single API base. Billing is pay-as-you-go from the token counts the provider reports, with cache reads and cache writes priced separately, and members earn a referral commission when the people they invite top up.

Close the review with a short record of the claims that were verified, the assumptions that remain in place, and the questions still open. The author should leave knowing the findings that carry evidence and the ones that are still bets. Create a BestRelay account and run a single review in this shape to feel the difference.