- Home
- Skills
- Code Quality & Review
- Paid Code Reviewer — Severity-Rated Diff & PR Review
Paid Code Reviewer — Severity-Rated Diff & PR Review
Severity-rated code review for diffs and PRs: blockers first, evidence with paths, confirm before edits.
$24
Works with the AI Agents you already use
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.tsline 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.tsline 115 - Evidence: The
try/catchblock 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
- Apply the suggested fix for the cache race condition.
- Refactor
client.tsto properly propagate database exceptions. - 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
- Scope definition The agent identifies the target diff, branch, or PR and confirms the desired review depth.
- Defect gathering It parses changed files to find race conditions, insecure defaults, or broken logic.
- Risk triage Findings are sorted by severity, leading with merge-blocking issues.
- 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.
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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
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
Requires