Cross-Model LLM Code Review: Should you use Claude to review Codex or vice versa?
Zuodong Xiang, Yike Zhang, YueMing Zhang, Hailu Xu
KDD'26
cs.SE, cs.AI
2026-07-23
On 116 LiveCodeBench tasks, Claude reviewing Codex drafts lifts pass rate from 71.6% to 89.7%; the reverse, Codex reviewing Claude, drops it from 91.4% to 82.8%.
A lot of coding workflows now chain two models. One agent writes a draft, another reviews it before the change lands, the way a human engineer would in code review. The intuition is that a second model, with different knowledge, catches what the first missed. But the second call costs more tokens and wall-clock time, and it can also take a working solution and break it. This KDD'26 workshop paper asks the question directly: is cross-model review worth it, and does the order, who writes and who reviews, matter?
The setup is clean. Tasks are 116 hard and medium LiveCodeBench problems, single-file Python with hidden tests, all released after 2025 and after the training cutoffs of Claude Opus 4.7 and Codex GPT-5.5, so neither model could have memorized the answers. Six conditions cover every writer-reviewer pairing: A (Claude solo), O (Codex solo), OA (Codex writes, Claude reviews), AO (Claude writes, Codex reviews), AA (Claude self-review), OO (Codex self-review).
The binding constraint is static review. The reviewer sees the problem and the draft but cannot run code, query a test runner, or inspect execution traces, mirroring the pre-CI review a developer does by hand. All conditions use high reasoning effort, the same prompts, and the same <solution> output format, so any measured gap comes from the review pass itself. Statistics use paired McNemar tests with Benjamini-Hochberg correction.
The headline is that direction matters. Who reviews whom swings the pass rate by double digits.
| Condition | Pass rate | Delta vs solo | Cost/task | Regression rate |
| A (Claude solo) | 91.4% | baseline | $0.226 | n/a |
| O (Codex solo) | 71.6% | baseline | $0.190 | n/a |
| OA (Codex to Claude) | 89.7% | +18.1 pp | $0.443 | 4.3% |
| OO (Codex self) | 84.5% | +12.9 pp | $0.312 | 5.2% |
| AO (Claude to Codex) | 82.8% | -8.6 pp | $0.382 | 11.2% |
| AA (Claude self) | 91.4% | +0.0 pp | $0.389 | 2.6% |
Codex solo sits at only 71.6%. Hand those same drafts to Claude for review and the rate jumps to 89.7% (BH-adjusted p = .001), within two problems of Claude solo. Codex reviewing itself reaches 84.5% (p = .022). The reverse direction does not pay. Codex reviewing Claude drafts drops the rate from 91.4% to 82.8% (p = .046), and Claude reviewing itself leaves 91.4% untouched.
Splitting fixes from regressions (Figure 1) sharpens the asymmetry. OA fixes 26 failures and breaks 5 successes (net +21); AO fixes only 3 but breaks 13 (net -10). Reading through the artifact cases, the two models intervene differently. Claude as reviewer tends to keep the writer's interface and repair one local invariant, such as restoring segment-tree state. Codex as reviewer, when uncertain, discards the writer's data structure and rewrites from scratch, for example replacing a passing sorted-list median window with a heap that then fails hidden tests.
For teams running coding agents, this is an actionable rule. If the writer is Codex, a Claude review is worth adding at roughly $1.40 per net fix ($0.25 extra per task, 21 net passes across 116 tasks). If the writer is already Claude, skip the review: self-review buys nothing for more cost and latency, and cross-model review loses 8.6 points. The paper also flags a cheaper path: when latency is tight and 84.5% is acceptable, Codex self-review (OO) is faster and cheaper than the cross-model pairing.
The mechanism generalizes beyond this one pair. A review pass is bounded by how much stronger the reviewer is than the writer. A stronger reviewer has room to lift a weaker draft; a weaker reviewer can mostly only drag a stronger one down. This matches the Olausson et al. self-repair finding that repair helps only when the repair model is meaningfully stronger than the draft model. Latency points the same way: Claude solo takes 86.2 s versus Codex's 38.5 s, consistent with Claude spending more compute on first-pass checks and leaving little for a second pass to find.
The authors draw the boundary clearly. The 116-task sample is an exploratory diagnostic, not a leaderboard verdict, and only one model pair is tested, so generalization to Gemini, DeepSeek, Qwen, or Grok is unverified. Static review with no test execution likely understates what a sandboxed, tool-using agent could fix, and the tasks are single-file Python, so no repository-scale bug fixing, build systems, or multi-file review.
Two caveats stand out. First, the authors concede they cannot fully separate the effect of review direction from the effect of the two models' baseline gap, so the ordering claim is descriptive of role assignment, not a causal statement about direction alone; the direct AO-versus-OA McNemar test does not survive BH correction (p = .144). Second, the fix-versus-regression pattern, where Claude repairs locally and Codex rewrites, is an interpretive read across the artifact rather than a quantified taxonomy, and may not reproduce across runs.