Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    bix-claude-skills: GitHub PR Review Resolver

    1

    Triage GitHub PR comments, implement requested fixes, and sync replies directly from your terminal.

    Free

    1 useSecurity scanned
    bix-claude-skills: GitHub PR Review Resolver

    bix-claude-skills: GitHub PR Review Resolver

    Example session with this skill installed

    Resolve the review comments on PR #42. Only look at unresolved threads.

    or

    /github-pr-resolve 128
    
    • Read your context and instructions
    • Compiled the bix-claude-

    Summary: PR #128 ("Add retry to invoice export") has 3 threads awaiting your reply and 1 review summary. The skill read the current code for each, found one project rule that applies (CLAUDE.md: no magic numbers), and asked you to triage. You chose Fix for thread 1, Reply only for thread 2 and Fix for thread 3. Changes are in your working tree and are not committed.

    Review summary

    
    ### Review by @mira-dev: CHANGES_REQUESTED
    > A few small things in the export retry. Details inline.
    

    Threads

    
    ### Thread 1: src/export/retry.ts:42 (by @mira-dev) - [Agree-Fix]
    > The delay of 500 should be a named constant.
    
    Code context:
       const attempt = 0;
       while (attempt < 3) {
         await sleep(500);
    
    Assessment: Reviewer is right. The value is repeated in two places and CLAUDE.md asks for named constants.
    
    ### Thread 2: src/export/retry.ts:77 (by @mira-dev) - [Disagree]
    > Why not retry on every error?
      ↳ @tomas-r: Only network errors are safe to retry.
    
    Code context:
       if (!isNetworkError(err)) throw err;
    
    Assessment: Retrying a validation error would send the same bad invoice again. Current code is correct.
    
    ### Thread 3: src/export/csv.ts:19 (by @mira-dev) - [Agree-Fix]
    > This header list is out of order compared to the docs.
    
    Code context:
       const headers = ["id", "total", "date"];
    
    Assessment: The docs list date before total. Fix.
    

    Final summary

    
    ### Fixed
    - ✓ Thread 1 (src/export/retry.ts:42) - moved 500 to RETRY_DELAY_MS
    - ✓ Thread 3 (src/export/csv.ts:19) - reordered headers to id, date, total
    
    ### Reply only
    - Thread 2 (src/export/retry.ts:77) - [Disagree] Only network errors are retried, because other errors would fail the same way again.
    
    ### Skipped
    - None
    

    Next steps

    • Review the diff, then ask the skill to commit.
    • Confirm the push when asked.
    • Approve the drafted replies, for example: "Fixed in a1b2c3d. The retry delay is now a named constant."
    • Answer "Mark these 2 threads as resolved?" for threads 1 and 3. Thread 2 stays open for the reviewer.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Managing PR feedback manually is slow and error-prone. This skill automates the evaluation, implementation, and resolution of GitHub pull request review comments. It stops you from context-switching between your terminal and browser by pulling review threads directly into your environment.

    What it does

    • Automated Triage pulls all active review threads and categorizes them as Agree-Fix, Clarify, Disagree, or Outdated.
    • Context-Aware Evaluation reads the current file state at specific lines to verify if reviewer feedback is still applicable before you act.
    • Rule Enforcement applies local project rules and .claude/rules to ensure suggested fixes align with your codebase conventions.
    • Batch Implementation creates focused tasks to apply agreed-upon changes across multiple files and threads.
    • Thread Management posts replies to GitHub using the correct API endpoints and offers to resolve threads only after confirmation.

    How it works

    1. Gather provides the PR number to fetch all active comments, code hunks, and repository-specific coding rules.
    2. Evaluate and display: read the code at each location, categorise, show summaries then threads by file.
    3. Triage: you pick an action per thread, up to 4 threads per question.
    4. Explore: investigate chosen threads and propose an approach for your approval.
    5. Implement: apply approved fixes one at a time with task tracking.
    6. Summary: list what was fixed, replied to and skipped. Nothing is committed yet.
    7. Commit, push, reply and resolve: each step waits for your confirmation.

    Frameworks & tools

    Uses the GitHub CLI (gh) and GraphQL API for repository interaction. Compatible with any stack as it operates on raw file content and PR metadata.

    Why this beats prompting it yourself

    Manual prompting often misses the full context of a review thread or ignores repository-specific linting and architectural rules. This skill systematically reads the exact code lines referenced, triages multiple threads in batches, and ensures every reply is concise and professional without AI branding.

    Use cases

    • Closing out large PRs with dozens of minor style and logic suggestions.
    • Defending architectural decisions by citing project rules in Disagree replies.
    • Responding to outdated comments after a rebase or significant refactor.

    Known limitations

    Requires the GitHub CLI to be authenticated. Performance may degrade with PRs exceeding 30 active threads, requiring file-by-file processing.

    • Requires gh installed and logged in, and python3.
    • Must run inside a git repo with a GitHub remote.
    • Triage is interactive, so it is not suited to unattended runs.
    • By default only unresolved threads whose last comment is not yours are shown. Use -all to include the rest.
    • With more than 30 threads it shows a per-file table first and works file by file.
    • Fixes are not committed automatically. Commit, push, replies and resolving each need your confirmation.
    • It never resolves Clarify or Disagree threads, since the reviewer answers those.
    • Does not expand scope. Extra issues found during a fix are noted and you are asked first.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Read Files
    Network Access
    Write Files

    File Scopes

    <repo>/**

    The gather script only writes to stdout and a temporary folder it deletes on exit. Replies, pushes and thread resolution happen only after you approve them. It does not read secret files or manage credentials itself.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill automates the process of reading pull request comments, comparing them against your current local code, and automatically generating fixes or replies. It solves the issue of manual context-switching between your browser and terminal while ensuring all feedback is addressed systematically.

    You will need the GitHub CLI (`gh`) installed and authenticated on your local machine. The skill uses your existing GitHub permissions to fetch PR metadata and post replies, so no additional third-party tokens are required.

    The skill is language-agnostic and works with any project where your code is hosted on GitHub. It is designed to work with any AI agent that supports file-system access and terminal execution.

    Yes, the skill reads your local `.claude/rules` or project-specific guidelines to ensure that any automated fixes it proposes align perfectly with your existing architectural and styling standards.

    Yes the skill can handle large PRs, although it will use parallel mode to dispatch sub-agents with enough context for reviewing each topic, saving tokens and context usage from the main model.

    Yes. Add `-all`, for example `/github-pr-resolve 128 -all`.

    Yes. It loads CLAUDE.md, REVIEW.md and `.claude/rules/*.md` from the repo root and from folders above commented files, and checks fixes against them.

    It labels the thread Disagree and drafts a short reply with the reason. It does not agree just to avoid friction.

    New in Code Quality & Review