Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Code Reviewer For You

    1

    Technical code auditor that identifies logic bugs, security risks, and performance bottlenecks with actionable fixes.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    1 useSecurity scanned
    Code Reviewer For You

    Code Reviewer For You

    Example session with this skill installed

    Review this Node.js function:

    const getUser = async (id) => {
      const query = "SELECT * FROM users WHERE id = " + id;
      const user = await db.execute(query);
      return user[0];
    };
    
    • Read your context and instructions
    • Compiled the code reviewer

    I have reviewed the getUser function. The code contains a critical security vulnerability and lacks basic error handling for empty results.

    Findings

    [Critical] SQL Injection Vulnerability

    Location: getUser function, query string construction.
    Issue: The function uses string concatenation to build a SQL query with untrusted input id.
    Why it matters: An attacker could pass a malicious string (e.g., 1 OR 1=1) to bypass authentication or extract the entire user database.
    Recommended fix: Use parameterized queries or a prepared statement provided by your database driver.

    const getUser = async (id) => {
      const query = "SELECT * FROM users WHERE id = ?";
      const user = await db.execute(query, [id]);
      return user[0] || null;
    };
    

    [Medium] Unhandled Empty Result

    Location: return user[0];
    Issue: If the database returns an empty array, accessing user[0] returns undefined.
    Why it matters: Calling code might expect a null value or an object, and subsequent property access on undefined will throw a runtime error.
    Recommended fix: Explicitly handle the empty case by returning null or throwing a specific 404 error.

    What Looks Good

    • The function correctly uses async/await for non-blocking I/O.
    • The naming convention is clear and follows standard JavaScript practices.

    Suggested Tests

    • Injection Test: Call getUser("' OR 1=1 --") and verify the query fails or returns nothing.
    • Empty Result Test: Call getUser with a non-existent ID and ensure it returns null without crashing.

    Final Verdict

    • Overall risk: Critical
    • Priority fixes: Implement parameterized queries immediately.
    • Confidence: High

    Next steps

    1. Update the database driver calls to use prepared statements.
    2. Add a guard clause for the return value.
    3. Verify if similar concatenation patterns exist elsewhere in the data layer.

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

    About this skill

    The problem

    Static analysis tools often flood developers with trivial linting errors while missing critical logic flaws or race conditions. Manual peer reviews are slow, inconsistent, and often skip deep security or performance checks under deadline pressure.

    What it does

    • Identifies logic errors, boundary cases, and improper null/undefined handling.
    • Detects security risks including injection, secrets exposure, and unsafe deserialization.
    • Flags resource leaks, concurrency issues, and performance bottlenecks in specific code blocks.
    • Prioritizes findings by severity from Info to Critical with actionable remediation steps.
    • Generates corrected code snippets and suggests targeted unit tests for edge cases.

    Why this beats prompting it yourself

    General-purpose prompts often provide vague "clean code" advice or hallucinate security vulnerabilities. This skill follows a structured engineering workflow that distinguishes confirmed defects from architectural concerns, ensuring feedback is technical, evidence-based, and free of style nitpicking.

    Use cases

    • Pre-PR self-review to catch embarrassing logic bugs before colleagues see the code.
    • Security-focused audits for sensitive authentication or data-handling modules.
    • Refactoring legacy code to identify hidden resource leaks and maintainability debt.
    • Onboarding assistance to verify if a new implementation meets specific technical standards.

    Cannot guarantee absolute security or bug-free status via static review. Requires sufficient context to avoid false positives on missing dependencies or framework-specific behaviors.

    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

    Money-back guarantee

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

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    No special permissions declared or detected

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill is designed for deep logic and security auditing, moving beyond simple syntax checking to find race conditions, memory leaks, and injection vulnerabilities that standard linters often miss.

    The skill is optimized for mainstream backend languages including JavaScript (Node.js), Python, Go, and Java, though it can analyze most C-style syntax for logic and security flaws.

    Once added to your workspace, you simply paste your code block or file content into the agent; no complex API integrations or local environment configurations are required.

    The skill provides a structured report categorizing findings by severity (Info to Critical), accompanied by a "Before vs. After" code comparison and suggested unit tests for verification.

    Yes, as a 'For Free' skill, you receive the full auditing logic and workflow, and any future logic updates or security definition improvements are included at no additional cost.

    The skill is built to be platform-agnostic and functions across major LLM-powered agents that support custom skills or system-level instructions.

    New in Code Quality & Review