Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Switch ai Code Reviewer

    1

    Audit local git diffs for memory leaks, async bottlenecks, and exposed security keys before pushing code.

    $6

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    switch-ai-code-reviewer

    switch-ai-code-reviewer

    Example session with this skill installed

    Run triage on my latest git diff for the auth-service.js file. I am worried about the new async login flow and potential token leakage.

    • Read your context and instructions
    • Compiled the switch-ai-code-reviewer

    I have completed the triage and security audit for the auth-service.js diff.

    PR-Triage & Security Audit Report

    CategoryPriorityIssueLocationRecommendation
    SecurityCRITICALHardcoded JWT Secretline 42Remove string literal; use process.env.JWT_SECRET.
    PerformanceHIGHUnawaited Async Callline 89db.logs.save() is called without await, risking a race condition.
    MemoryMEDIUMGrowing Closure Scopeline 112Event listener inside a loop without cleanup. Move handler outside loop.
    TriageINFOLogic Changeline 55Updated password hashing rounds from 10 to 12.

    Suggested Fix for Async Bottleneck

    // Before
    async function login(user) {
      const token = generateToken(user);
      db.logs.save({ action: 'login', userId: user.id }); // Missing await
      return token;
    }
    
    // After
    async function login(user) {
      const token = generateToken(user);
      await db.logs.save({ action: 'login', userId: user.id });
      return token;
    }
    

    Next steps

    1. Move the hardcoded secret at line 42 to your .env file.
    2. Apply the await fix to the logging call to ensure data consistency.
    3. Re-run the audit tool once changes are saved to verify the fix.

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

    About this skill

    Staging messy pull requests without a second set of eyes leads to production bugs and leaked secrets. This skill audits local git diffs to catch memory leaks, async bottlenecks, and exposed credentials before you commit.

    What it does

    • Security Auditing scans code for hardcoded API keys, secrets, and common vulnerability patterns.
    • Performance Analysis identifies inefficient async/await patterns and potential memory leaks in logic.
    • Diff Triage summarizes changes and flags high-risk modifications for manual oversight.
    • Automated Refactoring suggests concrete code improvements to resolve identified bottlenecks.

    How it works

    1. Use the triage command to analyze the current staged or unstaged git diff.
    2. Review the generated audit report highlighting security risks and performance issues.
    3. Apply suggested fixes for async patterns or memory management directly to the file.
    4. Run a final audit on specific files to ensure all vulnerabilities are cleared before pushing.

    Frameworks & tools

    This tool interfaces with local git environments and uses an MCP server running on Node.js to process code analytics.

    Why this beats prompting it yourself

    Generic prompts often miss context-specific async bottlenecks or fail to scan for obscure secret patterns. This skill provides a structured audit framework designed specifically for local diff analysis and PR preparation.

    Use cases

    • Auditing a feature branch for exposed environment variables before a merge.
    • Identifying race conditions in complex asynchronous JavaScript or TypeScript logic.
    • Generating a summary of changes to assist in writing detailed pull request descriptions.
    • Reducing technical debt by catching memory leaks during the development cycle.

    Known limitations

    Requires a local git repository and Node.js environment to run the MCP server. Performance scanning is optimized for standard async patterns and may not catch every edge case in niche libraries.

    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.

    Requires local git and Node.js. Optimized for async/memory audits; might not catch logic-specific bugs in non-standard libraries.

    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 4 days ago

    Accounts
    GitHubSwitch Omni
    Software
    Node.js (v18.0.0 or higher)Git (initialized local repository)

    Permissions

    Terminal / Shell
    Network Access
    Environment Variables

    Allowed Hosts

    github.com...
    switch-omni.com
    api.github.com

    File Scopes

    **/*
    src/**/*

    This skill is a complete MCP port of the switch-ai-code-reviewer bot. It has been refactored from a centralized webhook architecture into a secure, client-side stdio MCP server designed for seamless integration with Claude Code and Cursor IDE.

    Listed4 days ago

    What's inside

    Frequently Asked Questions

    The skill audits local git diffs to catch security risks like hardcoded API keys, identifies memory leaks, and flags inefficient async/await patterns before you commit or push your code.

    This skill requires a local Git repository and a Node.js environment to run the underlying MCP server. It is compatible with any AI agent that supports the Model Context Protocol (MCP) for local file and tool interaction.

    No, the tool operates on your local git diffs and staged changes, meaning it analyzes your code locally via the MCP server before it ever reaches your remote repository.

    Upon purchase, you receive the MCP server configuration and the specific skill set designed to interface with your local development environment and git CLI.

    While the performance analysis is optimized for JavaScript and TypeScript async patterns, the security auditing and diff triage features work effectively across most text-based programming languages.

    Unlike a manual prompt, this skill uses a structured audit framework that specifically targets local diff context and known vulnerability patterns, providing more consistent and reliable results than a generic chat interaction.

    New in Code Quality & Review