agentleFS
akshaypimprikarakshaypimprikar/pragma/.claude/skills/review/SKILL.md

review

Skill4 starsChanged 6 days agoMITView on GitHub

Review a PR for design compliance and code quality, and verify that gates actually ran by re-running its deterministic checks at the PR HEAD SHA rather than trusting the pasted summary. Invoke when a PR is opened, passing the PR number or branch name.

192 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use close-spec, daily-arxiv and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • dzhngSkill

    close-spec

    When a spec under specs/<feature>/ is done shipping (a write-spec build, or any planned task that produced a spec), archive it to specs/done/ and rewrite it from a build-plan into a durable rationale — the why, the principles, the invariants — pointing back to the real code for the how. Use when implementation has landed and the plan no longer matches what shipped, or the user says a feature/spec is finished. Pairs with [write-spec](../write-spec/SKILL.md) (the plan this closes) and [review](../review/SKILL.md) (run before closing).

    Also in 5 projects that use this

  • LambenthanSkill

    daily-arxiv

    每日从 arXiv 拉取新论文,过滤相关性,auto-ingest 高优先级论文,检测 SOTA 更新

    Also in 5 projects that use this

  • dzhngSkill

    design-with-images

    Explore UI and visual design with image generation, then iterate the real implementation against the user-selected concept. Use when brainstorming visual directions, offering mockup variants, or implementing an approved generated design; do not stop at the mockups or the first code approximation.

    Also in 5 projects that use this

  • LambenthanSkill

    exp-eval

    实验判决门:Review LLM 独立评判实验结果 → 4 种判决路径 → 自动更新 claims confidence、ideas status、graph edges

    Also in 5 projects that use this

  • +5 more from Lambenthan
  • +3 more from dzhng

The file

We split this skill into the rules it gives an agent

12 rules. 0 are common, 3 are distinctive, and 9 are very specific to this project.

  • 0

    Common

    Most of the 156 edited versions we read keep these.

  • 3

    Distinctive

    This author's own choices. Worth a look.

  • 9

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Read AGENTS.md/CLAUDE.md first — it defines the architecture rules you enforce.

    line 16
  2. Very specific:

    Lane first: Run python3 scripts/check_pr_lane.py --git origin/<base> --head-branch <head> --base-branch <base> and state the lane in the …

    line 28
  3. Very specific:

    /review --confirm: after an APPROVED verdict, when the head moved with more than log-only commits (for example code-review fixes): review …

    line 47
  4. Very specific:

    Do not re-run xcodebuild or the ios-coverage skill — a full local build, test run, and coverage pass is too expensive to repeat here.

    line 65
  5. Distinctive:

    Check CI: If a PR exists:

    line 114
  6. Very specific:

    If this block or the log check below prints STOP, it did not run: fix the cause (for example gh auth login or git fetch) and run it again.

    line 154
  7. Distinctive:

    Every finding it reports — each checklist FAIL and each other defect — goes into the verdict, marked accepted or dismissed.

    line 210
  8. Very specific:

    Before rating, pipe each finding's path:line citation through python3 scripts/check_finding_lines.py --base origin/<base>.

    line 226
  9. Distinctive:

    If a subagent cannot be spawned in this runtime, run the checklists here instead, apply the same severity, blocking and advisory rules …

    line 245
  10. Very specific:

    Every verdict carries two lines right under its heading, which the review-evidence check reads: Reviewed at <full PR HEAD SHA> and Round <1 …

    line 279
  11. Very specific:

    Only blocking items (a failed gate-verification check, a HIGH, or a blocking MEDIUM) go in .claude/context/rejections.md, whoever logs …

    line 288
  12. Very specific:

    Use --comment, not --approve — GitHub blocks self-approval on PRs authored under your own account, so --approve fails here.

    line 335

“Common” is measured: kept by at least 6 in 10 of the 156 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Review Agent

You are the Review Agent for an iOS app project. Your job is to review a PR for design compliance and code quality — architecture, type-safety, and build/test/coverage compliance are /gates' job; this command verifies that /gates actually ran and re-runs its cheap deterministic checks at the PR HEAD SHA, rather than trusting the pasted summary.

Trigger

Invoked when a PR is opened. The PR number or branch name is passed as the argument (e.g. /review 12 or /review feature/recurring-transactions). Feature/fix/spec PRs target develop; hotfix/release PRs target main.

Process

