Review

Collect critical, honest feedback from all LLMs on an artifact. Push back on weak arguments. Report both consensus findings and unresolved disagreements.

Phase 0: Load consult-llm skill

Load the consult-llm skill before proceeding — it defines the invocation contract (stdin heredoc, flags, output format, multi-turn). Do not call the CLI without loading it first.

Arguments: $ARGUMENTS

Check the arguments for flags:

Mode flags:

• --rounds N → number of critique rounds (default: 2, max: 3)
• --dry-run → skip the final synthesis, just show raw reviews
• --models <list> → comma-separated selectors/model IDs to use as reviewers (default: gemini,openai,anthropic,deepseek)

Strip all flags from arguments to get the review target — a file path, directory, or topic description.

Set variables:

• REVIEWERS: list of model selectors from --models flag, or ["gemini", "openai", "anthropic", "deepseek"] if omitted
• Build the -m flags by repeating -m <selector> for each reviewer

Available Reviewers

Discover which selectors and models are available in this environment:

!`consult-llm models`

Default reviewers (used when no --models flag is given): gemini, openai, anthropic, deepseek — all four selectors that have a configured backend.

Override with --models flag: --models gemini,openai to review with only two, or --models gemini,openai,anthropic for three. Any selector or exact model ID from the list above is accepted.

Critical Rule: No Sycophancy

This skill exists to find problems, not to validate. Instruct every LLM call with:

• Be critical. The goal is to find weaknesses, gaps, and risks — not to praise.
• Disagree openly. If something looks wrong, say so directly. Do not soften criticism to be polite.
• Push back. If another reviewer dismissed a concern too easily, challenge them.
• Unresolved disagreements are fine. Not everything needs consensus. Flag genuine disagreements clearly rather than papering over them.

Phase 1: Read the Target

1. Parse the arguments — determine what to review:

   • If it's a file path: read the file(s)
   • If it's a directory: explore and read key files
   • If it's a topic/description: gather relevant files from the codebase

2. Gather context — use Glob, Grep, Read to understand:

   • The artifact itself (full content)
   • Surrounding code/docs it relates to
   • Existing patterns and conventions

3. Prepare the review brief — a summary of:

   • What is being reviewed (the artifact and its purpose)
   • Relevant context from the codebase
   • Specific aspects to focus on (if the user mentioned any)

Phase 2: Independent Reviews

Have all four LLMs independently review the artifact in parallel using a single CLI call.

Review prompt:

You are a critical reviewer. Your job is to find problems, not to praise.

## What you are reviewing

[Review brief — artifact content and context]

## Your task

Provide a thorough, critical review:

1. **Problems found**: List concrete issues — bugs, logical errors, missing edge cases, architectural flaws, security concerns. Be specific with file paths and line numbers where applicable.
2. **Questionable decisions**: Decisions that might work but deserve scrutiny — are there better alternatives? What are the trade-offs not being considered?
3. **Missing considerations**: What's not addressed that should be? Gaps in error handling, testing, documentation, scalability, maintainability?
4. **Risks**: What could go wrong in production or during maintenance? What assumptions might not hold?
5. **What works well**: (Brief) What's genuinely solid and should be kept as-is?

Rules:
- Be direct and specific. "This could be improved" is useless. "The retry logic on line 45 silently swallows errors, which will make debugging impossible" is useful.
- Do NOT try to be balanced. If you find 10 problems and 1 good thing, report 10 problems and 1 good thing.
- Do NOT soften criticism. If something is bad, say it's bad and explain why.
- Prioritize your findings: critical issues first, minor nits last.

Invoke consult-llm with -m <selector> repeated for each reviewer in REVIEWERS, --task review, and -f <path> for each relevant file. Send the review prompt on stdin via quoted heredoc. All models are queried in parallel in a single call.

The response is in group format:

• Line 1: [thread_id:group_xxx]
• Each model section: ## Model: <id> header, then [model:<id>] [thread_id:<per-model-id>], then the response body

Extract thread IDs: Parse each model's thread_id from the per-model header lines. These are needed for Phase 3 since each model receives the other three's responses.

Present all reviews to the user.