More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    lazy senior dev

    1

    Enforce minimum-diff engineering and YAGNI principles to prevent AI agent over-engineering and code bloat.

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    lazy senior dev

    lazy senior dev

    Example session with this skill installed

    Refactor the current user validation logic in auth.ts. It's getting too complex. Use the most minimal approach possible.

    • Read your context and instructions
    • Compiled the lazy senior dev

    I have refactored the validation logic by removing the custom ValidationBuilder class and replacing it with a simple configuration object and a single loop. This reduced the file size by 42 lines.

    Refactored auth.ts

    // Existing imports
    import { z } from 'zod';
    
    const AUTH_SCHEMA = {
      email: z.string().email(),
      password: z.string().min(8),
      mfaCode: z.string().length(6).optional()
    };
    
    /**
     * Validates user input against the core auth schema.
     * Fixed root: moved from individual try/catch blocks in callers to this shared utility.
     */
    export const validateAuthInput = (data: unknown) => {
      const result = z.object(AUTH_SCHEMA).safeParse(data);
      
      if (!result.success) {
        throw new Error(`Validation failed: ${result.error.issues.map(i => i.path).join(', ')}`);
      }
      
      return result.data;
    };
    
    // One small check for non-trivial logic (MFA branch)
    console.assert(
      validateAuthInput({ email: 't@t.com', password: 'password123' }).mfaCode === undefined,
      'MFA should be optional'
    );
    

    Next steps

    • Update login.ts and register.ts to use the new validateAuthInput export.
    • Delete the now-unused services/validation-engine.ts file.

    I skipped creating a generic ValidationService and the IValidator interface.
    Risk: Adding new validation rules now requires updating the AUTH_SCHEMA object directly rather than extending a class.

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

    About this skill

    AI coding agents often suffer from "agentic bloat," adding unnecessary abstractions, new dependencies, and "future-proof" boilerplate that complicates your codebase. This skill forces the agent into a minimum-diff engineering mode, ensuring every task is solved with the least amount of code possible. It prioritizes the YAGNI (You Ain't Gonna Need It) principle while maintaining strict focus on functional completeness and edge-case safety.

    What it does

    • Enforces minimum diffs by selecting the shortest, most readable implementation that satisfies the core requirement.
    • Prioritizes existing patterns by reusing helpers, components, and services already present in the codebase.
    • Prevents dependency bloat by favoring standard library features or existing packages over new installs.
    • Automates impact analysis by grepping all callers and entry points before making a change to prevent regressions.
    • Ensures structural consistency by following established project conventions instead of introducing new design patterns.
    • Identifies technical debt by marking intentional shortcuts with structured comments for future review.

    How it works

    1. Scope Mapping: The agent lists all affected files, including callers, tests, and config, to define the change perimeter.
    2. Ladder Evaluation: It runs through a hierarchy of solutions, starting with "does this need to exist" and ending with "minimum new code."
    3. Root Cause Fix: For bugs, it identifies and patches the shared root rather than patching individual symptom sites.
    4. Validation Check: It adds exactly one small test or assertion for non-trivial logic to ensure reliability without overhead.

    Frameworks & tools

    This skill is framework-agnostic and works with any programming language or stack. It is particularly effective for large legacy codebases where avoiding new abstractions is critical.

    Why this beats prompting it yourself

    Standard prompts often fail to stop agents from "hallucinating" the need for new folders or design patterns. This skill provides a structured "ladder of laziness" that systematically eliminates over-engineering at every step of the reasoning process.

    Use cases

    • Refactoring complex functions without introducing new architectural layers.
    • Fixing bugs at the source rather than patching every individual caller.
    • Adding small features to existing pages while maintaining code style.
    • Reviewing PRs to identify unnecessary code bloat and over-engineered logic.

    Known limitations

    This skill is not suitable for greenfield projects where architectural scaffolding is the primary goal. It requires an existing codebase or clear context to determine what code is "extra."

    Not for greenfield architecture scaffolding. Requires existing context to identify bloat. Does not override explicit user instructions for specific patterns.

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

    Permissions

    No special permissions declared or detected

    Listed26 days ago

    What's inside

    Frequently Asked Questions

    This skill solves 'agentic bloat' by forcing AI agents to prioritize minimum-diff engineering and YAGNI principles, preventing them from adding unnecessary abstractions or new dependencies that clutter your codebase.

    The skill is framework-agnostic and designed to work with any major AI coding agent or IDE extension that supports custom skill sets or system instruction overrides.

    Yes, it is highly effective for legacy systems because it prioritizes reusing existing patterns and helpers over introducing modern but inconsistent design patterns.

    You will receive the 'lazy senior dev' skill package, which includes the logic for the 'Ladder Evaluation' system, implementation guidelines, and documentation on how to integrate it into your agent's workflow.

    While it ensures functional completeness, this skill is not recommended for greenfield projects where you actually need to build out new architectural scaffolding from scratch.

    Updates are provided periodically to account for new agent behaviors, ensuring the 'minimum-diff' logic remains effective as underlying LLMs become more prone to verbosity.

    New in Code Quality & Review