More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Code Review & PR Polish

    1

    Senior-level code review + polished pull request descriptions. Catches bugs, security issues, performance problems and writes clear PRs.

    $7

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Code Review & PR Polish

    Code Review & PR Polish

    Example session with this skill installed

    Review the following changes and write a polished PR description:

    + function processPayment(userId, amount) {
    +   const user = db.query("SELECT * FROM users WHERE id = " + userId);
    +   if (user.balance > amount) {
    +     user.balance -= amount;
    +     db.save(user);
    +     return true;
    +   }
    +   return false;
    + }
    
    • Read your context and instructions
    • Compiled the code review

    Code Review Report

    Summary

    This payment processing function contains a critical SQL injection vulnerability and lacks proper error handling and atomicity. High risk if deployed.

    Critical & High Issues

    • [Critical] processPayment — SQL injection via string concatenation in the query
      Suggested fix: Use parameterised queries / prepared statements.

    • [High] processPayment — No transaction / locking around balance check and update
      Suggested fix: Wrap the read-modify-write in a database transaction to prevent race conditions.

    • [High] processPayment — No authentication or authorisation check that the caller can act on this userId.

    Medium Issues

    • [Medium] Missing input validation for amount (negative values, zero, non-numeric).
    • [Medium] No logging or audit trail for payment attempts.

    Low / Nit Suggestions

    • [Low] Function name could be more specific (e.g. deductUserBalance).
    • [Nit] Consider returning a result object instead of bare boolean for richer error information.

    Positive Notes

    Simple and readable structure. Easy to follow the happy path.

    Test Coverage Assessment

    No tests visible for this new function. Critical paths (success, insufficient funds, invalid user, concurrent requests) should be covered.


    Pull Request Description

    Summary

    Adds basic payment processing function that deducts from a user’s balance.

    Changes

    • New processPayment(userId, amount) function

    Motivation

    Enable core payment deduction flow for the billing feature.

    Testing

    • Manual testing of success and insufficient-balance paths performed.
    • Unit tests still needed for edge cases and concurrency.

    Checklist

    • Code follows project style
    • Tests added/updated
    • No secrets committed
    • Documentation updated if needed
    • Breaking changes noted (if any)

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

    About this skill

    Ship better code faster with senior-engineer quality reviews.

    Code Review & PR Polish performs a structured, severity-ranked code review and generates professional pull request descriptions in one pass.

    What the skill checks

    • Security (injection, secrets, auth, data exposure)
    • Correctness & edge cases
    • Performance (N+1, hot paths, memory)
    • Maintainability & style
    • Test coverage gaps

    Every review is delivered with clear severity levels (Critical → Nit) and actionable suggestions.

    When you need a PR description, it produces a clean, professional template covering Summary, Changes, Motivation, Testing and Checklist.

    Perfect for

    • Individual developers who want a second pair of eyes
    • Teams that want consistent review quality
    • AI coding agents that need strong review standards
    • Anyone writing pull requests regularly

    Works with Claude Code, Cursor, Codex CLI, Grok and every agent supporting the open SKILL.md standard.

    One-time purchase. Instant install. Lifetime access.

    • Does not execute or run the code — analysis is static only.
    • Cannot access private repositories or external systems unless the user provides the relevant code/diff.
    • Severity ratings are based on best judgment and may vary by project context and risk tolerance.
    • Very large diffs may receive a high-level summary first, with deeper focus on the most critical files.
    • Language and framework-specific nuances are covered for common stacks, but highly specialized or obscure frameworks may need additional human review.
    • Does not replace formal security audits or penetration testing for high-stakes production systems.

    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

    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 2 months ago

    Requires

    Git

    Permissions

    Terminal / Shell
    Listed2 months ago

    What's inside

    Frequently Asked Questions

    This skill is designed to work with most leading AI agents that support code input or Git integration; you simply provide the code diff or file content, and it returns the structured review and description.

    Unlike generic prompts, this skill uses a specialized senior-engineer framework that prioritizes logic and security risks over stylistic 'nits,' ensuring critical vulnerabilities aren't lost in the noise.

    The skill generates a multi-dimensional audit report categorized by severity (Critical to Nit) and a professional PR description including a change log and testing checklist.

    Setup is near-instant; once added to your agent's workspace, you can immediately begin pasting diffs or linking repositories to trigger the review process.

    Yes, the skill is highly effective at auditing AI-generated snippets, as it is specifically tuned to detect common patterns of hallucination and insecure defaults often found in generated code.

    While the skill can analyze large diffs, its depth is limited by your AI agent's context window; for the best results on massive PRs, we recommend processing one logical module at a time.

    Those tools review diffs as they land in your IDE or CI. This is a skill for your agent (Claude Code, Cursor, or anything that reads SKILL.md) — it runs on your terms, mid-conversation, with a fixed structure and severity system every time, and it doubles as a PR-description writer. If you already get consistent, well-structured output from what you have, you don't need this. If your reviews come back as an unstructured wall of text, or you're tired of writing PR descriptions by hand, this fixes that.

    You can absolutely do that. What this adds is consistency: the same severity taxonomy (Critical/High/Medium/Low/Nit), the same checklist across security, correctness, performance, and tests every single time, plus a matching PR-description template — instead of a fresh, differently-shaped review every time you ask. It's the difference between a habit and a one-off prompt.

    No single tool should be your only line of defense, and this one isn't. It's good at catching the patterns that show up constantly in real code — missing auth checks, injection risks, obvious race conditions, N+1 queries — the same things a competent human reviewer scans for. It will miss subtle, business-logic-specific vulnerabilities that require deep context, and it is not a substitute for a real security audit or SAST/DAST tooling on anything security-critical.

    It happens with any LLM-based review, and this skill can't eliminate that risk entirely. The instructions explicitly tell it not to invent issues and to flag when it's working from a limited scope (e.g., a single pasted snippet). In practice, treat every flagged issue as a lead to verify, not a verdict — the same way you'd treat a junior reviewer's comments.

    It's language-agnostic by design — the checklist (security, correctness, performance, maintainability, tests) applies to any codebase. It doesn't ship language-specific static-analysis rules, so it won't catch framework-specific footguns the way a dedicated linter/plugin for that ecosystem would.

    [Fill in to match your actual listing terms — this needs to match whatever pricing/update policy you've set on the marketplace, not be assumed here.]

    New in Code Quality & Review