Want your plan peer-reviewed before you write a line of code?
Four frontier models, checked against your real codebase.

In your editor

You already do this, for the plans humans write. Design docs go to peer review. RFCs get comments. Architecture meetings happen before the code lands. Plans written by AI agents usually skip the same scrutiny: the agent makes the plan, you skim it, the agent starts coding. Plan Review puts the panel back in front of the plan.

What Plan Review does

Plan Review is a slash-command skill installed by twira init. Seven steps. (1) Find the plan, auto-picked from this session’s plan-mode if you are in one, otherwise asks. (2) Extract every file path, symbol name, module reference, and external library the plan mentions. (3) Codebase discovery, indexed search + read + blast_radius on the extracted terms to find existing code the plan overlaps with. (4) Launch multi-model team review with the plan + the codebase findings bundled into every reviewer’s prompt; runs in the background with live progress streamed to you. (5) Independent synthesis, the agent reads the team output, cross-references its own Step-3 findings, and forms its own judgement. (6) Structured report, overall verdict, strengths, critical issues, recommended improvements, code to reuse, missing considerations. (7) You decide, every plan modification waits for your sign-off before the file is touched.

How it actually works

The cheapest place to catch an architectural mistake is before any code has been written. Plan Review is the Twira workflow that takes an implementation plan, the one you just produced in plan-mode, or any markdown file describing a proposed change, and runs it through multi-model peer review against your actual codebase. The reviewers do not just judge the plan in isolation; they look up every symbol and file path it references, find existing code that overlaps, surface reusable functions the plan ignored, flag missing considerations, and challenge architectural choices. Then the agent presents its own independent analysis for you to approve before any plan modifications happen.

Triggered by a slash command. Like Code Review, this is a Skill, not an MCP tool. It lives at .claude/skills/plan-review/SKILL.md inside your project and at ~/.claude/skills/plan-review/ globally so you can use it in any repo. Triggered by /plan-review or any of the natural-language phrases, "review the plan", "review my plan", "peer review this plan", "analyse the plan", "check the plan", "get the team to review", "multi-model review". The agent walks the workflow; you watch it work and approve the changes at the end.

Seven-step workflow. (1) Find the plan. Either the user gave a path, or the plan came from this session’s plan-mode (the agent uses the file path it remembers), or as a last resort the agent lists the five most-recent plan files in ~/.claude/plans/ and asks you to pick. The skill is explicit: never auto-select when the plan did not come from this session. (2) Extract key terms. The agent reads the plan in full and pulls out every file path, function name, class name, type name, module reference, MCP tool name, REST endpoint, CLI command, and external library it mentions. (3) Codebase discovery. For each extracted term, the agent runs indexed search (symbol mode for symbol names, content mode for usage patterns) and read for any file path mentioned in the plan; for the top five most important files, it also runs impact with action: blast_radius to understand what depends on them. The skill caps this at 10–15 search calls total, focused on the most important terms, not exhaustive. (4) Launch team review via CLI. The plan plus the codebase-overlap findings are written to .claude/tmp/review-topic.txt and passed to twira team review --topic-file ... --preset pro --synthesise running in the background; the skill polls every 20–30 seconds and streams progress to you so you never go more than 30 seconds without an update. (5) Independent synthesis. After the team review completes, the agent reads the synthesis markdown, cross-references it with its own Step-3 discoveries, and forms an independent judgement, which findings are valid, which are noise, which contradictions exist between reviewers, what the team missed. (6) Present to you. A structured report, overall assessment, strengths, critical issues, recommended improvements, existing code to reuse, missing considerations, in a fixed shape every time. (7) You decide. The agent waits. If you approve specific changes, the agent edits the plan file via the Edit tool and confirms what was modified. If you reject a change, it stays out. Never modifies the plan without your explicit approval.

Catches the four classes of mistake that hurt most. Reusable code being re-invented, the plan describes building X, but X already exists in src/utils/. The codebase-discovery step finds it before any code is written. Missing considerations, the plan describes the happy path but skips error handling, concurrency, the migration of existing data, security implications, or test coverage. Architectural issues, the plan introduces a pattern that contradicts how the rest of the codebase works, or adds a layer that does not earn its place. Implementation traps, the plan says "call function Y" but Y has constraints the plan ignores (rate limits, idempotency requirements, expected error shapes). Each of these is hard to spot in your own plan because the planner already concluded the path was right; multiple fresh perspectives spot them in minutes.

Why it is its own workflow and not just "team review on the plan file". Two reasons. First, the codebase-discovery pre-step is critical. A team review on the plan in isolation produces good high-level critique; a team review on the plan plus the relevant existing code produces actionable, specific critique that ties every finding to a concrete file path. Second, the independent-synthesis step at the end matters. Multi-model output without a synthesis pass becomes noise; the agent reading every finding, cross-referencing its own discovery work, and presenting its own verdict is what turns the review into a clear set of "here are the three changes I would make, do you approve?" prompts.

Four frontier models in the room, one per provider. The skill uses the pro preset on the underlying team tool, which selects one model from each of the four providers (Anthropic, OpenAI, Google, xAI). That diversity is the whole point, different training data, different blind spots, so a mistake one model rationalises is one the other three are more likely to challenge. The --synthesise flag tells the underlying CLI to run a final reconciliation pass so the agent reads a single coherent verdict, not four parallel monologues.

You approve every plan modification, nothing is silent. After synthesis, the agent presents the proposed modifications and waits for your sign-off before changing the plan file. If you reject a proposed change, it stays out. If you accept, it goes in via the Edit tool with confirmation of exactly what was changed. The skill is explicit: "Never modify the plan file without explicit user approval." This keeps you in the loop on the document that drives the rest of the work.

Best used with plan-mode. Most useful right after you have produced a plan in your AI agent’s plan-mode and want a sanity check before implementation begins. Also valuable for any standalone plan-style document, a design doc, an RFC, a migration proposal, anywhere a written plan is the input to real engineering work. About 15 minutes upfront, and almost always cheaper than the rebuild the unreviewed plan would have triggered.

Tier is Pro. Plan Review uses team review under the hood, which is gated by the multi_agent feature flag. The skill itself is installed on every install; the actual run requires Pro because it spawns multiple frontier-model reviewers. A Free user can still see /plan-review listed and read the skill text, but invoking it returns the multi_agent upgrade prompt.

Setup is zero. twira init installs the skill automatically to .claude/skills/plan-review/ inside the project and to ~/.claude/skills/plan-review/ globally. Trigger with /plan-review or any of the natural-language phrases. Plan files conventionally live at ~/.claude/plans/<name>.md when produced via plan-mode; the skill finds them automatically. Requires the same provider CLIs as Code Review (claude, codex, gemini, the xAI client), the first run prompts for any missing.