Skip to content
Skills Library
Programming · Building & coding

fix

/fix

This skill should be used when the user asks to "fix PR comments", "fix review feedback", "fix PR #123", "address review comments", "resolve PR feedback", "apply review suggestions", "handle PR feedback", or wants to automatically process unresolved review threads on a pull request by fixing code, creating issues, or dismissing comments.

Licence
MIT
Last repository change
16.07.2026

Assessment and security

84/ 100Class: good
Format9 / 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
2
Deprecation

No signals detected. Repository changed on 16.07.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

This skill should be used when the user asks to "fix PR comments", "fix review feedback", "fix PR #123", "address review comments", "resolve PR feedback", "apply review suggestions", "handle PR feedback", or wants to automatically process unresolved review threads on a pull request by fixing code, creating issues, or dismissing comments.

Triggers from the description

fix PR commentsfix review feedbackfix PR #123address review commentsresolve PR feedbackapply review suggestionshandle PR feedback

Arguments

/fix <pr-number>
Original author description

This skill should be used when the user asks to "fix PR comments", "fix review feedback", "fix PR #123", "address review comments", "resolve PR feedback", "apply review suggestions", "handle PR feedback", or wants to automatically process unresolved review threads on a pull request by fixing code, creating issues, or dismissing comments.

How it works

  1. Helper Scripts
  2. Workflow
  3. Decision Guidelines
  4. Important Guidelines
  5. Script Reference
Original SKILL.md headings · 267 lines, 1,324 words
SKILL.md preview
---
description: This skill should be used when the user asks to "fix PR comments", "fix review feedback", "fix PR #123", "address review comments", "resolve PR feedback", "apply review suggestions", "handle PR feedback", or wants to automatically process unresolved review threads on a pull request by fixing code, creating issues, or dismissing comments.
argument-hint: "<pr-number>"
disable-model-invocation: true
allowed-tools: Bash, Read, Write, Edit, Grep, Glob
---

# GitHub PR Review Fixer

Process unresolved review threads on a pull request. A single thread may contain multiple distinct topics (e.g., "fix the null check here, also the error handling module should be refactored, and the naming looks fine"). For each thread, identify every distinct topic and independently decide the appropriate action per topic: fix the code, create a new issue, or dismiss with no action. After all actions are taken, reply to each thread with a consolidated report covering every topic.

**Action types:**

| Action | Description |
|--------|-------------|
| **fix** | Make code changes to address the reviewer's concern and commit |
| **new issue** | Create a GitHub issue to track the problem for later |
| **won't fix** | No action needed (minor suggestion, style preference, or already addressed) |

## Helper Scripts

This skill uses shared helper scripts in `scripts/` at the plugin root:

| Script | Purpose |
|--------|---------|
| `fetch-review-threads.sh` | Fetch review threads from a PR with optional filtering |
| `post-reply.sh` | Post a reply to a review thread |

## Workflow

### Step 1: Fetch Actionable Threads

Fetch unresolved review threads that need attention:

```bash
PR_NUMBER=$ARGUMENTS
bash ${CLAUDE_PLUGIN_ROOT}/scripts/fetch-review-threads.sh $PR_NUMBER --filter-resolved --filter-skill fix
```

This returns JSON with:
- `owner`, `repo`, `prNumber`: Repository context
- `threads`: Array of threads requiring action
- `totalCount`: Number of actionable threads

Each thread contains:
- `id`: Thread ID for posting replies (e.g., `PRRT_xxx`)
- `path`: File path in the repository
- `line`, `startLine`: Line numbers in the file
- `comments.nodes`: Array of all comments in the thread

If no actionable threads are found (`totalCount: 0`), report that no action is needed.

### Step 2: Analyze Each Thread and Identify Topics

For each thread, read all comments, examine the code context, and identify every distinct topic raised. A single thread may contain multiple independent concerns — each one gets its own action.

1. **Read all comments**: Parse `comments.nodes` to understand the full conversation
2. **Examine the code**: Read the file at `path` around `line` to understand the context
3. **Analyze the codebase**: Use Grep and Glob to understand related patterns
4. **Identify distinct topics**: Break the thread into separate, independent concerns. Each topic is a single actionable point (e.g., "fix the null check", "refactor error handling", "naming looks fine").
5. **Decide action per topic**: For each topic independently, choose one of:
   - **fix** - The concern is valid and can be addressed with a code change now
   - **new issue** - The concern is valid but requires broader changes, is out of scope for this PR, or needs further discussion
   - **won't fix** - The suggestion is a minor style preference, already addressed, or not applicable

Build a list of `(topic, action)` pairs for each thread. A thread with three topics might produce: `("fix null check", fix)`, `("refactor error handling", new issue)`, `("naming convention", won't fix)`.

### Step 3: Execute Actions

Process each topic according to its decided action. A single thread may produce multiple actions (e.g., two fixes and one new issue). Track all actions taken for the summary.

#### Action: fix

1. Read the file and understand the issue
2. Make the necessary code changes using Edit or Write tools
3. Commit the change with a descriptive message:

```bash
git add <changed-files>
git commit -m "Fix: <brief description of the fix>

Addresses review comment on <file>:<line> in PR #$PR_NUMBER"
```

4. Record: file changed, line, brief description of fix

#### Action: new issue

Create a GitHub issue with context from the review thread:

```bash
gh issue create --title "<concise title describing the problem>" --body "$(cat <<EOF
## Context

Raised in review of PR #$PR_NUMBER

**File**: `<path>`
**Line**: <line>

## Problem

<description from the review comment>

## Suggested Approach

<any suggestions from the thread or initial thoughts on how to address>

---
*Issue created with [Claude Code](https://claude.ai/code) - github-devflow:fix*
EOF
)"
```

