How do I have a second model review bug fixes in a Go microservice before each commit?

Tares runs a challenger session in which Claude Code writes your bug fixes and the OpenAI Codex CLI reviews the plan and every commit before Claude moves on. A blocking finding sends Claude back to fix the problem and amend the same commit, and you can waive a finding you disagree with. Nothing here is specific to Go, so it works in your microservice repo as it is.

How it works

In a challenger session, Claude Code plans and builds as usual. Codex runs on your laptop, against your own OpenAI account, and Tares never calls it. Tares records the exchange.

• Plan critique. When you approve the plan and Claude leaves plan mode, the plugin hands the plan to Codex in a read-only sandbox. Codex tags each finding [P1] (the plan fails as written), [P2] (will cause rework) or [P3] (advice). The critique reaches Claude right after your approval, and Claude adjusts. A plan critique never blocks. Only [P1] counts as blocking on a plan, and Claude then revises or tells you why it disagrees.
• Commit review. After every git commit, the plugin has Codex review that commit. With no findings, Claude carries on.
• Blocking findings. With [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, Claude makes a new commit instead. The amended commit is reviewed again as round 2, and so on until Codex is satisfied. The loop is capped at 8 rounds per commit and 5 turn ends per session. After that, the findings come back as context.
• Advice only. [P3] findings are context and never block. A Codex timeout, error or inconclusive review never blocks either.

Review state, fix-loop counters, review history and waivers live under the repository’s .git/ directory.

Set it up

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

   uv tool install tares     # or: brew install glassflow/tap/tares
   tares up
   tares mcp --transport streamable-http

2. In Claude Code, install the Tares plugin, version 0.2 or later, with /plugin marketplace add glassflow/tares and then /plugin install tares@tares. The install asks for the Tares URL, the MCP endpoint and, on a secured instance, a read + ingest API key.

3. Install the Codex CLI and log in. Codex is billed to your OpenAI account:

   npm install -g @openai/codex
   codex login

4. Set an Anthropic API key for the summarizer, under Settings > Model providers or as ANTHROPIC_API_KEY. Tares Cloud instances come with one.

5. Open Claude Code in your Go microservice repo and say “make this a challenger session”, or type /tares:challenger. The first marked session creates the Challenger workflow project on Tares by itself.

6. Ask for the bug fix in plan mode, approve the plan, then let Claude implement and commit. Each commit is reviewed before Claude moves on.

7. If you disagree with a blocking finding, run /tares:challenger-waive. It lists the blocking findings and waives one or all. The waiver is remembered for that finding on later rounds and reaches Tares as a challenge_waived event.

To make commit reviews advisory, set the plugin option challenger_mode to advise. The default is strict. By default Codex runs read-only. If it needs to run your project’s commands to judge a fix, set codex_sandbox to workspace-write, or to danger-full-access if that is not enough.

The challenger workflow guide covers every option. If you have not used the Tares CLI before, start with Get started.

What you get

• Each bug fix is reviewed by a second model before Claude moves on, and blocking problems are fixed in the same commit instead of piling up as follow-ups.
• The plan is critiqued before any code is written, so gaps, scope problems and missing verification show up early.
• You keep the final say. Waive any finding you disagree with, or switch commits to advisory mode.
• Tares keeps one timeline per session. Open the project’s Sessions list to see the plan outcome and one badge per reviewed commit, Findings (N) or Pass. Click a session to read the Claude and Codex exchange as one thread.
• When you /exit, a Tares agent writes a summary covering what was built, what Codex caught in each commit, cost, and up to five Memory proposals. You accept or reject each one, and accepted ones are handed to Claude at the start of the next session in that repo.
• Review runs on your laptop and never wait on Tares. If Tares is down or slow, a review is not blocked, and the plugin retries shipping on the next hook.
• Expect cost and time: Codex takes 30 to 90 seconds on a plan, and a session with a plan and three commits is typically five to eight Codex runs, billed by OpenAI.

When something else fits

• If you do not want a second model gating each commit, use a normal Claude Code session, or set challenger_mode to advise so commit findings are context only.
• If a whole project needs to be built by a crew of sessions, with a reviewer holding every pull request to a fixed bar, the software factory for Claude Code in Get started fits better. It can also have a second model check every commit.

Related