How Autoreview Turns AI Code Review into an Unskippable Quality Gate

What is Autoreview?

Autoreview is an AI‑powered skill that runs automatically on code changes before a pull request is merged. It continuously reviews, reports, and fixes issues until the codebase is clean, after which a human reviewer inspects a final report.

Problems Autoreview Solves

Volume: agents can generate thousands of lines of code in minutes, overwhelming manual reviewers.

Blind‑spot: agents are good at writing code but poor at spotting their own bugs, often responding that the code "looks fine".

Boredom: human reviewers can miss simple mistakes (e.g., != becoming ==) when attention drifts.

Four Design Principles

Review as a Final Gate, Not an Approval System

Autoreview does not decide whether a PR can be merged; it only discovers and reports problems. After a problem is found, the agent may attempt an automatic fix within strict guardrails (read‑only code path verification, small‑fix priority, batch fixing of similar bugs). If the fix violates guardrails, the process pauses for human input.

Scope Governor: Review Only This PR, Not the Whole Project

Before reviewing, Autoreview locks a scope baseline consisting of the original requirement, target branch, expected behavior, ownership boundary, changed files, and non‑test line count. Findings are classified into three categories:

In‑scope blocker : a problem within the same ownership boundary that does not change the task contract.

Follow‑up : a real issue that belongs to a related bug class, module, or broader reinforcement work.

Stop‑and‑escalate : requires new agreements, configurations, APIs, or design changes beyond the original scope.

Five stop conditions trigger a pause:

The change has turned into an architectural, protocol, data‑migration, or release‑process change.

The number of changed files or non‑test lines has more than doubled without explicit scope expansion.

Two rounds of fixes have not converged.

The optimal fix is to define a contract rather than add ad‑hoc inference.

Fixing the current finding would make the PR describe a different behavior or ownership.

Multi‑Engine Review: A Personal Review Committee

Autoreview supports seven engines: Codex (default, gpt‑5.5), Claude (claude‑fable‑5), Pi, Droid, Copilot, Cursor, and OpenCode.

Example commands:

"$AUTOREVIEW" --engine claude --model claude-fable-5 --thinking max

Panel (Codex + Claude): "$AUTOREVIEW" --panel Custom reviewers: "$AUTOREVIEW" --reviewers codex,claude,pi All seven engines together: "$AUTOREVIEW" --reviewers all Trade‑offs:

Cost: each engine adds token expense; multi‑reviewer panels are opt‑in.

Signal‑to‑noise: different engines excel at different aspects (Codex best at structured review, Claude stronger on context and design intent).

Availability: models may be queued; the skill advises not to switch engines as a retry reason.

Engine Isolation

Each engine runs in an isolated sandbox to prevent repository configuration from contaminating the reviewer.

Codex : exec --ignore-user-config --ignore-rules + read‑only sandbox + project_doc_max_bytes=0 Claude : --safe-mode --setting-sources user --strict-mcp-config + MCP fully disabled + explicit tool whitelist

Pi :

--no-approve --no-session --no-context-files --no-extensions --no-skills

OpenCode : neutral temporary directory, --pure --format json, deny‑by‑default permissions, environment‑variable disabled configs

Cursor : print mode, stdin prompt, temporary read‑only permissions, fail‑closed on project config/MCP

Workflow: From Local to PR to Release Branch

Local Development (pre‑commit)

Three common modes:

"$AUTOREVIEW" --mode local

"$AUTOREVIEW" --mode commit --commit HEAD

"$AUTOREVIEW" --mode branch --base origin/main

Parallel testing can be combined: "$AUTOREVIEW" --parallel-tests "go test ./..." If a review triggers a fix, tests must be rerun because the previous results are no longer valid.

Release‑Branch Rules

On release, beta, stable, hotfix, signing, notarization, or appcast branches, Autoreview switches to a frozen mode with stricter constraints:

Only fix release‑blocking items (crashes, data loss, install/upgrade failures, confirmed security bugs).

No new behavior, configuration, protocol, migration, or documentation.

Non‑blocking findings become follow‑up items for the main branch.

Real design problems that are not blocking are opened as issues/PRs rather than fixed.

Long‑Running Reviews

Reviews may run for hours because the loop is: review → fix → new context → review again. Each iteration can take up to 30 minutes. Autoreview emits a heartbeat line such as review still running: ... elapsed=... pid=... to indicate healthy progress. The process aborts only after several missed heartbeats, a 30‑minute silence, or an explicit failure.

Context Efficiency: Avoid Double Token Consumption

Autoreview follows a "run once, collect results, summarize" principle. It builds a single large bundle, runs a structured review, and aggregates the output, avoiding exponential token costs that arise from nested reviewer calls. Nested reviews are explicitly prohibited in the skill definition.

Final Report

List of review commands executed.

List of tests and proofs run.

Each accepted or rejected finding accompanied by a one‑sentence rationale.

Final clean result line: autoreview clean: no accepted/actionable findings reported. The report must be generated by the last helper run with a zero exit code; otherwise the "clean" label is invalid.