How do I have a second model review docs updates in a Python backend before each commit?

Tares lets the Codex CLI review every commit Claude Code makes, so a second model checks your docs updates in a Python backend before you move on. Codex also critiques the plan when Claude leaves plan mode. A blocking finding sends Claude back to fix and amend the same commit, and you can waive a finding you disagree with.

How it works

You turn on a challenger session in Claude Code. Claude plans and builds as usual, and Codex runs on your laptop next to it. Tares records the exchange and never calls Codex. The full setup is in the challenger workflow guide.

• The plan is critiqued. When you approve the plan and Claude leaves plan mode, Codex reviews it in a read-only sandbox. It tags each finding [P1] (the plan fails as written), [P2] (will cause rework) or [P3] (advice). A plan critique never blocks. Claude mentions the findings, adjusts, or tells you why it disagrees.
• Every commit is reviewed. After each git commit, the plugin has Codex review that commit. A commit that updates docs in your Python backend goes through the same review as any other.
• Blocking findings send Claude back. On [P1] or [P2] findings, Claude is blocked and told to fix them and fold the fix into the same commit with git commit --amend. If the reviewed commit is already on a remote, it makes a new commit instead. The amended commit is reviewed again as round 2, and so on until Codex is satisfied.
• Limits on the loop. The loop stops at 8 rounds per commit and 5 turn ends per session. After that the findings come back as context.
• Nothing else blocks. [P3] findings, a Codex timeout, an error or an inconclusive review never block.

Set it up

1. Run Tares and its MCP endpoint, or use a Tares Cloud instance, which serves the endpoint itself. Locally, use two terminals:

tares up
tares mcp --transport streamable-http

2. Install the Tares plugin for Claude Code, version 0.2 or later. The install asks for the Tares URL, the MCP endpoint and, on a secured instance, a read + ingest API key.

/plugin marketplace add glassflow/tares
/plugin install tares@tares

3. Install the Codex CLI on your laptop and log in to it. Codex runs there and is billed to your OpenAI account.
4. Set an Anthropic API key under Settings > Model providers or as ANTHROPIC_API_KEY. The summarizer at the end of the session uses it, and Tares Cloud instances come with one.
5. Start Claude Code in your Python backend repo and say “make this a challenger session”, or type /tares:challenger. The first marked session creates the Challenger workflow project on Tares for you.
6. Ask for your docs updates in plan mode, approve the plan, and let Claude commit. Each commit is reviewed before Claude moves on.
7. Waive a finding you disagree with. Type /tares:challenger-waive. It lists the blocking findings and waives one or all of them. The waiver is remembered for that finding on later rounds and shipped to Tares as a challenge_waived event.
8. Optional: set the plugin option challenger_mode to advise so commit findings never block. The default is strict. If Codex needs to run your project’s commands, set codex_sandbox to workspace-write or danger-full-access. The default is read-only.

Type /tares:challenger off to turn the challenger off for the rest of the session. If you run a crew instead of a single session, Get started shows how to enable a second-model check on every commit when you answer the crew settings in tares factory crew up.

What you get

• A second model checks the plan and each commit before the work moves on, so a weak docs update is caught while the commit can still be amended.
• Blocking findings turn into a fix loop. Claude amends the commit and Codex reviews it again, with no copy and paste from you.
• You stay in control. Waiving a finding stops that finding from blocking later rounds.
• One timeline per session on Tares. The Claude and Codex exchange reads as one thread under Sessions on the project page. Each commit gets a Findings (N) or Pass badge. challenge_plan, challenge_commit and challenge_waived events record what happened.
• A summary when you /exit. The challenger_summarizer agent writes what was asked and built, what Codex caught in each commit, the cost, and up to five Memory proposals. Accept one and the next Claude Code session in that repo starts with it as context.
• Local review state. The reviews run in your Claude Code hooks, and a Tares that is down or slow never blocks them. Review history and waivers live under the repository’s .git/.
• A rough cost picture. A session with a plan and three commits is typically five to eight Codex runs, billed by OpenAI.

When something else fits

• If you want Codex to advise only, use challenger_mode set to advise. Commits are then never blocked.
• If you want a whole project built by a crew with a reviewer holding every pull request to a fixed bar, see Get started for the software factory for Claude Code.
• If you do not want to use an OpenAI account, the challenger is not the right fit, because it relies on the Codex CLI.

Related