AgentLayer▸docs
Engineering

Second-model review

Put a different model on anything you made, a proposal, a plan, a document, or code. It documents what it finds on one dossier; your agent verifies every finding, fixes the real ones, and hands back the next round.

A model reviewing its own work shares its own blind spots. A different model reading it cold finds what the author cannot: the assumptions baked into the prose, the plan, or the commit messages. adversarial-review puts that second model on anything you made: a proposal, a plan or spec, a policy draft, a report, a skill, or code. You don't need to be technical to use it, and it needs no GitHub access unless the target is a pull request.

A second model's edits may not be something you ship yet, so the skill splits the work by trust. The reviewer documents: it reads a brief, hunts, and writes findings. The implementer verifies each finding against the work, fixes what is real, and commits where the target is committed code. Both are the same agent launched from the same home on different models or hosts, so the dossier names the two sides by role, never by model.

What you can review

Any of your own work. The brief lists numbered claims for the reviewer to falsify, and where they come from depends on the target:

TargetThe claims come fromFixes land
A plan, spec, skill, or document, by pathThe text's own assertions, since every instruction, name, and number in it is acted on literally by whoever reads it nextIn the file, for you to keep or discard
Code: a PR, a branch, or several repositories moving togetherThe commit messages. The reviewer also hunts for structure (a reframing that deletes whole branches, a pass-through layer, a hollow test), and no findings is a valid resultAs commits on your branch
The uncommitted working tree of a repositoryThe task and the plan it implementsIn the tree, uncommitted

A teammate's PR is a different job: the engineer skill's PR review.

Run a round

Brief

Ask in plain words, or name the skill and the target:

you  > get a second model to check this proposal
you  > adversarial-review reports/plans/2026-09-23-1200-billing-spec.md
you  > adversarial-review brief                      (current branch against the default branch)
you  > adversarial-review 142                        (a PR, checked out locally)
you  > adversarial-review ~/Developer/app:main..HEAD ~/Developer/engine:main..HEAD
you  > adversarial-review --working-tree             (the uncommitted work in the code path)

The implementer writes the dossier and hands you one line.

Hand off

Paste the line into the reviewer's session, launched from the same home so the file is writable:

Read <dossier path> and do what "Brief for the reviewer" says. Write your findings into that same file under the empty heading "## Round 3 — Findings (Reviewer)". Change nothing else in it and nothing in the repositories or the files under review. When you are done, reply with only the path of the file.

While the round is out, the target stays where the brief points. The reviewer modifies nothing in the repositories or the files under review; read-only checks such as a build or a test run are welcome and reported as what ran.

Verify

you  > adversarial-review verify                     (after the reviewer replies with the path)

The implementer runs every finding through the same verification rubric the PR review uses, then:

  • fixes the confirmed ones in the smallest correct change and runs the repo's build and tests;
  • commits one commit per finding group on your branch, and never pushes;
  • defers a confirmed edge case whose only fix is another guard, and offers it to you instead;
  • rejects the wrong ones with a receipt, and marks pre-existing ones inherited;
  • writes the disposition, updates the Ledger, re-cuts the brief at the new heads, and hands you the next round's line.

On a working tree or a document the fixes land in place with a suggested commit message each, and you commit. A round with nothing confirmed and nothing open closes the loop.

The dossier

The dossier is the whole state, one file per target:

  • A Brief the implementer rewrites every round.
  • A Ledger with one row per finding across rounds.
  • A Findings and Disposition pair per round.

The brief is self-contained: the reviewer needs nothing else from the home.

Every fix the implementer lands becomes a new claim in the next round's brief, because a fix written under review pressure is as suspect as the original work.

Flags

Five flags add reviewers, change the target or where fixes land, or name the dossier.

What it never does

  • Never posts to GitHub or any chat surface. You carry the handoff line between sessions.
  • Never pushes. For code it commits on your own branch only, and only when you asked it to verify; a document is edited in place and never committed.
  • Never puts private material in a brief: nothing from the agent home's memory or notes, no secrets, no customer identifiers.

On this page