PR-Slop-Buster: AI Code Bloat & Dependency Auditor

    1

    Detect and remove AI-generated code bloat, redundant dependencies, and over-engineered boilerplate.

    $19

    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 CLIMuseMuseDotsDots+21 more

    PR-Slop-Buster: AI Code Bloat & Dependency Auditor

    Example session with this skill installed

    Audit this authentication module PR diff for AI-generated code bloat, unnecessary dependencies, and mock abuse before I submit it for code review.

    • Read your context and instructions
    • Compiled the pr-slop-buster

    I have completed the audit of your authentication module. The implementation shows signs of AI-generated over-engineering, particularly in the token handling logic and test suite.

    PR Slop Scorecard: 42% (Moderate Bloat)

    Audit CategoryStatusFindingRecommendation
    Dependency🚩 FailImported lodash.merge for a single object update.Use native { ...spread } or Object.assign().
    Abstraction⚠️ WarningAuthServiceFactoryInterface found for a single provider.Flatten to a simple functional export.
    Testing🚩 Failexpect(service).toBeDefined() is the only test case.Add functional tests for JWT expiration logic.
    Comments✅ CleanNo redundant parrot comments detected.N/A

    Actionable Refactoring

    // BEFORE: AI-generated boilerplate
    import _ from 'lodash';
    export class AuthProviderFactory {
      public static create() {
        return new AuthProvider();
      }
    }
    const config = _.merge({}, defaultOptions, userOptions);
    
    // AFTER: Minimalist implementation
    export const authProvider = new AuthProvider();
    const config = { ...defaultOptions, ...userOptions };
    

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

    About this skill

    AI coding assistants often hallucinate unnecessary abstractions, add redundant dependencies, and generate shallow tests that inflate coverage without adding value. This skill acts as a ruthless staff engineer review lens, identifying and stripping away AI-generated bloat before your code hits production.

    What it does

    • Dependency auditing flags heavy external libraries like lodash or moment when native standard library alternatives exist.
    • Tautological test detection catches mock abuse and tests that assert truth without verifying actual state mutations.
    • Boilerplate decoupling identifies premature abstractions such as over-engineered factories or unnecessary singleton patterns.
    • Comment pruning removes parrot comments that merely rephrase variable names without adding architectural context.
    • Slop indexing assigns a percentage score to your diff to quantify code quality and maintenance burden.

    How it works

    1. Input Analysis: The agent scans your git diff or specific source files for common AI-generated anti-patterns.
    2. Scoring: It calculates a Slop Index Score from 0% to 100% based on detected bloat and dependency inflation.
    3. Audit Reporting: It generates a structured PR Slop Scorecard detailing every violation.
    4. Refactoring: The agent provides specific minimalist code replacements to simplify the implementation.

    Frameworks & tools

    This skill is language-agnostic but optimized for modern ecosystems like Node.js (npm), Python (pip), and TypeScript. It works directly within AI-powered IDEs and CLI tools.

    Why this beats prompting it yourself

    General-purpose models often hesitate to criticize their own output or suggest removing code they just wrote. This skill enforces a specific minimalist constraint that prioritizes lower cognitive load over impressive-looking boilerplate.

    Use cases

    • Auditing AI-assisted pull requests for hidden maintenance debt.
    • Replacing heavy legacy dependencies with modern native one-liners.
    • Cleaning up over-engineered wrappers in new feature branches.
    • Verifying that test suites actually test logic rather than just mocks.

    Known limitations

    This skill focuses on code structure and bloat. It does not perform deep security vulnerability scanning or complex runtime performance profiling.


    Focuses on structural bloat and dependencies. Does not perform security vulnerability scanning or runtime performance profiling. Requires a git diff or source file access to function.

    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 1 month ago

    Permissions

    Read Files
    Terminal / Shell

    Runs locally to inspect code diffs and git changes. Requires zero network access or external credentials.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    It identifies and removes "AI slop," such as unnecessary design patterns (factories/singletons), redundant npm/pip dependencies that have native alternatives, and hollow tests that inflate coverage without actually verifying logic.

    The skill is language-agnostic but features specialized optimizations for Node.js, TypeScript, and Python ecosystems, where AI-generated dependency bloat is most common.

    Unlike general models that often favor verbosity, this skill uses a "minimalist constraint" logic to prioritize low cognitive load and codebase maintainability over impressive-looking boilerplate.

    The Slop Index is a percentage score from 0% to 100% that quantifies the maintenance burden of a diff, where a higher score indicates a higher density of redundant or low-value code.

    Yes, it is designed to run directly within AI-integrated IDEs and CLI tools, allowing you to audit your git diffs locally before you even push to your repository.

    The purchase includes the full skill logic, regular updates to the anti-pattern detection library, and a perpetual license for use across your personal or organizational projects.

    New in Code Quality & Review