Skip to content
Skills Library
Programming · Automation

git-pr-feedback

/git-pr-feedback

Fetch, triage, and address PR review comments from GitHub Copilot and human reviewers. Use when the user asks to check PR feedback, review comments, address reviewer suggestions, or fix PR issues. Trigger on: "check PR comments", "what did copilot say", "address PR feedback", "fix review comments", "handle PR suggestions", "review feedback", "PR comments", "copilot review", "reviewer feedback", or any mention of responding to pull request comments. Also trigger when the user returns to a PR after some time and wants to handle accumulated feedback.

Licence
MIT
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Fetch, triage, and address PR review comments from GitHub Copilot and human reviewers. Use when the user asks to check PR feedback, review comments, address reviewer suggestions, or fix PR issues. Trigger on: "check PR comments", "what did copilot say", "address PR feedback", "fix review comments", "handle PR suggestions", "review feedback", "PR comments", "copilot review", "reviewer feedback", or any mention of responding to pull request comments. Also trigger when the user returns to a PR after some time and wants to handle accumulated feedback.

Triggers from the description

check PR commentswhat did copilot sayaddress PR feedbackfix review commentshandle PR suggestionsreview feedbackPR commentscopilot review
Original author description

Fetch, triage, and address PR review comments from GitHub Copilot and human reviewers. Use when the user asks to check PR feedback, review comments, address reviewer suggestions, or fix PR issues. Trigger on: "check PR comments", "what did copilot say", "address PR feedback", "fix review comments", "handle PR suggestions", "review feedback", "PR comments", "copilot review", "reviewer feedback", or any mention of responding to pull request comments. Also trigger when the user returns to a PR after some time and wants to handle accumulated feedback.

How it works

  1. Workflow
  2. Handling Specific Reviewer Types
  3. Edge Cases
Original SKILL.md headings · 179 lines, 985 words
SKILL.md preview
---
name: git-pr-feedback
version: 1.4.0
description: >
  Fetch, triage, and address PR review comments from GitHub Copilot and human
  reviewers. Use when the user asks to check PR feedback, review comments,
  address reviewer suggestions, or fix PR issues. Trigger on: "check PR
  comments", "what did copilot say", "address PR feedback", "fix review
  comments", "handle PR suggestions", "review feedback", "PR comments",
  "copilot review", "reviewer feedback", or any mention of responding to pull
  request comments. Also trigger when the user returns to a PR after some time
  and wants to handle accumulated feedback.
requires_agent_teams: false
requires_claude_code: false
min_plan: starter
owns:
  directories: []
  patterns: []
  shared_read: ["*"]
allowed-tools: ["Read", "Write", "Edit", "Bash", "Grep"]
composes_with: ["git-pr", "git-commit", "git-post-merge-cleanup", "babysit"]
spawned_by: []
---

# PR Feedback Handler

Fetch review comments on a GitHub PR, triage them, fix what's clear, ask about
what's ambiguous, and reply to each comment on GitHub with what was done.

## Workflow

### 1. Identify the PR

Determine the PR number from context:

```bash
# Current branch's PR
gh pr view --json number -q .number

# Or from a URL the user provided
# Or from a specific PR number they mentioned
```

### 2. Fetch All Comments

Pull both review comments (inline on code) and issue-level comments:

```bash
# Inline review comments (from Copilot and reviewers)
gh api --paginate repos/{owner}/{repo}/pulls/{pr}/comments

# General PR comments (not on specific lines)
gh api --paginate repos/{owner}/{repo}/issues/{pr}/comments

# Review summaries
gh api --paginate repos/{owner}/{repo}/pulls/{pr}/reviews
```

Use `--paginate` to ensure all comments are returned — the default page size
is 30, which can silently miss comments on large PRs.

Parse each comment to extract:

- **who**: `user.login` — distinguish `Copilot`, `copilot-pull-request-reviewer[bot]`, and human reviewers
- **where**: `path` and `line` — the file and line the comment targets
- **what**: `body` — the feedback text
- **id**: `id` — needed for replying
- **thread state**: use paginated GraphQL `reviewThreads` and join `comments.nodes.databaseId` to REST comment IDs. Author replies are context only, never resolution. Issue comments have no review-thread resolution flag; triage them explicitly.

```bash
gh api graphql --paginate -F owner='{owner}' -F repo='{repo}' -F number='{pr}' \
  -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 isOutdated comments(first:100){nodes{databaseId body author{login}} pageInfo{hasNextPage endCursor}}}}}}}'
```

Fetch additional comment pages for any thread whose nested `pageInfo.hasNextPage` is true. If API auth/pagination/state lookup fails, mark unresolved status UNKNOWN and stop automatic skipping; never infer resolution from a reply or `isOutdated`.

### 3. Triage Each Comment

Classify every comment into one of these categories:

| Category | Action | Example |
|----------|--------|---------|
| **Bug** | Fix immediately | "This glob won't match broken symlinks" |
| **Improvement** | Fix if straightforward, ask if complex | "Exit code should be non-zero for errors" |
| **Doc issue** | Fix immediately | "The doc says X but the code does Y" |
| **Style/nit** | Fix if trivial, skip if subjective | "Consider renaming this variable" |
| **Noise/false positive** | Dismiss with explanation | "This is intentional because..." |
| **Ambiguous/tricky** | Present to user with options | "This could be fixed multiple ways..." |

