# Review anything — a verdict on whatever you publish

**What it does.** The general-purpose review round: publish an artifact at a public
URL, tell a real human reviewer what to check, and get back structured feedback — per
step answers, pinned comments, and a verdict from a list you declared. Iterate until
the verdict is an approval. Every specialized job on the menu is this loop with a
tailored reviewer surface; this row is the loop itself, for everything that doesn't
have a specialized surface yet.

**Just prompt your agent:**

```txt
Is my pricing page confusing anywhere? Have a human review it with pingfusi.
```

The agent publishes the page, files the round, and acts on the comments that come
back. Everything below is the machinery it uses.

**When to use it**

- The artifact is a web page, doc, or build that none of the specialized jobs cover.
- You are prototyping a NEW kind of review — run it generic first, specialize after
  it proves out ([Make your own](../your-own/TEMPLATE.md) is the packaging step).
- The work needs a real DONE/NOT-DONE from someone who isn't its author.

**The contract** (the doctrine every job inherits — details in [docs/CORE.md](../../docs/CORE.md)):

1. **Publish before review.** A reviewer is remote: host self-contained websites and
   MP4s with `pingfusi publish`; use a verified tunnel only for an app that genuinely
   requires a live server. An unviewable draft burns the round.
2. **File structured asks, not prose.** Steps a reviewer can act on (≤20 steps,
   ≤300 chars each), inline options for judgment questions (≤40 chars each), and a
   verdict list where the approving verdict is unmistakable.
3. **Verdict-required.** The round passes only on an approving verdict from its own
   declared list — prose that merely sounds approving never passes.
4. **Wait, fix, refile.** Filing automatically chains client-safe wait legs until
   feedback. If a raw MCP leg returns pending, immediately call `pingfusi_wait` again;
   never return pending to the user. Passive result/verify reads do not renew the lease
   (a lapse only pulls the round from the feed for new claims; a reviewer mid-review
   can still finish). Act on every comment in the artifact's
   own source, refile, repeat. Done is a recorded verdict, never a feeling.

**How to run it.** `core.review.file(stateFile, spec)` (send + wait) →
`core.review.verify(stateFile)`, against a state file you own — no target workspace
needed. The installed generic review skill drives this loop for coding agents; the
worked example in [Make your own](../your-own/TEMPLATE.md) is a complete recipe.

**Its routing skill:** [`pingfusi-review`](../../skill/pingfusi-review/SKILL.md), which
selects this verdict-bearing job when a quick advisory answer is not enough.

**Reviewer surface: the generic round.** A question, steps with tappable options,
pinned/drawn comments, and a verdict — answered with no custom UI work. That is
exactly why it is the day-one surface for every new job.