Read AGENTS.md/CLAUDE.md first — it defines the architecture rules you enforce.

Also read the following files if they exist — skip silently if absent:

  • .claude/context/invariants.md — project invariants; these supplement AGENTS.md/CLAUDE.md rules
  • .claude/context/rejections.md — past violations on this project
  • .claude/context/incidents.md — past bug root causes

How to rate a repeat of an entry in either file is stated under "Judgment checks" below, and the subagent gets that wording verbatim.

Lane, rounds and design mode

Lane first. Run python3 scripts/check_pr_lane.py --git origin/<base> --head-branch <head> --base-branch <base> and state the lane in the verdict. The docs, release and sync lanes need no /review: say so and stop. app and pipeline continue. scripts/pipeline_lanes.json lists what each lane needs to merge; the review-evidence CI check (scripts/check_review_evidence.py) enforces it.

One round by default. Round 1 reviews the whole PR. Only a blocking finding (see "Merge its output" below) sends the PR back. Every other finding gets a GitHub issue and the verdict is APPROVED with the issue links. Round 2 runs only after a CHANGES REQUESTED round 1: the subagent gets only the diff since the round-1 Reviewed at SHA plus the round-1 blocking findings, and checks whether each was fixed and whether the delta introduced a HIGH. There is no round 3: after round 2, open an issue for each remaining non-HIGH finding and post APPROVED; a remaining HIGH goes to the user for a decision. Each extra round re-reads the PR and adds new surface to review, so findings that are not defects in this diff do not earn one (2026-09-28 to 10-05: a project PR ran 56 rounds; another's round 2 found LOW items in round-1 fixes).

Round cap is enforced. review-evidence fails a PR with a third full-round ## Review Agent verdict: review (scripts/check_review_evidence.py; a Round confirm verdict does not count). Do not post one: after round 2 open issues, or ask the user to add a Round cap override: <reason> line to the PR body. A later commit that touches only docs/*.md, docs/pipeline-review/**, CHANGELOG.md or README.md (not docs/superpowers/) keeps the verdict valid, so a docs fix needs no --confirm.

/review --confirm after an APPROVED verdict, when the head moved with more than log-only commits (for example code-review fixes): review only the diff since the last APPROVED SHA, block only on a HIGH that diff introduces, and post Round confirm. It is not a round.

Design mode for a PR whose changes are specs or plans under docs/superpowers/: the subagent reports only contradictions, false claims (it opens every cited path:line and every claimed fact about another file) and flaws that make the design fail or unbuildable. Implementation detail goes in the spec's "Requirements carried to /plan" section, not into the verdict as a blocker.

Architecture, type-safety, build/test/coverage compliance — verified against /gates, not trusted

/gates runs before every PR is opened and is the single authoritative check for layer separation, type safety, patterns, build success, full test suite, coverage, and UI-selector matching (its Gate 10 covers what this section used to duplicate). A gate summary pasted into a PR body is a claim written by the same session that wrote the code, so do not accept it on its own. Verify it in this order; a failed check is a CHANGES REQUESTED finding, not a question to ask the user.

Do not re-run xcodebuild or the ios-coverage skill — a full local build, test run, and coverage pass is too expensive to repeat here. Everything else that is cheap and deterministic is re-run.

  1. Pin the SHA. git fetch origin, make sure the checkout is the PR head (gh pr checkout <PR> or a worktree if it is not), then compare:
    gh pr view <PR> --json headRefOid -q .headRefOid
    git rev-parse HEAD
    git status --porcelain -- . ':!.claude/context/rejections.md'   # must print nothing (this command's own log is exempt)
    The two SHAs must be equal, the tree clean, and the Gates run at <sha> line in the PR body's gate summary must equal that SHA. A missing line, a different SHA, or commits landed after /gates ran → CHANGES REQUESTED: re-run /gates at the current HEAD. Do not fall back to "ask the user whether to trust it".
  2. Re-run the deterministic gates at that SHA and compare to the summary. Run the scripts from the base branch, not the PR checkout (a PR that edits check_gate_integrity.py must not be judged by its own edited copy — the gates job in gates.yml does the same), and pass the PR's branch name because a gh pr checkout/worktree HEAD may be detached, which makes the integrity script silently skip its feature/* check:
    BR=$(gh pr view <PR> --json headRefName -q .headRefName)
    BASE=origin/$(gh pr view <PR> --json baseRefName -q .baseRefName)   # origin/main for release/* and hotfix/*
    T=$(mktemp -d)
    run_gate() {  # never run an empty file: `git show > f` leaves a 0-byte f when the script is missing
      name=$1; shift
      if git show "${BASE}:scripts/${name}.py" > "$T/${name}.py" 2>/dev/null; then python3 "$T/${name}.py" "$@"
      else echo "NOT VERIFIED: scripts/${name}.py not on ${BASE}"; fi
    }
    run_gate check_gate_integrity "$BASE" "$BR"    # Gate 11
    run_gate check_tdd_commit_order "$BASE"        # Gate 9
    A script that is not on the base branch yet (the PR introducing it, or before it merges) is reported as NOT VERIFIED: <script> not on <base> and, for a PR that adds it, run from the PR copy with that caveat stated — never counted as a clean pass. Exit 2 from the TDD script means the configured layer names (project.architecture / project.scoped_layer_dirs) match nothing in the repo: report that, not a pass. Also re-run the grep-only gates — Gate 3 (TODO/FIXME/HACK), Gate 4 (branch name), Gate 5 (CHANGELOG) and Gate 10 (architecture rules) — with the base branch's gate script and config, against $BASE (local develop may be stale after git fetch) and $BR (a detached checkout has no current branch):
    if git show "${BASE}:scripts/check_gates.sh" > "$T/check_gates.sh" 2>/dev/null && git show "${BASE}:scripts/pipeline_lanes.json" > "$T/lanes.json" 2>/dev/null; then
      bash "$T/check_gates.sh" --only 3,4,5,10 --base "$BASE" --branch "$BR" --config "$T/lanes.json"
    else echo "NOT VERIFIED: scripts/check_gates.sh or scripts/pipeline_lanes.json not on ${BASE}"; fi
    Each of its four summary lines must match the same gate's line in the pasted summary. Any result that disagrees — a script exits non-zero, a gate line differs — is CHANGES REQUESTED, quoting the command and its output. Gates 1, 2, 6, 7, and 8 (build, tests, coverage, security skill, advisory heuristics) are not re-run here; state that they rest on the summary and CI.
  3. Check CI. If a PR exists:
    gh pr checks <PR> --json name,bucket
    Require a check named gates with bucket pass. fail → CHANGES REQUESTED. pending → wait for it to finish, up to 30 minutes; if it is still pending then, post CHANGES REQUESTED with every other result of this review plus a note that CI has not finished, and run /review again once it has. Unfinished CI is not a violation: do not log it to rejections.md. No check named gates at all → CHANGES REQUESTED: gates.yml runs on every PR, so a missing check means CI did not run.

Judgment checks — run by a fresh-context subagent, not this session

The design compliance and code quality checklists below are judgment calls, so this session does not make them. Hand them to one fresh-context subagent, spawned with the Agent tool and model: "sonnet" (the default inherits the session model, and which makes each round an expensive top-model run). In another coding agent, use its own subagent tool with no conversation history (Codex: spawn_agent with fork_turns: "none"); this section is the explicit request such tools ask for. Give it these inputs, and nothing that carries the implementer's account of the change (listed below). This PR's own entries in rejections.md and incidents.md describe the change, so the subagent gets a diff without the two logs and the base branch's copies of them. Prepare those in one shell call (BASE does not carry over from step 2), with the copies outside the repo so the working tree stays clean:

BASE=origin/$(gh pr view <PR> --json baseRefName -q .baseRefName)
git rev-parse -q --verify "$BASE" >/dev/null || { echo "STOP: base branch not found ($BASE)"; exit 1; }
T=$(mktemp -d)
git diff "${BASE}...HEAD" -- . ':!.claude/context/rejections.md' ':!.claude/context/incidents.md' \
  > "$T/pr.diff" || { echo "STOP: git diff failed"; exit 1; }
if [ ! -s "$T/pr.diff" ]; then
  git diff --quiet "${BASE}...HEAD"; rc=$?
  [ "$rc" -eq 0 ] && { echo "EMPTY: the PR has no changes"; exit 0; }
  [ "$rc" -eq 1 ] || { echo "STOP: git diff failed"; exit 1; }
  echo "LOG-ONLY: this PR changes only the logs"; exit 0
fi
for f in rejections incidents; do
  if git cat-file -e "${BASE}:.claude/context/$f.md" 2>/dev/null; then
    git show "${BASE}:.claude/context/$f.md" > "$T/$f.md" || { echo "STOP: could not copy $f.md"; exit 1; }
  fi
done
echo "subagent inputs in: $T"

If this block or the log check below prints STOP, it did not run: fix the cause (for example gh auth login or git fetch) and run it again. Never post a verdict on a block that stopped. EMPTY means the PR has no changes at all: post CHANGES REQUESTED saying so, with nothing to review. LOG-ONLY means the PR changes nothing but the two logs, so the subagent has nothing to judge: skip it, write Judgment checks: N/A (log-only PR) in the verdict, and still run the log check below. CHANGELOG.md stays in the diff: it is part of the change under review. Its entries must describe what changed, not how the review of this PR went, so that they carry no implementer's account. Then give it these, using the directory the block printed as $T:

  • the PR number, to name in its findings (not to fetch anything with)
  • the diff: $T/pr.diff
  • the acceptance criteria from the plan or spec this PR implements (docs/superpowers/plans/ or docs/superpowers/specs/), if one exists
  • the files to read: AGENTS.md/CLAUDE.md, .claude/context/invariants.md, the base-branch log copies in $T (rejections.md, and incidents.md if it exists), plus docs/design-system.md and <AppName>/Theme/ when the diff touches <AppName>/Views/ or adds a UI component
  • the two checklists below, verbatim
  • this rule, verbatim: a finding that repeats a violation logged in rejections.md for an earlier PR, or reintroduces a symptom in incidents.md, is HIGH severity — name the entry it repeats. A repeat of a rejections.md entry that recorded only a wording or style issue keeps its own severity. Both logs you get are the base branch's copies, so every entry in them is from an earlier PR
  • the severity scale, one of these for every finding: HIGH is a repeat (the rule above) or a break of an AGENTS.md/CLAUDE.md or invariants.md rule; MEDIUM is a FAIL on a checklist item that is not marked (advisory), or a defect that changes behavior or would mislead a reader; LOW is a wording or style issue that changes nothing. A FAIL on a required checklist item is never lower than MEDIUM.

It may also read any source file in the repo (for example, the whole file around a hunk), since several checks need surrounding code, except the working-tree copies of .claude/context/rejections.md and .claude/context/incidents.md, which hold this PR's own entries: tell it not to open them or diff them. What it must not get is the implementer's account of the change: this session's conversation, the implementer's reasoning, the PR body, commit messages, or the gate summary. Tell it not to run any command that shows PR metadata or commit history: gh pr view, gh pr diff, gh pr checks, gh api for the PR, git log, git show or git blame. Tell the subagent it is read-only (no edits, commits, or GitHub posts), and instruct it to report every checklist item as PASS or FAIL with file path + line number, or as N/A with the reason it does not apply, plus any other defect it finds in the diff, each with a severity, or to state plainly that it found none.

The subagent does not see this PR's changes to rejections.md or incidents.md, so check them yourself: each must only append: the base branch's file has to be an exact prefix of the PR's file, so an insertion, an edit or a removed line anywhere in an earlier entry is caught. Compare against the merge-base, not the base branch's tip, because PRs merged since this branch was created may have appended their own entries. This must print nothing:

BASE=$(git merge-base "origin/$(gh pr view <PR> --json baseRefName -q .baseRefName)" HEAD)
[ -n "$BASE" ] || { echo "STOP: no merge-base found"; exit 1; }
for f in rejections incidents; do
  p=".claude/context/$f.md"
  if git cat-file -e "${BASE}:$p" 2>/dev/null; then
    n=$(git show "${BASE}:$p" | wc -c)
    cmp -s <(git show "${BASE}:$p") <(git show "HEAD:$p" | head -c "$n") ||
      { echo "EDITED: $p"; git diff "${BASE}" HEAD -- "$p"; }
  fi
done

An EDITED: line is a failed gate-verification check: CHANGES REQUESTED. Quote the edited lines from the diff the block prints under it.

Merge its output into the verdict:

  • Every finding it reports — each checklist FAIL and each other defect — goes into the verdict, marked accepted or dismissed. You may dismiss one only by quoting the code that disproves it, and the dismissal is listed in the posted verdict — never dropped silently.
  • Decide which accepted findings block with scripts/review_verdict.py, not by judgment. Pipe it a JSON list of the accepted findings (dismissed ones may be left out): {"id", "severity", "in_diff", "advisory", "depends_on_unchanged", "guard_bypass"}, flags default false, except that a MEDIUM that is not advisory must set one of the three explicitly (the script exits 2 otherwise). in_diff means a defect in lines this PR adds or changes. depends_on_unchanged means unchanged code the PR's change needs to work. guard_bypass means a concrete input or sequence that bypasses a guard in .claude/hooks/, gates, review or scripts/check_*. It prints a findings verdict, the blocking ids and the ids that get an issue instead (a failed gate-verification check still forces CHANGES REQUESTED, whatever the script prints): HIGH always blocks, MEDIUM blocks only when not advisory and one of the three flags is true, LOW never blocks. A MEDIUM that only proposes a different design or concerns unchanged code sets no flag. Use its lists as printed; a finding that does not block is still reported, with its issue link. Keep the severity the subagent assigned. You may raise it, and you may lower it only with a stated reason in the verdict. Two floors never move: a repeat rated HIGH under the rule above, a regression of a blocking fix, or a break of an AGENTS.md/CLAUDE.md or invariants.md rule stays HIGH, and a required checklist FAIL stays at least MEDIUM.
  • Before rating, pipe each finding's path:line citation through python3 scripts/check_finding_lines.py --base origin/<base>. Lower an OUTSIDE MEDIUM to LOW and say "cites lines outside the diff" in the verdict, unless the finding sets depends_on_unchanged or guard_bypass. UNCITED and INSIDE findings keep their severity.
  • A cosmetic finding (wording, wrap width, naming, formatting with no behavior effect) is never raised to HIGH by the regression rule below, however many times it returns; it stays LOW.
  • Decide regressions within this PR yourself; the subagent cannot see the PR body or history, so it does not rate them. Compare each finding with the fixes the PR body documents, with this PR's own entries in rejections.md, and with the incidents.md entries this PR's diff adds (an entry this PR added to rejections.md records a blocking item, since only blocking items are logged; an incidents.md entry can be non-blocking, so rate it on the severity scale from what it describes, as for a PR-body fix). A fix listed in the PR body has no severity of its own: rate it on the severity scale above from its description and from the verdict that found it, if one was posted, and state that rating in the verdict. If a finding matches a blocking fix made earlier in this PR (HIGH, or a blocking MEDIUM) that came back, it is a regression: raise it to HIGH and name that fix (and its entry, if one exists). A returning item whose earlier fix was not blocking (LOW, or MEDIUM on an advisory item) keeps its own severity, and a finding that was never fixed keeps its severity.
  • Post the subagent's raw report, unedited, in the verdict (inside a <details> block). The accepted and dismissed list is checked against it, so a finding left out of the list is visible to anyone auditing.
  • If a subagent cannot be spawned in this runtime, run the checklists here instead, apply the same severity, blocking and advisory rules (rating repeats only against the base-branch log copies prepared above, not the working-tree logs, which hold this PR's own entries), and write Judgment checks: NOT isolated (subagent unavailable) in the verdict. Call the review isolated only when a subagent actually ran and its report is the one you post; with no subagent report the verdict says NOT isolated (2026-11-01: a Codex run spawned no subagent and still reported "the isolated review found no defects").

Design compliance checks

Only applies to PRs that touch <AppName>/Views/ or add new UI components. Read docs/design-system.md and <AppName>/Theme/ before running these checks.

  • No hardcoded colors where a Theme.Colors token exists
  • No magic spacing or corner radius values where a Theme.Spacing token exists
  • No new visual patterns introduced without a corresponding token in Theme/
  • New charts or data visualisation components use Theme.Charts tokens
  • Component structure follows established patterns (card, row, sheet, empty state) documented in docs/design-system.md
  • (advisory) Layout adapts rather than assuming one screen: no hardcoded widths/heights/offsets where the layout should size from its container, safe areas respected, and any API newer than the project's deployment target is gated with #available (or @available) with a fallback

Code quality checks

  • No commented-out code committed
  • No TODO/FIXME in new code (unless tracked in an issue)
  • Functions do one thing
  • No magic numbers for <domain> thresholds — use named constants

Output format

For each check: ✅ PASS or ❌ FAIL (with file path + line number), or N/A with the reason it does not apply.

Lead the verdict with a Gate verification block: the PR HEAD SHA, whether it matched the summary's SHA, each re-run script/grep and its result, the log prefix check result, the gates CI job state, and which gates were not re-run. Follow it with an Isolated review block: every finding the subagent reported, with its severity, marked accepted or dismissed, with the quoted code for each dismissal (or the NOT isolated note), followed by the subagent's raw report (none when judgment checks were NOT isolated).

Every verdict carries two lines right under its heading, which the review-evidence check reads: Reviewed at <full PR HEAD SHA> and Round <1 | 2 | confirm>, plus the lane.

Final verdict:

  • APPROVED — every gate-verification check that ran passes (a NOT VERIFIED script is reported as a visible note, never as a pass, and does not block on its own; a pending gates job is handled as in step 3) and scripts/review_verdict.py lists no blocking finding (see "Merge its output" above), eligible to merge once the required checks pass (see AGENTS.md/CLAUDE.md "Merge rule")
  • CHANGES REQUESTED — list issues that must be fixed before merge

Logging violations to rejections.md

Only blocking items (a failed gate-verification check, a HIGH, or a blocking MEDIUM) go in .claude/context/rejections.md, whoever logs them: this review, a code-review round, or a person by hand. Append one entry per violation in two cases, not just one:

  1. This review's own verdict is CHANGES REQUESTED — log each failed gate-verification check and each accepted finding that blocks under the rules in "Merge its output" above. Non-blocking and dismissed findings go in the verdict only, not in this file.
  2. This review's own verdict is APPROVED, but the PR body documents bugs that were found and fixed earlier in this PR's lifecycle — a "Bugs found and fixed," "code-review round," or similar section from code-review (or the code-review:code-review plugin) or manual verification. Log each of those too. These are exactly the violation patterns this file exists to prevent recurring; by the time this review runs they're already fixed, so a formal pass finds nothing new and the file stays empty even when real defects happened. Read the full PR body specifically looking for this before concluding there's nothing to log. Log only fixes that would have blocked under the rules in "Merge its output" above (HIGH, or a blocking MEDIUM), rated as the regression check rates PR-body fixes; a fixed LOW or advisory item is not a violation to log.

In both cases, check rejections.md first. If the item already has an entry for this PR, skip it, however it was logged (an earlier /review round, a code-review round, or by hand). Logging it again would double the history that repeat detection reads. The one exception is a regression: if a blocking issue was fixed in this PR and then came back, log its return as a new entry that names the entry it repeats, or the PR-body fix if that fix has no entry yet.

## YYYY-MM-DD — PR#<N> — <Violation Type>
**What was wrong:** <description>
**Rule violated:** <exact rule from invariants.md or AGENTS.md/CLAUDE.md — or, if none applies, "no formal rule, caught in review" (case 1) or "no formal rule, caught before this review" (case 2)>
**File:** <path:line if known>
**Caught by:** <this review | code-review pass | manual verification — from the PR body>

Skip this step only if neither case applies, or every item that case 1 or case 2 requires already has an entry for this PR that the skip rule above covers.

Context isolation

Gate verification stays in this session but re-runs the deterministic gates; judgment checks run in the isolated subagent. What is and isn't isolated: reference.md § Context isolation.

Posting the verdict to GitHub

Reporting the verdict back in this session is not enough — nothing distinguishes it from prose written by the same session that wrote the code, so it isn't independently checkable by anyone auditing the repo from outside. Post it as a real, separate GitHub review object:

gh pr review <PR> --comment --body "$(cat <<'EOF'
## Review Agent verdict: <APPROVED | CHANGES REQUESTED>

Reviewed at <full PR HEAD SHA>
Round <1 | 2 | confirm> · Lane <app | pipeline>

<the check-by-check output from Output format above>
EOF
)"

Use --comment, not --approve — GitHub blocks self-approval on PRs authored under your own account, so --approve fails here. --comment still creates a distinct, timestamped review object separate from the PR body/comments, which is the actual goal.

Posting a review does not trigger the review-evidence check (it runs on pull_request_target, which review events do not fire). So finish by replacing or adding one line in the PR body, which does: Review: <review URL> at <full PR HEAD SHA> (edit the body with gh pr edit <PR> --body-file).

Done when

Any required rejections.md entries are appended, the verdict is posted to GitHub via gh pr review, the PR body's Review: line is updated, and the verdict is reported to the user. Do not merge the PR — per AGENTS.md's "Merge rule," the required checks decide mergeability and the user merges it themselves.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.