Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    AI Code Bloat Eliminator Pro - Less code. Same behavior.

    1

    Find unnecessary abstractions, duplicate logic, dead code, and overengineering in AI-generated code, with safe, behavior-preserving refactoring recommendations.

    $12.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    AI Code Bloat Eliminator Pro - Less code. Same behavior.

    AI Code Bloat Eliminator Pro - Less code. Same behavior.

    Example session with this skill installed

    Use AI Code Bloat Eliminator Pro in Deep mode to review this repository for unnecessary complexity introduced during AI-assisted development.

    Look for excessive abstractions, redundant wrappers, duplicated logic, unnecessary defensive checks, dead code, redundant state, and dependency bloat.

    Trace actual callers, dependencies, and behavior contracts before recommending changes. Identify complexity that should be preserved, especially anything related to security, error handling, compatibility, or concurrency.

    Prioritize findings by maintenance value and refactoring risk. Include exact file locations, minimal simplification proposals, and regression-test recommendations.

    Review only. Do not modify files, install dependencies, or execute the application.

    • Read your context and instructions
    • Compiled the ai code bloat

    AI Code Bloat Review

    Executive Summary

    Reviewed the TypeScript checkout-pricing example for unnecessary implementation complexity. Identified one confirmed simplification opportunity involving redundant factory, interface, and facade layers.

    The existing calculation can be expressed directly without changing the public function signature or intended pricing behavior.

    Review mode: Standard
    Action: Review only — no files modified
    Method: Static source analysis
    Tests executed: None

    Findings Overview

    StatusCount
    Confirmed1
    Likely0
    Needs verification1
    Not assessed1

    CBE-001 — Unnecessary Factory and Facade Layers

    Priority: P2
    Evidence: Confirmed within the example
    Change risk: Low within the example
    Category: Excessive abstraction

    Location: examples/demo-overengineered.ts:9-40

    Problem

    The checkout price calculation passes through several internal abstractions:

    checkoutTotal → PricingFacade → PriceComputer → calculateTotal

    The implementation contains an interface, a concrete implementation, a factory, and a facade, even though the example has only one calculation strategy.

    Inspection of the example found no alternative implementations, additional policies, or meaningful behavior within these intermediary layers.

    Recommended Simplification

    Replace the internal delegation chain with a direct calculation:

    export function checkoutTotal(cart: Cart): number {
      return Math.max(
        0,
        cart.subtotalCents +
          cart.shippingCents -
          cart.discountCents
      );
    }
    

    Expected improvement: Fewer internal concepts, simpler call flow, and less code to maintain.

    No runtime performance improvement is claimed.

    Behavior That Must Be Preserved

    • The exported Cart type and checkoutTotal signature
    • Identical pricing formula and zero-clamping behavior
    • Existing number semantics and edge cases
    • Compatibility with existing callers

    Recommended Regression Tests

    1. Compare results for positive, zero, and negative totals.
    2. Verify fractional inputs and boundary values.
    3. Check NaN and Infinity behavior.
    4. Confirm that the public TypeScript interface remains unchanged.

    Verification status: Tests proposed, not executed.

    Complexity Worth Keeping

    The zero-clamping operation is intentional observable behavior. Removing it could produce negative checkout totals and would not be a behavior-preserving simplification.

    The public function and exported type should also remain unchanged.

    Additional Verification

    Before applying an equivalent simplification to a production repository, check for dependency injection, runtime registration, external consumers, and compatibility requirements that may justify the abstraction.

    Recommended Next Steps

    1. Confirm there are no unobserved consumers of the internal layers.
    2. Add or identify characterization tests for the pricing calculation.
    3. Apply the smallest possible refactoring.
    4. Run the authorized type checks and regression tests.
    5. Review the final diff for unintended behavior changes.

    Final assessment: One actionable simplification identified in the assessed example. No source files were changed, and no performance or correctness guarantees are claimed without further verification.

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

    About this skill

    Less code bloat. Better software. Same behavior.

    AI coding agents are excellent at generating code, but they can also introduce unnecessary interfaces, factories, wrappers, defensive checks, and layers of abstraction. The code works, but becomes increasingly difficult to understand, maintain, and extend.

    AI Code Bloat Eliminator Pro turns your coding agent into a disciplined code simplification reviewer. It identifies unnecessary complexity, investigates why it exists, and recommends the smallest safe refactoring without sacrificing functionality.

    What it detects

    • Unnecessary abstractions: Excessive interfaces, factories, service layers, and pass-through wrappers.
    • Duplicated logic: Repeated implementations that could safely share a simpler solution.
    • Defensive code bloat: Redundant checks, repeated validation, and unnecessary error-handling layers.
    • Dead and obsolete code: Unused implementations, stale fallbacks, and unnecessary compatibility paths.
    • Redundant state: Duplicated caches, unnecessary synchronization, and avoidable transformations.
    • Dependency bloat: Overlapping libraries and unnecessary external utilities.
    • Accidental complexity: Overengineered workflows, speculative extensibility, and avoidable performance overhead.

    Three review modes

    Quick: Focused review of pull requests and recently changed code.

    Standard: Systematic examination of unnecessary complexity across relevant modules.

    Deep: Cross-module architectural analysis, compatibility considerations, and staged refactoring plans.

    What makes it different?

    Most AI refactoring prompts simply ask for shorter or cleaner code. This skill takes a more rigorous approach.

    Before recommending a change, it examines the implementation, callers, dependencies, and behavior contracts. It also identifies complexity that should remain, such as necessary security checks, public interfaces, transaction boundaries, and concurrency safeguards.

    Every actionable recommendation includes file-and-line evidence, priority, change risk, proposed simplification, and a validation plan.

    Designed for AI-assisted development

    Works with compatible coding agents and supports TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, Swift, Dart, and other languages through source-level analysis.

    Includes a lightweight, dependency-free Python inventory helper, reusable review templates, and structured Markdown/JSON reports.

    Read-only by default. The skill only modifies code when explicitly requested. It does not promise automatic performance gains or arbitrary reductions in lines of code.

    The goal isn't the shortest code. It's the simplest implementation that correctly solves the problem.

    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.

    This skill provides evidence-driven code reviews, not guaranteed automatic optimization.

    Static analysis may not reveal dynamically registered code, reflection, external consumers, deployment constraints, or undocumented compatibility requirements. Some recommendations therefore require additional verification.

    The included Python inventory helper identifies large files and repeated source patterns, but is not a full AST-based analyzer and cannot independently determine whether code is safe to remove.

    Behavior preservation cannot be guaranteed without adequate tests and runtime verification. Performance gains, reduced maintenance costs, and specific code-reduction percentages are not guaranteed.

    The skill is read-only by default. Implementation, test execution, and dependency installation require appropriate authorization. Results depend on the connected agent's capabilities and accessible repository context.

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

    Software
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    src/**
    packages/**
    tests/**
    scripts/**
    lib/**

    The skill requires read access to the buyer-authorized source repository for code analysis. Terminal access is optional for running the bundled read-only Python inventory helper. Write access is used only when the buyer explicitly requests refactoring. Static reviews require no network access, credentials, or environment variables. The inventory excludes common sensitive and generated paths, but does not replace repository-specific access controls or follow all .gitignore rules. Tests, builds, dependency installation, and other project execution require separate authorization.

    Listed27 days ago

    What's inside

    Frequently Asked Questions

    No. The default mode is read-only. It analyzes your code and recommends improvements. Changes are made only when you explicitly request refactoring.

    Instead of blindly shortening code, the skill uses a structured review process. It checks callers, dependencies, compatibility requirements, and existing behavior before recommending changes. It also identifies complexity that should be preserved.

    The skill is language-agnostic and includes guidance for TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, Swift, and Dart. Review quality depends on the connected agent's understanding of the language and available repository context.

    No automated review can guarantee semantic equivalence. The skill minimizes risk by documenting behavior contracts, identifying compatibility concerns, and recommending regression tests. Changes should be verified before deployment.

    Quick focuses on pull requests and recently changed code. Standard performs a broader review of unnecessary complexity. Deep examines cross-module architecture, compatibility, and staged refactoring opportunities. All three modes remain read-only unless changes are explicitly requested.

    New in Code Quality & Review