Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    bix-claude-skills: GitHub PR Review

    1

    Review a GitHub PR, rank findings by severity, and post a batched pending review after you approve each comment.

    Free

    2 usesSecurity scanned
    bix-claude-skills: GitHub PR Review

    bix-claude-skills: GitHub PR Review

    Example session with this skill installed

    Review PR #42 in parallel mode. Make sure to check against our performance guidelines in .claude.md.

    or run the below commands in claude code.

    /github-pr-review 482
    
    • Read your context and instructions
    • Compiled the bix-claude-

    I reviewed PR #482 ("Add token refresh to the auth client") in the acme-api repo. The PR changes 6 files and has 410 diff lines, so I used single mode. I drafted 4 findings: 1 Critical, 1 Warning and 2 Nits. One of them is tagged Pre-existing. The PR is open and not a draft, and you have not reviewed it before. Project rules were read from CLAUDE.md.

    Approval prompts, shown one at a time with the options Post / Skip / Modify:

    [Critical] Comment 1 - `src/auth/refresh.ts` line 20: Missing null check on refresh token
    
    `refreshToken` can be `undefined` when the user has signed out, so `token.trim()` throws. Return early when it is missing.
    
    ```suggestion
    
    

    if (!refreshToken) return null;

    [Warning] Comment 2 - src/auth/refresh.ts line 55: Query runs inside a loop

    getUser is called once per retry. Move it above the loop and reuse the result.

    [Nit] Comment 3 - src/config.ts line 8: Unnamed number

    3600 is the token lifetime in seconds. Give it a name such as TOKEN_TTL_SECONDS, like the other settings in this file.

    [Warning] [Pre-existing] Comment 4 - src/db/users.ts line 30: Unchecked input in SQL

    The email is joined into the query string. This line was not changed in this PR. Use a parameterized query.

    
    **Summary after approval**
    
    

    Posted: Comment 1 (src/auth/refresh.ts:20) [Critical], Comment 3 (src/config.ts:8) [Nit]
    Skipped: Comment 2 (src/auth/refresh.ts:55) [Warning], Comment 4 (src/db/users.ts:30) [Warning] [Pre-existing]
    Event type: REQUEST_CHANGES

    
    Ready to submit the review with 2 comments? Submit / Cancel. On Submit, the review was created as pending on the latest commit, then submitted as REQUEST_CHANGES because a Critical comment was posted. Final count: 2 posted, 2 skipped, with the PR link at the end.
    
    **Next steps**
    - Ask the author to fix the Critical comment, then run `/github-pr-review 482` again.
    - Open a separate issue for the pre-existing SQL input problem.
    - Use `-parallel` on very large PRs.
    
    not reviewed it before. Project rules were read from CLAUDE.md

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

    About this skill

    Manual code reviews are slow, prone to oversight, and often inconsistent across team members. This skill automates the heavy lifting of PR analysis by auditing diffs against five specific categories: correctness, conventions, performance, security, and tests. It identifies logic errors, naming violations, and security vulnerabilities while respecting your project-specific rules.

    What it does

    • Multi-category auditing evaluates code for logic errors, performance bottlenecks, security risks, and style consistency.
    • Parallel processing uses subagents to analyze massive pull requests quickly without hitting context limits.
    • Pre-existing issue detection uses git blame to distinguish between new bugs and legacy code issues.
    • Interactive approval presents each finding for your review, allowing you to edit, skip, or approve comments before they go live.
    • Batched submission bundles all approved feedback into a single GitHub "Pending Review" to avoid notification spam.

    How it works

    1. Trigger the review by providing a PR number and optional parallel flag for large diffs.
    2. The agent analyzes the diff, incorporating any local .claude.md or review guidelines to ensure project alignment.
    3. Review the drafted findings one by one, deciding whether to post, skip, or modify the feedback.
    4. Finalize the batch review, which the agent submits via the GitHub API with the appropriate status (Request Changes, Comment, or Approve).

    Frameworks & tools

    This skill utilizes the GitHub CLI (gh), Git for blame operations, and standard shell utilities. It is designed for use within Claude Code or similar environments with filesystem and terminal access.

    Why this beats prompting it yourself

    Generic prompts often miss context or produce hallucinated line numbers. This skill implements rigorous line-counting logic, merges findings from specialized subagents, and integrates directly with your local Git history to ensure feedback is both accurate and relevant to the PR branch.

    Use cases

    • Auditing mission-critical PRs for subtle logic errors and security vulnerabilities.
    • Enforcing consistent naming conventions and architectural patterns across a distributed team.
    • Speeding up the review cycle for large refactors by pre-screening performance hits.
    • Generating documentation gap reports for public API changes.

    Known limitations

    Requires the GitHub CLI to be authenticated and Git to be initialized in the repository. Documentation review is skipped in parallel mode and only supports specific primary languages.

    • Needs the gh CLI installed and logged in (gh auth login), plus git and python3.
    • Must run inside a git repo with a GitHub remote. It works on GitHub only.
    • Doc review covers 10 languages: JavaScript, TypeScript, Python, Go, C#, Rust, Java, Ruby, Kotlin, PHP and Swift. It is skipped when the main language is not detected or not supported.
    • The main language is picked by counting changed files by extension, so mixed-language PRs get one language for doc review.
    • Pre-existing issue detection can be inaccurate when your checked-out branch is not the PR branch. The skill warns you in that case.
    • Parallel mode starts 6 sub-agents and uses more tokens. The doc agent is skipped when the language is unsupported.
    • It only comments on lines visible in the diff. Issues outside the diff are noted but not included in the review.
    • Findings come from the model reading the diff. They are not a replacement for a human review.

    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

    2 uses

    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

    File Scopes

    <repo>/CLAUDE.md
    <repo>/REVIEW.md
    <repo>/**

    The skill needs the shell to call `gh` and `git`, and network access to read the PR and create the review. It reads CLAUDE.md and REVIEW.md to follow your team rules. It never edits your code, never pushes commits, and never posts a comment or submits a review without your approval.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill uses Git Blame to differentiate between code you just wrote and legacy code already in the main branch. This ensures you only receive feedback on your current changes, preventing the agent from flagging pre-existing issues you aren't responsible for.

    Yes, the skill is designed to read local `.claude.md` files and project-specific review guidelines. This allows it to enforce your team's specific naming conventions, architectural patterns, and coding standards automatically.

    For large PRs, the skill uses a parallel processing mode that deploys subagents to analyze different parts of the diff simultaneously. This prevents context window limitations and significantly speeds up the audit of massive refactors.

    This skill requires an environment with terminal access, such as Claude Code, and necessitates that the GitHub CLI (`gh`) is installed and authenticated on your machine. It also requires a local Git initialization to perform history and blame checks.

    Unlike generic prompts, this skill includes a built-in interactive stage where you can edit, skip, or approve every suggestion. It also uses a batched submission system to post all feedback at once, avoiding the notification spam caused by individual comments.

    Yes. If CLAUDE.md or REVIEW.md exists in the repo root, its rules are added to the review criteria and win on conflict.

    New in Code Quality & Review