respond-to-pr-comments-in-blocklist
Skill630 starsChanged 27 days agoMITView on GitHub
Interactively walk a user through PR review comments one at a time, collect a per-comment decision, then post agent-authored replies on GitHub and resolve the review threads once the user approves a preview. Use only when the user wants to reply to or resolve review threads on GitHub. Skip when the user only wants comments fetched or displayed (use `pr-comments`), or only wants the code changes made without posting anything back to GitHub.
1 other project uses a version of this.
Adopted by
Most recently taken up by
- zhouycheng/skillsword for word, first seen Oct 13, 2026
Other versions1 project uses a version of this.
Word for word · 1
- zhouycheng/skills★ 1100% same
Edited · 0
None found.
Wrote their own version · 0
None found.
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository28 other files it gives its agents.
- brandalfSkill
- check-impl-against-specSkill
- complainSkill
- councilSkill
- create-prSkill
- cross-critiqueSkill
- diagnose-ci-failuresSkill
- fix-errorsSkill
- implement-specsSkill
- merge-riskSkill
- migrate-to-factorySkill
- pr-walkthroughSkill
- readoutSkill
- reproduce-bug-reportSkill
- researchSkill
- resolve-merge-conflictsSkill
- review-prSkill
- sagaSkill
- scan-new-specsSkill
- skill-doctorSkill
- spec-driven-implementationSkill
- suggestion-boxSkill
- update-skillSkill
- validate-changes-match-specsSkill
- write-feature-docsSkill
- write-pr-descriptionSkill
- write-product-specSkill
- write-tech-specSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
33 rules. About 0 are common, 25 are distinctive, and 8 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈25
Distinctive · estimate
This author's own choices. Worth a look.
8
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 17
Do not refetch comments unless the loaded context is missing essential fields such as comment body, author, URL, path, or line metadata.
- Distinctive: line 18
Do not post GitHub replies, submit reviews, or resolve threads until the final preview is approved by the user.
- Distinctive: line 24
Before asking for response mode, filter the loaded comments down to actionable comments that still need the user's attention.
- Distinctive: line 41
When unsure whether a comment is automated, already answered, or still actionable, keep it in the walkthrough rather than skipping it.
- Very specific: line 49
Before discussing individual comments, call ask_user_question with exactly one mode question:
- Distinctive: line 55
Use the selected mode for the rest of the workflow.
- Distinctive: line 80
If the fix is not obvious from the loaded context, inspect the relevant files before presenting options.
- Very specific: line 81
Call ask_user_question with options tailored to the specific comment.
- Distinctive: line 85
Always include options with these meanings:
- Very specific: line 92
Use the Other... option's freeform field for custom responses or approaches.
- Distinctive: line 94
When the user selects "explain", provide concise context about the comment, why the reviewer likely raised it, and what tradeoffs are …
- Distinctive: line 98
When the user selects "acknowledge without changes", give them the option to provide more information about why no code changes are being …
- Distinctive: line 116
Follow the user's selected mode:
- Distinctive: line 125
Follow repository-specific coding, testing, and style rules.
- Distinctive: line 126
Run the narrowest useful validation after each one-by-one fix, and run final validation after all fixes are applied.
- Distinctive: line 127
If a requested fix is unsafe, ambiguous, or conflicts with another comment, stop and ask the user before editing.
- Distinctive: line 131
After all accepted fixes are applied:
- Distinctive: line 134
Run relevant formatting, linting, typechecking, build, or tests based on the repository's conventions and the files changed.
- Distinctive: line 135
If validation cannot be run, explain why in the final summary and include that caveat in the preview.
- Distinctive: line 137
Do not commit changes unless the user explicitly asks.
- Very specific: line 141
After validation and before posting any GitHub replies or resolving review threads, ask whether the user wants to commit the changes and …
- Distinctive: line 143
If there are no working tree changes from addressing comments, skip the commit/push question and continue to the GitHub reply preview.
- Very specific: line 145
Call ask_user_question with options like:
- Distinctive: line 152
If the user chooses to commit and push:
- Very specific: line 155
Ask for or propose a concise commit message if one is not already clear.
- Distinctive: line 158
If commit or push fails, stop before posting GitHub replies and report the failure.
- Distinctive: line 162
After the commit/push decision is complete, and before posting anything to GitHub, show a preview grouped by comment.
- Distinctive: line 167
commit link, when a pushed commit exists for the fix
- Distinctive: line 177
If the user chooses to edit, collect their edits, update the preview, and ask for approval again.
- Very specific: line 181
Use the GitHub CLI only after approval.
- Very specific: line 183
Before running any GitHub CLI command that posts a reply or PR comment, verify the outgoing body begins with [Warp Agent].
- Distinctive: line 256
If a comment cannot be replied to or resolved through the available metadata, report the limitation and suggest a manual GitHub action …
- Distinctive: line 260
After posting approved responses and resolving approved threads, summarize:
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 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.
Files
Respond to PR comments in blocklist
Use this skill to respond to PR comments on the current branch. If comments are already visible in the conversation, typically from the built-in /pr-comments skill, continue from that context. If comments are not already visible, fetch and display them first, then guide the user through each actionable comment, collect an explicit decision, make requested code changes, and only then ask for approval before posting GitHub replies or resolving review threads.
When not to use this skill
Skip this skill when the user only wants PR comments fetched or displayed (use pr-comments instead) or only wants the underlying code changes made, with no intent to post replies or resolve threads on GitHub. Read this skill only once the user has confirmed they want replies posted or threads resolved.
Preconditions
- Work in the repository checkout for the PR branch.
- Do not refetch comments unless the loaded context is missing essential fields such as comment body, author, URL, path, or line metadata.
- Do not post GitHub replies, submit reviews, or resolve threads until the final preview is approved by the user.
If no PR comments are present in context, fetch and display them before continuing. Prefer invoking the built-in /pr-comments workflow when available. Otherwise use the equivalent GitHub CLI fallback: identify the current PR, fetch PR-level comments, review comments, and review bodies, then display them with insert_code_review_comments. After displaying fetched comments, ask the user whether to continue with this response workflow before making changes.
Comment filtering
Before asking for response mode, filter the loaded comments down to actionable comments that still need the user's attention.
Skip these comments without asking the user about them:
- Automated PR-level overview or status comments from Warp/Oz/code-review bots, especially comments with no attached file location that summarize review status, check progress, or say no code change is requested.
- Comments that have already been responded to by the current GitHub user.
To identify the current GitHub user, prefer:
GH_PAGER="" gh api user --jq .loginFor review threads, use reply_metadata.parent_comment_id, thread metadata, resolution state, and comment ordering from the loaded context when available. Skip the original comment and thread only when the thread is already resolved or when the latest relevant reply in that thread was authored by the current GitHub user. If a reviewer added a newer follow-up after the current user's reply, keep the thread in the walkthrough. For PR-level comments without explicit thread metadata, skip only when the loaded context clearly shows a current-user response to that specific comment, such as a direct reply, quote, link, or immediately following response that references it.
If an automated or already-answered comment is skipped, keep a short internal skipped list with the comment URL and reason. Do not create decision records for skipped comments, do not include them in the per-comment walkthrough, and do not include them in the final GitHub reply/resolution preview except as a brief skipped-count summary.
When unsure whether a comment is automated, already answered, or still actionable, keep it in the walkthrough rather than skipping it.
Ask User Question requirements
Every ask_user_question call in this skill must include an Other... option that uses the tool's freeform other field. Use that option to let the user enter a custom mode, response, rationale, posting instruction, or next step without returning control in normal chat solely to collect custom text.
Initial mode selection
Before discussing individual comments, call ask_user_question with exactly one mode question:
Respond one-by-oneCollect all decisions, then address in a batchOther...
Use the selected mode for the rest of the workflow.
One-by-one mode
For each comment, collect the user's decision and immediately perform any requested code change before moving to the next comment. After each change, keep a note of:
- the comment being addressed
- what code or documentation changed
- what validation was run or still needs to run
- the draft GitHub reply and whether the thread should be resolved
Batch mode
For each comment, interactively collect the user's decision without editing code yet. Batch mode does not batch or skip the information-gathering phase: the user must still be able to ask for more context, request an explanation, inspect the referenced code, or provide a custom approach for any individual comment before deciding. After all comments have a decision, apply the requested code changes in one batch, then validate and prepare the final GitHub reply preview.
Per-comment walkthrough
Process comments in the order they were displayed. For each comment:
- Restate the relevant context briefly:
- author
- file and line or PR-level location
- a clickable file reference formatted as
path:linefor single-line comments orpath:start-endfor ranged comments when location metadata is available - a concise summary of the comment
- any obvious code context needed to understand it
- If the fix is not obvious from the loaded context, inspect the relevant files before presenting options.
- Call
ask_user_questionwith options tailored to the specific comment.
When a comment is attached to code, print the file reference before asking the question so the user can quickly open the relevant section. Use repository-relative paths, for example src/lib.rs:42 or src/lib.rs:40-48. For PR-level comments with no file location, state that there is no attached code location.
Always include options with these meanings:
- Apply the agent's recommended fix for this comment.
- Explain what this comment means before deciding.
- Acknowledge the comment but do not make code changes.
Other...
Use the Other... option's freeform field for custom responses or approaches. Do not return control to the user in normal chat solely to collect custom freeform text.
When the user selects "explain", provide concise context about the comment, why the reviewer likely raised it, and what tradeoffs are involved. Then ask about the same comment again with updated options; do not skip the decision.
This explanation loop applies in both one-by-one mode and batch mode. In batch mode, only the eventual code edits and GitHub comment updates are deferred; per-comment information gathering remains interactive.
When the user selects "acknowledge without changes", give them the option to provide more information about why no code changes are being made. Preserve any provided rationale for the final GitHub reply draft.
Decision records
Maintain an internal decision record for every comment. Each record should include:
- comment identifier or URL
- comment type: review-thread comment, thread reply, PR-level comment, or review body
- selected disposition: fix, explain-then-fix, acknowledge-without-changes, custom, or no-action
- planned code change, if any
- validation needed
- draft reply body
- whether to resolve the review thread
For draft replies, be concise and concrete. Prefer replies that say what changed or why the comment is intentionally not addressed. Prefix every draft reply that may be posted to GitHub with [Warp Agent] so reviewers can clearly see the response was agent-authored. If the fix has already been committed and pushed before replies are posted, include a link to the commit that resolved the comment so the response is auditable.
Applying fixes
Follow the user's selected mode:
- In one-by-one mode, edit and validate each accepted fix before continuing to the next comment.
- In batch mode, wait until all comment decisions are collected, then make all accepted edits together.
When making changes:
- Apply only changes related to the selected PR comments.
- Preserve unrelated local changes.
- Follow repository-specific coding, testing, and style rules.
- Run the narrowest useful validation after each one-by-one fix, and run final validation after all fixes are applied.
- If a requested fix is unsafe, ambiguous, or conflicts with another comment, stop and ask the user before editing.
Final validation
After all accepted fixes are applied:
- Review
git diffto confirm the changes match the collected decisions. - Run relevant formatting, linting, typechecking, build, or tests based on the repository's conventions and the files changed.
- If validation cannot be run, explain why in the final summary and include that caveat in the preview.
Do not commit changes unless the user explicitly asks.
Commit and push before GitHub responses
After validation and before posting any GitHub replies or resolving review threads, ask whether the user wants to commit the changes and push them to origin. This order ensures reviewers see pushed code before they see agent-authored comment responses.
If there are no working tree changes from addressing comments, skip the commit/push question and continue to the GitHub reply preview.
Call ask_user_question with options like:
Commit and push these changes to origin before posting repliesDo not commit or push; continue to the GitHub reply previewStop before posting GitHub repliesOther...
If the user chooses to commit and push:
- Review
git statusand the final diff so only intended comment-response changes are included. - Ask for or propose a concise commit message if one is not already clear; preserve the
Other...option for custom commit instructions. - Stage the intended changes, commit in a non-interactive command, and push the current branch to
origin. - Include
Co-Authored-By: Warp Agent <agent@warp.dev>in the commit message (never in a PR description), and do not add it again if the commit already has one. - If commit or push fails, stop before posting GitHub replies and report the failure.
GitHub reply and resolution preview
After the commit/push decision is complete, and before posting anything to GitHub, show a preview grouped by comment. For each comment include:
- comment URL or short identifier
- action: reply only, resolve only, reply and resolve, or no GitHub action
- reply body
- commit link, when a pushed commit exists for the fix
- validation relevant to that comment
Then call ask_user_question to ask whether to proceed:
Post replies and resolve approved threadsEdit the draft responses firstDo not post anythingOther...
If the user chooses to edit, collect their edits, update the preview, and ask for approval again. Do not post until the user selects the approval option.
Posting with GitHub CLI
Use the GitHub CLI only after approval. Clear the pager for all gh commands.
Before running any GitHub CLI command that posts a reply or PR comment, verify the outgoing body begins with [Warp Agent]. If it does not, add the prefix before posting.
For review comments, post replies with the REST API endpoint. Write the reply body to a temporary JSON file and pass it with --input instead of putting the response text directly in command-line arguments:
REPLY_BODY_FILE="$(mktemp)"
cat > "$REPLY_BODY_FILE"
REPLY_PAYLOAD_FILE="$(mktemp)"
python3 - "$REPLY_BODY_FILE" "$REPLY_PAYLOAD_FILE" <<'PY'
import json
import sys
from pathlib import Path
body_file = Path(sys.argv[1])
payload_file = Path(sys.argv[2])
payload_file.write_text(json.dumps({"body": body_file.read_text()}))
PY
GH_PAGER="" gh api \
--method POST \
/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies \
--input "$REPLY_PAYLOAD_FILE"
rm -f "$REPLY_BODY_FILE" "$REPLY_PAYLOAD_FILE"For PR-level comments or review-body comments that cannot be directly threaded, post a normal PR comment and quote or link to the original comment:
REPLY_BODY_FILE="$(mktemp)"
cat > "$REPLY_BODY_FILE"
GH_PAGER="" gh pr comment {pull_number} --body-file "$REPLY_BODY_FILE"
rm -f "$REPLY_BODY_FILE"To resolve review threads, use GraphQL. If the thread node ID is not already known, query all review threads for the PR and map loaded comment IDs to their containing thread. Use pagination so threads beyond the first 100 can still be resolved:
GH_PAGER="" gh api graphql --paginate \
-f owner="{owner}" \
-f repo="{repo}" \
-F number={pull_number} \
-f query='
query($owner: String!, $repo: String!, $number: Int!, $endCursor: String) {
repository(owner: $owner, name: $repo) {
pullRequest(number: $number) {
reviewThreads(first: 100, after: $endCursor) {
pageInfo {
hasNextPage
endCursor
}
nodes {
id
isResolved
comments(first: 100) {
nodes {
databaseId
url
}
}
}
}
}
}
}'Resolve an approved thread with:
GH_PAGER="" gh api graphql \
-f threadId="$THREAD_ID" \
-f query='mutation($threadId: ID!) { resolveReviewThread(input: { threadId: $threadId }) { thread { id isResolved } } }'If a comment cannot be replied to or resolved through the available metadata, report the limitation and suggest a manual GitHub action instead of guessing.
Final response
After posting approved responses and resolving approved threads, summarize:
- comments addressed
- files changed
- validation results
- whether changes were committed and pushed to
origin - GitHub replies or resolutions posted
- anything left for the user
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
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.

