How do I have a second model review small features in a Go microservice before each commit?

Tares runs a challenger session in which the Codex CLI critiques Claude Code’s plan and reviews every commit in your Go microservice. A blocking finding sends Claude back to fix and amend the commit before it moves on. If you disagree with a finding, you waive it. Each small feature gets its own plan critique and per-commit reviews, all recorded on one timeline.

How it works

A challenger session is an ordinary Claude Code session that the Tares plugin has marked. Claude plans and builds as usual, and Codex runs on your laptop, billed to your OpenAI account. Tares never calls Codex and the review never waits on Tares.

• The plan. When you approve the plan and Claude leaves plan mode, the plugin hands the plan to Codex in a read-only sandbox. Codex checks it for gaps, wrong architecture, scope, unhandled risks and missing verification. 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 in its first reply and adjusts, or tells you why it disagrees with a [P1].
• Every commit. After each git commit, the plugin has Codex review that commit. No findings means Claude carries on. [P1] or [P2] findings block Claude, which must 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. The loop is capped at 8 rounds per commit and 5 turn ends per session, after which the findings come back as context. [P3] findings are context only. A Codex timeout, error or inconclusive review never blocks.

For a Go service, a small feature usually means a handful of commits, such as a handler, its tests and a config change. Each one is reviewed on its own, so a problem is caught while the change is still small. By default Codex reviews read-only. If you want it to run the project’s own commands, set the plugin option codex_sandbox to workspace-write or danger-full-access.

Set it up

1. Run Tares and its MCP endpoint, or use a Tares Cloud instance, which serves the endpoint itself. Install the Codex CLI and log in. Set an Anthropic API key for the summarizer under Settings > Model providers or as ANTHROPIC_API_KEY. Tares Cloud instances come with one.

   tares up
   tares mcp --transport streamable-http
   npm install -g @openai/codex
   codex login

2. In Claude Code, install the Tares plugin, version 0.2 or later: /plugin marketplace add glassflow/tares, 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. Open Claude Code in your Go 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.

4. Ask for one small feature in plan mode. Approve the plan, read the critique in Claude’s first reply, then let Claude implement and commit.

5. When a commit comes back blocked, let Claude fix and amend. To disagree with a 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 recorded on Tares as a challenge_waived event.

6. To make commit reviews advisory instead of blocking, set the plugin option challenger_mode to advise. The default is strict.

7. Type /exit to end the session. A Tares agent writes the summary and proposes what the next session in this repo should remember. Nothing reaches memory until you accept it.

If you later want a whole crew building Go tickets, tares factory doctor reads go.mod and tells you whether Claude Code has a Go language server. The Get started page has the details. The full plugin options and event list are in the challenger workflow guide.

What you get

• A critique of the plan before any Go code is written, with findings ranked [P1] to [P3].
• A review of every commit. Blocking findings are fixed inside the same commit, so history stays clean.
• A way out when Codex is wrong: waive the finding and move on, with the waiver on record.
• One timeline per session on the Challenger workflow project. Sessions shows the plan outcome and a Findings (N) or Pass badge for each reviewed commit. Clicking a session reads the Claude and Codex exchange as one thread.
• A summary with five sections, including Memory proposals: up to five sentences about the repo that you accept or reject. Accepted ones are handed to Claude at the start of the next session in that repo.
• Predictable cost. A session with a plan and three commits is typically five to eight Codex runs, billed by OpenAI.

When something else fits

• If the feature is large or spans several repos, a crew of Claude Code sessions with a reviewer on every pull request fits better. Start from Get started. The crew can also have a second model check every commit.
• If you want review comments without any blocking, set challenger_mode to advise, or use the waive command only when a finding is wrong.

Related