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."

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

    Listed5 days ago

    What's inside

    Frequently Asked Questions