Geminiloop
Drive a GitHub PR until Gemini Code Assist has no unresolved comments, but do not cargo-cult its suggestions. Gemini is often confidently wrong. Every comment is a claim to verify, not an instruction to obey. A wrong suggestion applied is worse than the comment itself.
How Gemini differs from other review bots
- No check-run, no score. Gemini does not publish a
X/5confidence or agreptilecheck. It posts a PR review (stateCOMMENTED) authored bygemini-code-assist[bot]with a## Code Reviewsummary body plus inline review comments. Detection is by polling the reviews endpoint, not a check-run. "Satisfied" = Gemini has reviewed the latest push and no bot comment is left unresolved (each either fixed or rebutted), since there is no numeric target. - Auto-reviews on push/open. It reviews automatically when a PR opens or gets new commits;
/gemini reviewforces a fresh pass. - Severity, not confidence. Inline comments carry a priority badge (a
![critical]/![high]/![medium]/![low]shields image) at the top of the body. Weightcritical/highseriously; treatmedium/lowas usually-skippable nits unless clearly correct. - Higher false-positive rate. This is the whole point of the skill: bias toward rebut over change.
Not for
- GitLab / Perforce (Gemini Code Assist is GitHub-only). For other review bots this catalog ships
copilotloop,codexloop,coderabbitloop, andqodoloop; for CI failures rather than review comments, useci-fix-loop.
Review state comes from the PR, not from memory
scripts/pr-review-state.sh reads the PR and prints one JSON object: the current head, whether
Gemini has acted on that head (a review of it, or any comment after it was pushed), and every
unresolved review thread with its author. Every "is there work / are we done" decision in this
loop comes from its exit code, never from what you remember resolving. The script lives in this
skill's directory, SKILL_ROOT: the directory holding this SKILL.md (Claude Code prints it as the
skill's base directory when the skill loads; in Codex, derive it from the selected SKILL.md path).
| Exit | verdict |
Meaning | Do |
|---|---|---|---|
| 0 | clean |
Gemini acted on the current head and no bot thread is unresolved | exit check: done |
| 10 | findings |
unresolved threads from Gemini or any other review bot | run an iteration |
| 20 | pending |
Gemini has not acted on the current head yet | trigger if needed, then wait |
| 30 | limited |
a rate-limit or paused notice from Gemini after the current head | stop, report blocked: rate-limited |
Resolving the last thread does not make a PR clean: Gemini has not reviewed your push yet. Earlier
versions of this loop exited at exactly that moment, while the next round of comments was still on
its way. Human threads are listed in .unresolved (is_bot: false) and counted in .counts.humans;
they never block clean, and this loop never resolves them.
1. Identify the PR
gh pr view --json number,headRefName,headRefOid -q '{number,branch:.headRefName,head:.headRefOid}'
Switch to the PR branch if not already on it. Capture OWNER/REPO (gh repo view --json owner,name).
2. The loop (max 5 iterations)
Keep an explicit iteration counter and stop at 5: the cap is a real bound to enforce, not a figure of speech. Each pass through A–G is one iteration; on hitting the cap, go straight to the report and list what is still unresolved rather than starting a sixth.
A. Read the PR state; wait for Gemini's review of the current head
One read answers both "is there work?" and "has Gemini seen my last push?". SINCE is the
timestamp you took right before your last push (step E); leave it empty on iteration 1. Right
after a push, add --wait 600 straight away: the wait ends only once the bot has acted on the new
head, so threads left open on purpose cannot make the push look reviewed.
"$SKILL_ROOT/scripts/pr-review-state.sh" --repo OWNER/REPO --pr <PR> --bot gemini-code-assist --since "$SINCE"
- Exit
10(findings): go to B. On iteration 1 this is whatever Gemini (or another bot) already posted. - Exit
20(pending): post/gemini review(gh pr comment <PR> --body "/gemini review"). Then wait with the same command plus--wait 600. Run the wait in the background where the host allows it (Claude Code: Bashrun_in_background; you are re-invoked when it exits) so ten minutes of polling never sits in the conversation. Still20after the wait: say so out loud, post/gemini reviewonce more, and wait once more. Still20after that: stop and report the timeout honestly; never claim success. - Exit
0(clean): go to the exit check. A--waitcall returnscleanonly after a settle re-read 60 seconds later, so a comment landing right behind the review is still caught. A bare read (no--wait) that sayscleanis good enough only when you have not pushed since Gemini's last review. - Exit
30(limited): stop now and reportblocked: rate-limited; nothing more is coming. - Exit
1: the read itself failed (often a transient GitHub 502). Retry once; if it fails again, stop and report it. An unknown state is not a clean one.
B. Fetch the findings
The working set is every unresolved thread in the state JSON with is_bot: true: Gemini's
own (is_target: true) and any other review bot's (Greptile, for example). A
fix for one bot often draws a comment from another, and leaving those open is how a "finished" loop
leaves a PR that is not clean. Treat another bot's thread with exactly the same verify-first rules
below. Never act on a human's thread (is_bot: false); list it in the report.
- Summary (the
## Code Reviewbody): the latest review.bodyfrom this bot (gh pr view <PR> --json reviews): read the overall take and the severity spread. - Unresolved inline comments:
.unresolved[] | select(.is_bot)in step A's state JSON lists each thread'sthread_id,comment_id,path,lineand a short excerpt, across every page of threads. Read the full comment before judging it:
gh api repos/{owner}/{repo}/pulls/comments/<COMMENT_ID> --jq '{user: .user.login, path, line, body}'
Mark each unresolved comment as seen, so the bot and a watching human can tell it is being handled.
GitHub's reaction set is fixed; eyes is the only "looking at it" value:
gh api --method POST repos/{owner}/{repo}/pulls/comments/<COMMENT_ID>/reactions -f content=eyes
C. Critically evaluate EACH comment (the core of this skill)
For every comment, verify the claim against the actual code and repo conventions before touching anything. Read the file, the surrounding code, the types, and any call sites. Then classify:
- CORRECT + actionable: the finding is real and the fix improves the code. → fix it (step D).
- FALSE POSITIVE / technically wrong: the claim doesn't hold. → do NOT change code; write a specific, evidence-based reply (cite the exact code/line/behavior that disproves it), then resolve.
- Valid but out-of-scope / stylistic nit that conflicts with repo convention or the PR's intent → briefly decline with a reason, then resolve. Do not expand the PR's scope to satisfy a nit.
Hard rules:
- Never modify correct code just to silence Gemini. Prefer a reasoned rebuttal.
- When uncertain whether a claim holds, investigate (read more code, run the type-checker / tests) rather than assume Gemini is right. Default to skepticism.
- If a suggested change would break other call sites, alter public behavior, or contradict a verified repo convention, it is a category-2 rebuttal, not a fix.
- Never fabricate identifiers to satisfy a comment (e.g. a Linear/ticket prefix). If Gemini asks for a ticket reference and none exists, say so; do not invent one.
Gemini's common failure modes to watch for (default these to category 2):
- Hallucinated APIs, options, or framework behavior stated as fact.
- "Add a null/undefined check" where the type already guarantees presence.
- Suggestions that compile-break or break other callers.
- Security/perf warnings with no actual exploit path or measurable cost.
- Restating library/framework semantics incorrectly.
- Style demands that contradict the repo's existing, consistent pattern.
D. Apply fixes: category 1 only
Make the minimal correct change. Re-run the local gate if the repo has one (typecheck/tests) before moving on.
E. Commit and push FIRST, before resolving anything
Order matters. A resolved thread is a claim that the fix is on the branch, so the push has to succeed before the claim is made: otherwise a failed commit or push leaves the PR unfixed with the finding marked resolved, and nobody looks at it again.
If step D changed code:
# Stage ONLY the files your fixes touched: never `git add -A`, which sweeps up
# unrelated work and untracked secrets sitting in the worktree.
git status --short # look before you stage
git add <path> [<path>...] # the files named in the findings you fixed
git commit -m "address gemini review feedback (geminiloop iteration N)"
SINCE=$(date -u +%Y-%m-%dT%H:%M:%SZ) # step A reads bot activity after this
git push
Author the commit per the repo's norms (e.g. the user's identity; no AI attribution if that is the convention). Confirm the push actually landed before continuing:
git rev-parse HEAD
gh pr view <PR> --json headRefOid -q .headRefOid # must match
If they differ, stop: the fix is not on the PR, so nothing may be resolved yet.
F. Reply to and resolve every addressed thread
Only now, with the fixes pushed, reply and resolve. Take thread and comment ids from step A's state
JSON (.unresolved[]): the script already follows pagination, so do not hand-roll a threads query.
Reply on a thread's comment via gh api repos/{owner}/{repo}/pulls/<PR>/comments -f body="..." -F in_reply_to=<comment_id>,
then resolve:
gh api graphql -f query='mutation { resolveReviewThread(input: {threadId: "THREAD_ID"}) { thread { isResolved } } }'
Then record the disposition as a reaction on the bot's own comment: the learning signal, and a visible marker for a human scanning the PR:
- 👍 (
+1): the finding was accepted and fixed. - 👎 (
-1): the finding was rebutted as a false positive. This is the correction signal.
gh api --method POST repos/{owner}/{repo}/pulls/comments/<COMMENT_ID>/reactions -f content=+1
# rebutted finding:
gh api --method POST repos/{owner}/{repo}/pulls/comments/<COMMENT_ID>/reactions -f content=-1
Reply first, then react, then resolve: the reaction is not a substitute for the reply, and a resolved thread with no reply loses the reasoning.
Resolve a thread only for a bot comment in your working set (this bot's or another review bot's) that you have fixed or rebutted: never blanket-resolve, and never resolve a human reviewer's thread.
Threads you are rebutting need no push, so they may be replied to and resolved regardless of whether step D changed code.
G. Back to A
Go back to A. After a push, A waits for Gemini's review of the new head (pushing re-triggers
it when auto-review is on; otherwise A triggers it). If this iteration changed no code (every finding
rebutted), there is no new head to wait for: A's fresh read says clean or shows what is still open.
3. Exit conditions
Decide from a fresh state read, never from what you remember resolving.
Stop when any is true:
- Done: the latest
pr-review-state.sh --wait 600call, made after your last push, exited0(clean); with no push since the bot's last review, a bare read that exits0is enough. Open human threads do not block this; list them in the report. - Max iterations (5) reached: report what remains.
- Timeout: still
pendingafter the retry in step A. Report it honestly; do not claim success. - Rate limited: exit
30. Reportblocked: rate-limited.
Keep the context small; resume instead of restarting
- Carry only three things between iterations: the iteration counter, the latest state JSON, and a ledger of each thread you handled (fixed with its commit, rebutted, or blocked). Re-read files fresh each iteration; do not re-paste earlier rounds' comment bodies.
- All loop state lives on the PR, so the loop is resumable. If the session has grown long or slow, or a bot commented after the loop ended, run this skill again in a fresh session: step A picks up from the PR as it is now. Starting fresh is cheaper than dragging a long session through more rounds.
- After reporting done, if the host can schedule a follow-up (Claude Code:
/loopor a scheduled wakeup), offer one re-check about 20 minutes later for bots that comment late.
4. Report
Geminiloop complete.
PR: #<n>
Iterations: N
Comments fixed: N (genuinely-correct findings)
Comments rebutted: N (false positives / nits, resolved with rationale)
Remaining: N (bot threads still open)
Human threads: N (open, listed below; this loop never resolves them)
Final state: clean | timeout | rate-limited | iteration cap
If it stopped at max iterations, list the remaining threads with your current assessment (fix-pending vs disputed) so a human can arbitrate.
