agentleFS
TakiTakeTakiTake/pall8t/.claude/skills/review-loop/SKILL.md

review-loop

Skill4 starsChanged 49 days agoMITView on GitHub

Address review feedback on a GitHub PR — fetch bot/human comments, verify every finding against the code before acting, classify it (real / valid nitpick / false positive), fix real ones with a regression pin, refute false ones with evidence, reply per finding, and request re-review. Use when a PR has review comments to address, when asked to "handle the review", or after an automated reviewer (ultrareview, Codex, CodeRabbit) posts findings. Loops until reviewers are satisfied, max 5 iterations.

62 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use motion-design, file-pr 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.
  • soilmassSkill

    motion-design

    Create animations and motion graphics using industry standards. Use when asked to animate UI elements, create video content, implement transitions, or build motion systems. Implements W3C Design Tokens, Material Design 3 baseline, and Lottie specification compliance.

    Also in 5 projects that use this

  • tekumaraSkill

    file-pr

    Raise a concise pull request. Use when the user asks to raise, open, or create a PR.

    Also in 3 projects that use this

  • owidSkill

    babysit-pr

    Spawn a background agent that babysits an open PR — triggers a Codex review, watches CI, judges and fixes valid findings, replies to and resolves review threads, and loops to a cap. Never merges. Trigger when the user asks to "babysit the PR", "ask for codex review(s) and watch CI", or after pushing a substantial chunk to a PR branch.

    Also in 4 projects that use this

  • HK-hubSkill

    polish

    Performs a final quality pass fixing alignment, spacing, consistency, and micro-detail issues before shipping. Use when the user mentions polish, finishing touches, pre-launch review, something looks off, or wants to go from good to great.

    Also in 3 projects that use this

  • jaydubya818Skill

    show-me-your-work

    Use when long-running work needs an auditable decision and evidence log.

    Also in 3 projects that use this

  • MicrosoftSkill

    council

    Convene the persona panel — six orthogonal review lenses — on a target. Cold independent fan-out, debate-to-consensus, synthesized verdict with recorded dissent and a roster manifest.

    Also in 4 projects that use this

The file

We split this skill into the rules it gives an agent

4 rules. 0 are common, 3 are distinctive, and 1 is very specific to this project.

  • 0

    Common

    Most of the 55 edited versions we read keep these.

  • 3

    Distinctive

    This author's own choices. Worth a look.

  • 1

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Distinctive:

    Reproduce it: write the failing test, or trace the concrete input/state that triggers the defect.

    line 32
  2. Distinctive:

    Never blanket-apply a bot's suggestions: reviewers disagree, and applying both sides of a contradiction produces churn.

    line 46
  3. Very specific:

    Run the full local gate before pushing (scripts/lint.sh and cargo test in this repo).

    line 57
  4. Distinctive:

    Never merge the PR yourself — in this repo, merging is always the human's action, regardless of how green everything is.

    line 92

“Common” is measured: kept by at least 6 in 10 of the 55 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 loop

Reviewer findings — especially from bots — are claims, not verdicts. Multiple reviewers contradict each other, and a plausible-sounding finding can be wrong. The core rule of this loop: verify first, then classify, and never apply a finding you haven't reproduced or reasoned through.

1. Gather every finding

gh pr view <N> --comments                                     # conversation
gh api --paginate repos/{owner}/{repo}/pulls/<N>/comments     # inline review threads
gh api --paginate repos/{owner}/{repo}/pulls/<N>/reviews      # review verdicts

--paginate matters: without it a busy PR silently truncates to the first page and findings past it are never addressed. Merge all pages into one collection before deduplicating.

Collect findings from all sources, including resolved-looking threads with no reply. Deduplicate across reviewers (bots often overlap).

2. Verify each finding — before touching the code

For each finding, decide which it is by evidence, not plausibility:

  • Reproduce it: write the failing test, or trace the concrete input/state that triggers the defect. If you can make it fail, it's real.
  • Refute it: trace the actual code path or the documented semantics of the API in question (std docs, upstream source) far enough to show the failure cannot happen. "Looks fine to me" is not a refutation.

3. Classify and act

ClassAction
Real defectFix it, and add a regression test that pins the exact failure scenario the reviewer described. The fix without the pin is half the job.
Valid nitpickApply if cheap; otherwise explain in the reply why it's deferred.
False positiveDo NOT change behavior to appease it. But treat it as a readability smell: if correct code drew the finding, the code argued badly for itself — clarify the comment/structure at that spot and, when practical, pin the questioned behavior with a test so the next reviewer (human or bot) doesn't trip on it.

Never blanket-apply a bot's suggestions: reviewers disagree, and applying both sides of a contradiction produces churn. The classification decision is the review — record it.

One more obligation for real findings: they mean the pre-PR local-review pass missed something. Generalize the miss into a lens in that skill's checklist (its "Grow the lenses" section) in the same PR that fixes it, so the category is caught locally next time.

4. Gate, commit, push

Run the full local gate before pushing (scripts/lint.sh and cargo test in this repo). Commit messages state the classification: what was real and fixed, what was refuted and why the code changed anyway (clarity, pinning) or didn't.

Pushing fix commits to the PR's own feature branch is ordinary workflow — it's what keeps the loop moving. But the repo's publish gates still apply: anything CLAUDE.md reserves for the human (tag pushes, merging, other repos) or that the permission system denies is handed to the human as an exact command, never retried or worked around.

5. Reply per finding, then request re-review

Reply on the PR (thread reply for inline comments, PR comment otherwise) with the verdict and the evidence: for a fix, name the commit and the pinning test; for a refutation, show the trace ("this into_inner unwraps the Take, not the BufReader") — enough that the thread can be resolved without re-deriving your work. Then request re-review from whoever raised it — each reviewer has its own trigger: CodeRabbit reviews only when it is asked to (comment @coderabbitai review; automatic review is off, so a push alone gets you nothing), the Codex workflow runs on synchronize (every push) when its API key is configured, and humans get a normal re-review request. Confirm the re-review actually started; a reply nobody re-reads closes nothing.

6. Loop, bounded

Repeat from step 1 when new feedback lands. Stop and hand back to the human when:

  • 5 iterations pass without convergence,
  • two reviewers directly contradict each other (present both sides and a recommendation instead of picking silently), or
  • a finding requires a scope/design decision that isn't yours to make.

Never merge the PR yourself — in this repo, merging is always the human's action, regardless of how green everything is.

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.