Paid Code Reviewer — Severity-Rated Diff & PR Review

    1

    Severity-rated code review for diffs and PRs: blockers first, evidence with paths, confirm before edits.

    $24

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Paid Code Reviewer — Severity-Rated Diff & PR Review

    Example session with this skill installed

    Review my current git diff against main. Focus on blockers and majors.

    • Read your context and instructions
    • Compiled the paid code reviewer

    I have reviewed the uncommitted changes against the main branch. The review identified 1 Blocker and 1 Major issue related to data persistence and error handling.

    Code Review Report

    Summary: This diff is

    not ready to merge. A critical race condition in the cache initialization will cause intermittent failures under load. Additionally, a missing error check in the database connector could lead to silent data loss.

    Findings Summary

    • Blockers: 1
    • Majors: 1
    • Minors: 0
    • Nits: 0 (Omitted per "quick" depth request)

    High Severity Findings

    [BLOCKER] Race Condition in Cache Init
    • Location: src/lib/cache.ts line 42

    Evidence: The init() function checks this.ready but does not await the connection promise if a concurrent call is already in progress.

    Why it matters: Multiple callers will trigger redundant connection attempts, leading to ConnectionPoolFull errors.

    • Suggested Fix:
    if (this.connecting) return this.connectionPromise;
    this.connecting = true;
    // ... logic to set connectionPromise
    
    [MAJOR] Silent Error Swallowing in DB Write
    • Location: src/db/client.ts line 115
    • Evidence: The try/catch block logs the error but does not rethrow or return a Failure type.
    • Why it matters: The calling service assumes the write succeeded, leading to inconsistent state.
    • Suggested Fix:
    catch (err) {
      logger.error(err);
      throw new DatabaseError("Write failed", { cause: err });
    }
    

    Next steps

    1. Apply the suggested fix for the cache race condition.
    2. Refactor client.ts to properly propagate database exceptions.
    3. Verify the fix by running npm test.

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

    About this skill

    Code reviews often devolve into subjective style debates while missing critical architectural flaws or security risks. This skill enforces a severity-based triage system to catch blockers before they reach production. It prioritizes functional defects over aesthetic nits, ensuring you address high-risk issues first.

    What it does

    • Severity classification Categorizes every finding as Blocker, Major, Minor, or Nit based on functional risk.
    • Evidence-based reporting Links every issue to specific file paths and symbols with verified code evidence.
    • Merge readiness summary Provides a high-level assessment of whether the diff is safe to merge.
    • Controlled remediation Proposes specific code fixes but never modifies your source tree without explicit approval.
    • Contextual analysis Examines nearby callers and tests to ensure changes don't break existing contracts.

    How it works

    1. Scope definition The agent identifies the target diff, branch, or PR and confirms the desired review depth.
    2. Defect gathering It parses changed files to find race conditions, insecure defaults, or broken logic.
    3. Risk triage Findings are sorted by severity, leading with merge-blocking issues.
    4. Interactive fixing You review the report and instruct the agent which specific findings to automate fixes for.

    Frameworks & tools

    Works with any language or framework via Cursor, Claude Code, or CLI. Supports git and gh tools for local diffs and GitHub Pull Requests.

    Why this beats prompting it yourself

    Standard prompts often produce "praise walls" or generic advice that ignores the actual severity of a bug. This skill uses a strict rubric to ensure the agent doesn't miss silent error swallowing or security risks while distracted by variable naming.

    Use cases

    • Pre-merge audits Run a final check on a feature branch to catch blockers before opening a PR.
    • PR triaging Quickly summarize the risk level of large incoming contributions.
    • Security hardening Identify insecure defaults and race conditions in sensitive code paths.

    Known limitations

    Large diffs exceeding 40 files may require splitting by package. Analysis is static and might require manual logs for runtime confirmation.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    Diffs over 40 files require scoped reviews. Findings are based on static analysis; runtime bugs may require manual log verification. Requires git or gh CLI for full context.

    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 buying a skill.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    Software
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed27 days ago

    What's inside

    Frequently Asked Questions

    Unlike standard AI prompts that often focus on stylistic preferences, this skill uses a strict severity-based rubric to prioritize functional defects, security risks, and architectural blockers that could break production.

    The skill is designed for use with Cursor, Claude Code, or any CLI-based environment, leveraging `git` and `gh` tools to analyze local diffs or remote GitHub Pull Requests.

    Yes, while the agent provides evidence-based findings and suggested fixes, it follows a 'controlled remediation' protocol and will never modify your source tree without your explicit approval.

    Purchase includes the core skill configuration, documentation for local or PR-based workflows, and access to future logic updates that refine the severity triage system.

    The skill is language-agnostic and works across any framework; however, for optimal performance with very large PRs (40+ files), we recommend reviewing by package or module to maintain depth.

    New in Code Quality & Review