Plan-tango: How I Stopped Manually Shuttling Plans Between Claude Code and Codex

I got GPT Pro mostly for the Pro model, Codex being included was a nice bonus — plus OpenAI was offering double limits for Codex on Pro subscriptions in May. But I won't lie, the idea of slightly reducing vendor lock-in and my dependency on Anthropic also appealed to me.

To my surprise, the most useful and frequently used scenario so far has been cross-reviewing development plans. You take the finished PLAN.md that Claude Code writes during the planning phase, drop it into Codex, and ask: "find gaps, don't write code". You get a list of comments, take it back to Claude Code. Rinse and repeat.

Why a second model spots what the plan's author misses

This is the well-known LLM-as-judge pattern: one model evaluates the output of another. Even a fresh Claude session on the same model will spot something. But review using a different model works noticeably better. Codex has different attention focuses, different intuition about edge cases, different concerns. If Claude wrote the plan on an optimistic high ("we can quickly add this hook right now"), Codex generally doesn't share the author's mood.

Based on my experience, the types of findings repeat: underestimated edge cases, careless assumptions about library APIs, spots where Claude itself honestly wrote "a separate step might be needed" in the plan — and by the final version of the plan, that step has somehow disappeared.

What I didn't expect: the reviewer wants to rewrite the plan as code

I once ran one plan through as many as 15 iterations. At some point I read through what Codex wrote in its latest review more carefully — and I saw where those 15 iterations were coming from.

If you ask an LLM "what's wrong with this plan?", it by default drifts towards "let me just rewrite your plan the way it should look". And "how it should look" in its understanding is as close as possible to ready-made code. Pseudocode, ready code blocks directly in the plan, sometimes detailed step-by-step instructions at the level of "and add this check here". As iterations go on, the plan moves from "here's an approximate route and three forks where you need to think" to "here's a line-by-line specification, the executing agent just has to parse it".

This sounds like an improvement — until you think about what it means next.

Next, a different agent will write the code. If the plan has already turned into line-by-line pseudocode, this agent has no room left for decisions. The micro-choices it could have made based on the code context have already been made for it by the plan reviewer, who did not have this context at the time of the critique.

For a while, I added a manual prompt "don't turn it into code, leave decisions to the writer agent" and pasted it into Codex every iteration. It works, but it becomes a separate ritual. By the third or fourth iteration, you forget — and the plan drifts back to pseudocode.

What broke completely in the end: tabs

There's another annoying thing in manual mode — lost context between rounds. The plan usually converges in 4–6 iterations, but not in a row: you get distracted by other things between them. And in Codex's interface, there is no send time next to messages.

You come back to the plan an hour or two later and don't remember: have you already copied the last Codex feedback into Claude or not? Is the plan version you have in Claude already after the last Codex iteration or before?

Mess with tabs — that's the main thing I wanted to get rid of. It became clear: it's easier to automate.

Where plan-tango came from

The idea was obvious: let Claude Code call Codex on command as many times as needed.

Official Codex plugin for Claude Code is a useful tool, but it can't do plan reviews with automatic iterations out of the box. It can complete a task for you, do code review of just-written code, and other useful things. It lacks the "send plan → collect feedback → make edits → send again, repeat until it converges" loop.

I wrote the first version of plan-tango on top of this plugin just to get the loop I needed. Basic scenarios worked. Then I hit a snag: I wanted to run Codex in fast mode (1.5x faster than normal, but it uses noticeably more limits, available as part of the standard subscription). It was impossible to pass this parameter through the plugin.

2 minutes in fast mode vs 3 in normal mode seems like a small difference. But over 4–6 iterations, the gap adds up. Plus, I still don't hit the weekly ChatGPT limit anyway — so why not get free acceleration?

So I rewrote plan-tango: instead of making calls via the Codex plugin, it now calls the Codex CLI directly. One less dependency, and more control over how Codex is invoked.

How it works now

Plan-tango runs in a single Claude Code window and is launched with the /plan-tango:tango command on the current plan. Then the loop is automatic: Codex review → edits to the plan → Codex review → edits → repeat until the plan converges (or until it hits the hard cap).

By default, it runs up to 6 iterations, with a hard cap of 12 — this is a sanity limiter, since Codex will always find something to criticize, and without a limit the loop could be infinite. Moreover, by default the plugin considers the plan approved if there are no critical or major findings (minor and nit findings are considered passing). The number of iterations and passing score are easily configurable.

Fast mode is enabled with the --fast flag and simply changes Codex's operating speed — priority service tier, 1.5x faster. It's enabled by default in my config.

The default prompt in the plugin asks the reviewer to "not write code, leave solutions to the writer agent". This is an attempt via prompt to keep the reviewer from the very drift into pseudocode I talked about earlier — it works in most cases, but it's still just a prompt, not a strict guarantee. If it doesn't suit you, the behavior is configurable.

The rest (severity-aware auto-stop, snapshots at each round, protection against the plan file being modified concurrently) is present, but I won't describe it here. If you're interested — check the README on GitHub.

The plugin and installation instructions: github.com/egsok/plan-tango.

MIT license — take it, fork it, customize it for your needs. I'll be grateful for stars!

Summary

Cross-model plan review has become a permanent part of my workflow. The idea itself is simple — it's half a page of code: one model writes the plan, the other one tears it apart.

I've always preferred spending more time on planning than catching bugs and reworking things later. Plan-tango just lets you fully delegate this part for medium-complexity tasks without manual involvement: formulate the requirements, launch it, go do your other things, come back to a ready-made plan.

The pattern itself works perfectly fine without the plugin too. First try it manually in another window. And if it works for you — grab plan-tango.

Original post on my blog: egorsokolov.ru/ai/plan-tango