Want AI to review your code and find issues before you ship?
How about 4 different models at once?

In your editor

You already do this, for code reviewed by humans. Open a PR, the reviewer reads it, files comments, you fix or push back, eventually it merges. Code reviews on human commits are standard practice. On AI-written commits, the same rigour rarely happens, the agent shipped it, you skimmed it, you trusted it.

What Code Review does

Code Review is a slash-command skill installed by `twira init`. Type `/code-review` (or *"review the last commit"*, or *"review commit abc1234"*) in your AI harness; the skill walks the workflow. It picks the commit, runs Diagnose + blast_radius on the changed files as pre-analysis, spawns multiple frontier models in parallel via the underlying `team review` MCP tool (each with a different review lens, logic, contracts, architecture, security), then drives the synthesis: four verdicts per finding (confirmed · disputed · noted · dismissed), enforced no-deferral policy (every confirmed finding either fixed in-session or written as a masterplan task), and a structured per-commit report you can attach to the PR description.

How it actually works

Code Review is the Twira workflow that turns "a multi-model code review on the last commit" from a 90-minute manual orchestration into a single slash command. You type /code-review in your AI agent; the skill orchestrates everything from there, picks the commit, runs deterministic pre-analysis on the changed files, spawns multiple frontier models in parallel (each with a different review lens), waits for them to complete, then walks the agent through a strict no-deferral synthesis that ends with every confirmed finding either fixed in this session or tracked as a concrete task in the masterplan.

Triggered by a slash command, not by an MCP call. This is a Skill, not an MCP tool, it lives at .claude/skills/code-review/SKILL.md inside your project and at ~/.claude/skills/code-review/ globally so you can use it in any project. When you type /code-review in Claude Code, Cursor, or any other harness that supports skills, the skill text becomes the agent’s instructions for the next turn: which commit to review, how to invoke the underlying CLI, how to interpret the JSON output, what verdicts to record, what format to present back to you. Trigger phrases are flexible, "review my code", "review the last commit", "review commit abc1234", "review abc1234..def5678", "review all pending" all kick off the same workflow.

Different lenses per reviewer is the whole point. A single AI reviewer tends to catch one class of issue and miss others. Code Review spawns multiple reviewers in parallel, each instructed to read the commit through a specific lens: logic (correctness, edge cases, off-by-one, race conditions), api_contract (type safety, error handling, missing validation), architecture (pattern consistency, design fit), and security (vulnerabilities, unsafe patterns, invariant violations). The lenses are distributed across the available models, with four or more models each gets one lens; with three, the first gets two and the rest get one; with two, each gets two; with one, that model gets all four. Each reviewer returns structured JSON findings with severity, file, line numbers, and a description. The agent then synthesises across all of them using its own full project context, which catches a fifth thing: false positives one reviewer raised that the others (or the agent itself) would correctly dispute.

Four-verdict synthesis, confirmed, disputed, noted, dismissed. After the reviewers finish, the agent reads the referenced file and line for each finding and classifies it: confirmed (real issue, agent agrees), disputed (reviewer flagged it but the agent has context that contradicts, the rationale is recorded), noted (plausible but uncertain, flagged for human review), dismissed (false positive with a brief reason). Verdicts are recorded against the finding ID via twira review verdict <id> <verdict> --reason "..." so the next reviewer of the same commit sees the prior decision history rather than re-litigating it.

No-deferral policy, enforced in the skill text, not optional. The skill instructions are explicit: every confirmed finding MUST be resolved one of two ways, fix it immediately in this session, or create a tracked task via masterplan with the exact fix described, file path, line numbers, and clear instructions. The skill bans phrases like "we should look at this later" or "noted for future consideration" without a concrete task. A multi-model code review is only valuable if its findings actually become work; without the deferral ban, review findings rot in chat history.

Pre-analysis is bundled into every reviewer prompt. Before the reviewers see the diff, Twira runs Diagnose against the changed files (65 deterministic detectors across four profiles, Bug, Health, Security, DOM), computes the blast radius (every dependent symbol the change reaches), and pulls a RED / YELLOW / GREEN risk rating from git history for each touched file. All of that is stitched into the prompt every reviewer receives. So the reviewer is not staring at a raw diff, they see "this commit touches files X and Y, has these existing detector findings, blast-radius reaches N callers, risk rating is RED on file X." Better context produces better reviews.

Structured report back to you, every commit gets the same shape. The skill ends the workflow with a per-commit report: an overall verdict (clean / minor issues / issues found / critical issues), the model list, confirmed issues with action (fixed in session or task ID), noted items, disputed items with rationale, dismissed items with reason. Same shape every time. Easy to skim, easy to attach to a PR description, easy to write a script around if you want to enforce policy at the PR level.

Multi-commit batching, review the whole branch at once. Pass a range (abc1234..def5678) or --all-pending and the skill walks every commit in sequence, presenting each report and asking you whether to continue before moving on. Useful for weekly review cadence, pre-merge sweeps on feature branches, or the "I have not reviewed in three days, what is in the queue?" check. The backfill action goes one step further, it picks up every unreviewed commit up to a configurable age limit and reviews them in one go.

Underlying primitives, the MCP review tool tracks the bookkeeping. The skill drives the workflow; the underlying review tool tracks the state. Three MCP actions on the review tool: status (pending vs completed counts plus the latest pending commits), findings (the JSON output for a specific commit), record (mark the current HEAD as a candidate for review later, e.g. at end-of-session). The corresponding CLI surface (twira review) has more, record / run / status / backfill / verdict / show / reset, for cases where the skill is not the right driver. The run action is CLI-only because it is long-running and would block the MCP thread.

Auto-recording via the post-commit hook. When Twira is installed in a repository, the post-commit git hook records every new commit into the review queue automatically. The review tool’s status action shows the queue; the skill processes it. You do not have to remember to record commits, they accumulate, and any time you type /code-review the skill picks up the next pending one. Use twira review status (or the MCP status action) to see what is waiting.

Tier is Pro. Multi-model code review is gated by the code_review feature flag. The skill itself is installed on every install; the actual twira review run execution requires Pro because it spawns paid frontier-model reviewers under the hood. Status and findings queries on existing reviews also flow through the Pro gate, so a downgrade from Pro stops further reviews running but does not delete past data.

Setup is zero. twira init installs the skill automatically to .claude/skills/code-review/ inside the project and to ~/.claude/skills/code-review/ globally. Trigger with /code-review or any of the natural-language phrases. The first run prompts for any provider CLIs missing on the system (it shells out to claude, codex, gemini, and the xAI client). The reviewer timeout is 5 minutes per reviewer; reviewers run in parallel, so the wall-clock per commit matches the slowest of them, not the sum.

What it isn’t

• ·Triggered by slash command, not callable from the agent loop directly. The agent runs the underlying review CLI indirectly via the skill text.
• ·Pro tier. The orchestration is included; the actual token costs are billed across the providers you invoke (your keys, your bills).
• ·Requires the underlying provider CLIs installed, claude, codex, gemini, the xAI client. The first run prompts for any missing CLI.
• ·Typically 2–5 minutes per commit. Reviewers run in parallel with a 5-minute per-reviewer timeout, so wall-clock matches the slowest reviewer. Multi-commit "review all pending" walks the workflow per commit sequentially.