**Triage guidelines:**

- Read the actual code the comment references before deciding. The diff context
  in the comment may be stale after pushes.
- Copilot comments are usually technically accurate but sometimes miss context.
  Verify before acting.
- Human reviewer comments carry more weight. Treat these as higher priority.
- If a comment suggests a significant design decision, always escalate to the user.

### 4. Present the Triage

Before making changes, show the user a summary:

```text
PR #34 — 3 review comments:

1. [BUG] Copilot on sync-skills.sh:426
   Broken symlink glob — --clean uses */ which skips broken symlinks
   → Will fix: change glob to /*

2. [IMPROVEMENT] Copilot on sync-skills.sh:101
   usage exits 0 on invalid options
   → Will fix: exit 1 for unknown options

3. [DOC] Copilot on SKILL.md:78
   Doc claims non-repo skills untouched but name collisions get replaced
   → Will fix: clarify the wording

Ready to fix all 3? Or want to discuss any of them?
```

For items classified as **ambiguous/tricky**, present the options and wait for
the user's decision before proceeding.

### 5. Implement Fixes

For each actionable comment:

1. Read the file at the referenced path and line
2. Make the fix
3. Stage the changed files by name (not `git add -p` — interactive staging
   doesn't work in automated environments)

After all fixes are applied, commit following git-commit conventions:

```bash
git add path/to/fixed-file1 path/to/fixed-file2
git commit -m "$(cat <<'EOF'
fix: address review feedback on {context}

{brief description of changes}
EOF
)"

git push
```

### 6. Reply to Comments on GitHub

For each comment, post a reply using the GitHub API:

```bash
# Reply to an inline review comment (threaded)
gh api repos/{owner}/{repo}/pulls/{pr}/comments/{comment_id}/replies \
  -f body="Fixed in {sha} — {brief description of what changed}."

# Reply to a general PR comment (post a new issue comment)
gh api repos/{owner}/{repo}/issues/{pr}/comments \
  -f body="Re: {summary of original comment} — Fixed in {sha}."
```

Reply content by category:

- **Bug/Improvement/Doc**: "Fixed in {short sha} — {what changed}."
- **Noise/false positive**: "This is intentional — {reason}."
- **Style adopted**: "Good catch, fixed in {sha}."
- **Style declined**: "Keeping as-is — {reason}."

### 7. Check for New Comments

After pushing fixes, Copilot may generate new comments on the updated code.
Don't block waiting for them — let the user know they can ask to check again
later.

## Handling Specific Reviewer Types

### GitHub Copilot

- Copilot review is *requested* immediately when a PR is created or updated,
  but comments can take 30 seconds to several minutes to appear.
- Usually catches real issues: bugs, edge cases, doc inconsistencies.
- Sometimes suggests changes that miss project-specific context — verify first.
- May not comment at all on markdown-only or trivial PRs.

### Human Reviewers

- May not appear immediately — check back when the user asks.
- Comments may be conversational rather than prescriptive.
- Look for approval/changes-requested status in the reviews endpoint.
- If a reviewer requested changes, prioritize their comments.

## Edge Cases

- **Unresolved review threads vs author replies**: An author reply does NOT equal
  resolution. Check thread status directly (`isResolved: true` or review thread state);
  never skip a review comment merely because someone replied to it without resolving.
- **Outdated comments**: After pushing fixes, read the file fresh — don't
  trust the diff context in the comment.
- **Multiple commits**: Batch fixes into one commit unless the fixes are
  logically independent enough to warrant separate commits.
- **No comments yet**: If fetching after PR creation and getting zero comments,
  that's normal — let the user know and offer to check again later.

Versions

RepositoryScoreLicence
This page · ivy00johns/skill-madness100MIT
laurigates/claude-plugins100MIT

Database snapshot: 13.11.2026 · package version c12ec1469b1a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100review-pr-comments
    Use when the user wants to address, process, or work through GitHub PR review comments. Trigger on phrases like "address PR comments", "work through review comments", "process PR feedback", "apply reviewer suggestions", or "/review-pr-comments <number>".
  • 100address-pr-comments
    Address PR review comments by fixing code, replying to each comment, and re-requesting review. Use this skill when the user wants to handle, fix, resolve, or address PR feedback, review comments, or code review suggestions. Also use when the user says things like "fix the PR…
  • 100github-pr-review
    Handles PR review comments and feedback resolution. Use when user wants to resolve PR comments, handle review feedback, fix review comments, address PR review, check review status, respond to reviewer, verify PR readiness, review PR comments, analyze review feedback, evaluate PR…
  • 100feedback
    Fetch unresolved review comments on a GitHub PR (Copilot and human), verify against the code, classify Address / Skip / Optional / Discuss. Use when asked to triage reviewer feedback, which comments to actually fix, or to sort signal from noise on a PR. Don't use to reply to or…
  • 90address-pr-comments
    Address review comments (including Copilot comments) on the active pull request. Use when: responding to PR feedback, fixing review comments, resolving PR threads, implementing requested changes from reviewers, addressing code review, fixing PR issues.
  • 100review-pr-comments
    Address review comments on a GitHub pull request — fetch unresolved comments, investigate each issue, fix valid ones, reply, and resolve threads. Use this skill when the user asks to review PR comments, address PR feedback, handle PR review, respond to reviewer comments, or fix…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.