I've been using Claude Code as my main coding medium for a couple of months now. It's an incredibly capable tool and has made the process of quickly spinning up features and toying with prototypes a breeze, and dare I say - quite fun.

But here's the thing. Every now and then Claude will create a buggy feature with absolute confidence. The code looks fine. Reads fine. You glance at it, nod, move on. But as we get used to frontier models being right 90%+ of the time, we're spending less and less time looking for these bugs. Humans are lazy after all, we'll always default to the path of least resistance.

I wanted a second pair of eyes. A different model with different training and different blind spots. The latest coding model from OpenAI (Codex 5.3) is incredibly adept at spotting bugs and security issues, but it's too slow and unintuitive for me to use as my daily driver. So I wired OpenAI's Codex CLI into Claude Code as a local MCP server, then wrote a skill called super-review that makes them check each other's work.

It's parenting, basically.

MCP, in a nutshell

MCP (Model Context Protocol) lets you give Claude access to external tools. You run a local server, Claude discovers what's available, and suddenly your coding assistant can talk to other services. The Codex CLI ships with an MCP server built in.

MCP can do much more than this but for the purposes of this post I figured it's better left to the people who designed it: Anthropic MCP announcement

The best part is I just asked Claude Code to set it up. I told it I wanted Codex as an MCP server, it installed the CLI, configured the connection, and wired everything together.

The skill

Claude Code has the concept of skills. They're markdown files that describe a multi-step workflow. Claude reads the instructions and follows them. No code needed, just markdown.

I wrote one called super-review. It's a two-pass code review. First, Claude does a primary review across eight areas: bugs, security, visual quality, code structure, performance, accessibility, type safety, and error handling. Each one gets a Pass, Concern, or Fail. Then it sends the same code over to Codex for a completely independent second opinion. The final output is a synthesised report combining both perspectives.

The full skill file lives at .claude/skills/super-review/SKILL.md:

---
name: super-review
description: Deep multi-pass code review using Claude and Codex as pair reviewers
allowed-tools: Read, Grep, Glob, Bash, mcp__codex__codex
---

# Super Review

You are performing a rigorous, multi-pass code review. You will act as
the primary reviewer, then use Codex as an independent pair reviewer
for a second opinion. Synthesise both into a single actionable report.

## Step 1: Determine Scope

- If arguments specify files or a directory, review those
- If a PR number, run gh pr diff to get the diff
- If blank, review the most recent commit or unstaged changes

Read all relevant files fully before starting.

## Step 2: Claude Primary Review

Analyse across eight dimensions. For each, assign Pass / Concern / Fail:

1. Bugs & Correctness
2. Security
3. Visual Implementation & Design Quality
4. Code Structure & Maintainability
5. Performance
6. Accessibility
7. Type Safety
8. Error Handling & Edge Cases

## Step 3: Codex Pair Review

Send the code to Codex for an independent review. Be specific,
cite line numbers, only flag issues.

## Step 4: Synthesise Report

Combine both into: Critical Issues, Warnings, Suggestions,
Dimension Ratings table, and Codex Second Opinion.

You run /super-review and it just works. Claude reads your code, forms its own opinion, then asks Codex to do the same without seeing Claude's notes. Two reviewers who can't collude.

Setting it up

1. Open Claude Code and ask it to set up the Codex CLI as an MCP server. It'll handle the install and config for you.
2. Set an OpenAI API Key or connect your ChatGPT account in the Codex CLI.
3. Drop the skill file into .claude/skills/super-review/SKILL.md or ask Claude to do it for you if you're feeling particularly lazy.
4. Run /super-review next time you've got changes to review.

The token bill from making two models argue about your code is another matter, but I find it therapeutic.