agentleFS
ClickHouseClickHouse/loom/.claude/skills/loom-address-review/SKILL.md

loom-address-review

Skill87 starsChanged 5 days agoApache-2.0View on GitHub

Works through review comments on your own Loom PR — verifies each thread, fixes it or answers why not, replies with the fixing commit, and repeats until a fresh review is empty. Use for "address the review", requested changes, or reviewer or bot comments on your PR. Not for reviewing others' changes (loom-review).

The file

We split this skill into the rules it gives an agent

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

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈3

    Distinctive · estimate

    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
  1. Distinctive:

    Write down the failing case, the pattern it shares with other findings, and the fix you expect to work.

    line 31
  2. Distinctive:

    Add or change the test that would have caught it.

    line 37
  3. Very specific:

    Run the gates the fix touches (loom-pre-push), commit with a message that says why (git commit -s), and push.

    line 38
  4. Distinctive:

    Update the PR body when the fixes change what it claims (scope, wire changes, tests): the squash merge copies the body into main's history.

    line 55

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “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

Addressing review on a Loom PR

A review comment is a claim about the code. Treat each as a bug report: verify it, fix it at the source, and answer in its thread so the reviewer can check the fix without rereading the PR. A request to address the review covers the commits, the pushes and the thread replies on your own PR; anything else public (a new issue, a comment on another PR) still needs a yes.

1. Collect every open thread

gh api graphql -F o=ClickHouse -F r=loom -F n=<n> -f query='
query($o:String!,$r:String!,$n:Int!){repository(owner:$o,name:$r){pullRequest(number:$n){
  reviewThreads(first:100){nodes{id isResolved isOutdated path line
    comments(first:50){nodes{databaseId author{login} body}}}}}}}' \
  --jq '.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved | not)'
gh pr view <n> --json reviews,comments --jq '.reviews[].body, .comments[].body'   # review summaries and top-level comments

Findings from a loom-reviewer run in this session count the same as GitHub threads.

2. Verify, then decide

For each finding, before editing:

  • Reproduce it: read the code path, write the failing test or a one-line probe. A finding you cannot reproduce gets a reply with what you checked, not a speculative change.
  • Write down the failing case, the pattern it shares with other findings, and the fix you expect to work. Several findings with one cause get one fix.
  • Fix every confirmed finding, nits included. Decline only with a reason a reviewer can check ("the caller already bounds this: _load in the store caps it at 500"). Never decline silently.

3. Fix at the source

  • The simplest change a new team member could follow: no new abstraction for one caller, no defensive branch for a state that cannot happen, no comment that restates the code.
  • Add or change the test that would have caught it.
  • Run the gates the fix touches (loom-pre-push), commit with a message that says why (git commit -s), and push.

4. Reply in each thread

Reply to the thread's first comment, in the loom-writing voice: what changed, the commit, the test.

gh api repos/ClickHouse/loom/pulls/<n>/comments/<databaseId>/replies -f body='Fixed in <sha>: <what now happens>; <test> covers it.'
  • Resolve a thread only when the fix is pushed and the reply names it, and leave a human reviewer's thread for them to resolve when they asked to check it themselves:
gh api graphql -F id=<thread id from §1> -f query='mutation($id:ID!){resolveReviewThread(input:{threadId:$id}){thread{isResolved}}}'
  • A top-level review comment gets one top-level reply that lists each point and its commit.
  • Update the PR body when the fixes change what it claims (scope, wire changes, tests): the squash merge copies the body into main's history.

5. Repeat

After the push, start a fresh review on the new head right away, in parallel with CI (loom-reviewer in Claude Code, loom-review elsewhere). The loop ends when a fresh reviewer returns no findings on the head and every check is green. An "approve" that still lists nits is not the end.

Report

For each finding: what it was, fixed (commit) or declined (reason), and the test. Then the head commit, CI state and the last reviewer's verdict.

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.