Record: issue number, issue URL, brief description

#### Action: won't fix

No code changes or issue creation needed. Record: brief reason why no action was taken.

### Step 4: Reply to Each Thread

After executing all actions, post a **single reply per thread** that covers every topic identified in that thread.

Structure the reply with one section per topic, using this format:

```
**<topic description>**: <action taken>

<details for this topic>
```

Use the appropriate detail format for each action type:

- **fix**: `Fixed in commit <sha>. <brief description of the change made>`
- **new issue**: `Created issue #<number> to track this. <issue URL>`
- **won't fix**: `No action taken: <brief explanation>`

Example reply for a thread with three topics:

```
**Fix null check on user input**: fix

Fixed in commit abc1234. Added null guard before accessing `user.name`.

**Refactor error handling module**: new issue

Created issue #42 to track this. https://github.com/owner/repo/issues/42

**Naming convention**: won't fix

No action taken: current naming follows the project's established conventions.
```

Post each reply using:

```bash
mkdir -p /tmp/github-devflow:fix/${REPO}/${PR_NUMBER}
# Write reply body to /tmp/github-devflow:fix/${REPO}/${PR_NUMBER}/reply.md
bash ${CLAUDE_PLUGIN_ROOT}/scripts/post-reply.sh --skill fix --file "<thread-id>" /tmp/github-devflow:fix/${REPO}/${PR_NUMBER}/reply.md
```

For threads with a single topic where the reply is short, inline form is also acceptable:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/scripts/post-reply.sh --skill fix "<thread-id>" "<reply-body>"
```

### Step 5: Push and Report Summary

Push all commits to the remote branch:

```bash
git push
```

Provide a summary of all actions taken:

- Total threads processed
- Total topics identified across all threads
- Number of fixes committed (with commit SHAs)
- Number of issues created (with issue numbers and URLs)
- Number of topics dismissed
- Any errors encountered

## Decision Guidelines

### When to "fix"

- Bug identified in the code
- Missing error handling or validation
- Incorrect logic or behavior
- Missing or wrong documentation in code
- Simple refactoring suggestions (rename, extract, simplify)

### When to "new issue"

- The fix requires changes outside this PR's scope
- Significant refactoring or architectural changes
- Performance improvements that need benchmarking
- Feature requests or enhancements
- Issues that need further discussion or design

### When to "won't fix"

- Pure style preferences with no functional impact
- The concern was already addressed in another commit
- The reviewer's suggestion contradicts project conventions
- Questions that were already answered in the thread
- Comments that are informational, not actionable

## Important Guidelines

### Commit Discipline

- One commit per topic that receives a "fix" action, for clear traceability
- Reference the PR number in each commit message
- Only stage files that were intentionally changed

### Code Quality

- Follow existing code patterns and conventions
- Make minimal, focused changes to address the specific concern
- Do not introduce unrelated changes alongside the fix

### Temp File Usage

- When creating temp files, use only the `/tmp/github-devflow:fix/` directory

### Error Handling

- If `gh` CLI is not authenticated, inform the user to run `gh auth login`
- If the PR number is invalid, report the error clearly
- If a fix attempt fails, skip that thread, report the error, and continue with remaining threads
- If `git push` fails (e.g., due to branch protection rules or authentication), inform the user of the error and suggest manual resolution
- If posting a reply fails, report the error and continue

## Script Reference

### fetch-review-threads.sh

```
Usage: fetch-review-threads.sh <pr-number> [--filter-resolved] [--filter-skill <name>]

Options:
  --filter-resolved    Filter out resolved threads
  --filter-skill <name>  Filter out threads where the latest
                         comment contains the specified skill's signature
                         (github-devflow:<name>)

Output: JSON with repository info and thread array
```

### post-reply.sh

```
Usage: post-reply.sh [--skill <name>] <thread-id> <body>
       post-reply.sh [--skill <name>] --file <thread-id> <body-file>

Options:
  --skill <name>  Include skill identifier in signature
                  (e.g., --skill fix → "github-devflow:fix")

Arguments:
  thread-id   The GraphQL ID of the review thread (e.g., PRRT_xxx)
  body        The reply message text
  body-file   Path to a file containing the reply message

Note: Automatically appends a "Claude Code" signature to identify
      AI-generated replies for filtering in subsequent runs.

Output: JSON with success status and comment details
```

Versions

RepositoryScoreLicence
This page · hhiroshell/gh-devflow-plugins84MIT
swingerman/engineer100MIT
Hainrixz/claude-seo-ai100MIT
vanducng/skills100MIT
RemiPelloux/kill-my-idea100MIT
tony/skills100MIT
applelog/nondev-kit100MIT
A7-studio/jobmigo100MIT
koda-ai-studio/agent-bom100Apache-2.0

Database snapshot: 13.11.2026 · package version b32400d461d5 (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
    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…
  • 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…
  • 100pr-comment-fix
    Automate fixing GitHub PR review comments. Use this skill whenever the user asks to "fix PR comments", "address review feedback", "resolve PR threads", or references a PR number/branch with unresolved review comments. Also trigger when the user says things like "go through the…
  • 95pr-comment-resolver
    Automate PR comment review, fix, and resolution workflow with atomic commits. Use when the user asks to "handle PR comments", "resolve PR review comments", "fix PR feedback", "process review comments", "address PR suggestions", "deal with review comments", or provides a GitHub…
  • 100git-pr-feedback
    Address PR review comments and resolve threads. Use when CHANGES_REQUESTED is set, working through unresolved review threads, or replying to reviewer feedback.
  • 100v1-address-review
    Use when resolving existing PR review comments or threads. Triggers on "address review feedback", "fix review comments", or "resolve review threads".

Feedback and reports

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