Claude Code second opinion

If you were like me, you had two terminals open.

One running Claude Code. One running Codex. You’d read Claude’s plan, copy the whole thing, switch windows, paste it in, and ask Codex what was wrong.

It would always find something.

Not always a disaster. But enough — a buried assumption, a test out of scope, a dependency conflict — that I kept doing it even though it was annoying. The copy-paste round trip was real work. I was doing it on every plan that felt risky.

So I built a skill that does it automatically. You can find it at github.com/cathrynlavery/codex-skill.

Claude makes a plan. The skill calls Codex in to review it before you see the approval prompt. Codex finds what it finds. Claude sees the feedback and updates the plan. You read both sides before you decide. The whole loop happens without you switching windows or touching anything.

What Codex is

Codex is a Claude Code skill that routes plans to OpenAI’s Codex CLI for review. It has 151 stars on GitHub and it works in two modes.

The automatic mode intercepts every plan via a hook before you see the approval prompt. OpenAI reviews the plan and appends its analysis. You read both, then decide. The manual mode is /codex directly, for when you want a second take on an architecture decision or a plan that feels off but you can’t say why.

The hook is the important part. I didn’t have to change how I work with Claude Code. I just added Codex, and now every plan gets a second set of eyes before I touch it.

One thing worth knowing: Codex is adversarial by nature. Give it a plan and it will find something. That’s not a bug. That’s why it’s useful. If you want unconditional validation, you’re not looking for a second opinion.

Why two models

The analogy I keep coming back to: Claude plays the full game. It knows the codebase, your request, the constraints. It forms a plan based on everything it knows.

Codex walks in at the end with no context fatigue. It hasn’t been reading your files for the past five minutes. It has no investment in the plan Claude came up with. It looks at the plan cold and asks whether it holds up.

They catch different things. Claude tends to miss edge cases in areas it already has a strong model of. Codex spots assumptions Claude buried in a plan without flagging them. That has saved me from bad implementations more than once.

Neither model is smarter than the other in some global sense. But a model that just did all the planning work is not well-positioned to be skeptical about that plan. A separate model with no prior context is.

What it actually catches

The pattern is always the same: Claude fixes the thing you asked it to fix and doesn’t fully trace what else that touches. It’s not wrong about the change. It just isn’t looking at the second and third-order effects.

A few real examples, none of them highly technical:

• Working on our app Helm. I asked Claude to change how we handle a specific user state. The plan looked right. Codex flagged that the change would quietly break two other screens that depended on that state — screens Claude hadn’t mentioned at all. If I’d approved it, users would have hit bugs I wouldn’t have traced back to that one change for a while.

• Building an onboarding flow. Claude’s plan touched the right files but didn’t account for the fact that existing users had already completed some of those steps. Codex caught that the plan treated every user as new. Would have been a confusing experience for anyone who’d been in the app before.

• Vibe coding a podcast episode. I pulled in a bunch of source material and had Claude outline a plan for how the episode would go — structure, talking points, key claims. Codex reviewed the plan and flagged two facts Claude had stated confidently that were either wrong or couldn’t be verified from the sources I’d provided. Not hallucinations in the dramatic sense. Just confident assertions about things that weren’t in the source material. Caught before the episode, not after.

None of these were catastrophic. But they were all things I would have discovered after the fact. That’s the whole point of catching them before you hit approve.

The setup

You need Claude Code already installed and working. If you don’t have it set up yet, start with my Claude Code guide first.

You also need the Codex CLI installed. One command:

npm install -g @openai/codex

On auth: the current official Codex plugin docs say a ChatGPT subscription, including Free, or an OpenAI API key is enough. If Codex is installed but not logged in yet, run codex login.

Install the Codex skill

git clone https://github.com/cathrynlavery/codex-skill ~/.claude/skills/codex

Then in your Claude Code settings, add the skill and the hook that makes it run automatically on every plan:

{
  "skills": ["~/.claude/skills/codex"],
  "hooks": {
    "ExitPlanMode": "codex-review"
  }
}

That’s it. Every time Claude Code finishes a plan, the hook fires before you see the approval prompt. Codex runs, its review appends to the output, and you read both before deciding.

Using /codex manually

The hook covers plans automatically. But I also use /codex directly when I have an architecture question and want a perspective that isn’t Claude’s, or when a plan came back and I want to probe it before approving, or when I’m about to make a decision that will be annoying to reverse.

/codex your question or concern here

It routes directly to Codex without needing to be in plan mode. The output comes back in the same session.

The cost question

If you’re using Codex through your ChatGPT subscription, there’s no additional per-request cost — it’s included in your plan. That’s how I run it.

If you’re routing through an API key, the added cost is minimal in practice. Plans aren’t long and Codex responses are concise. Under $5/month on my usage.

If you want to be selective regardless of how you’re set up, skip the hook and use /codex manually on plans that feel risky. You get most of the benefit without it running on everything.

Why I open-sourced it

I built this for my own workflow. BestSelf moved into software a few years ago, and I’ve been learning to build as a solo founder. I was approving Claude Code plans on instinct with no real way to stress-test them before committing.

Once it was working well enough to trust, open-sourcing felt obvious. It’s a small skill. The idea is the thing, not the code. If it’s useful to other people who work the way I do, that’s reason enough.

The repo is at github.com/cathrynlavery/codex-skill. Pull requests welcome. If you find it useful, a star helps other people find it.

OpenAI now ships an official plugin

OpenAI now ships codex-plugin-cc, an official Codex plugin for Claude Code. As of April 13, 2026, the repo has 14,000+ GitHub stars.

The official install flow is:

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup

It includes /codex:review, /codex:adversarial-review, and a fuller rescue workflow for background delegation.

I’m not surprised they built it. People were already doing this manually. The copy-paste workflow I described at the top of this post was not unique to me. Enough people were routing plans to Codex for a second opinion that it made sense to productize.

If you want the full suite, use the official plugin.

My skill is narrower and does one thing: the ExitPlanMode intercept. If that’s all you want, it still works fine.