make code

    1

    Enforce KISS, DRY, and YAGNI principles to write, refactor, or optimize application code with low cyclomatic complexity.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    make code

    Example session with this skill installed

    Refactor the processOrder function in orders.js to be simpler. It currently has too many nested if-statements and handles its own database connections.

    • Read your context and instructions
    • Compiled the make code

    I have classified this as a **refactor** branch. I identified `processOrder` as the entrypoint and noted that database logic should be handled by the existing `db.js` helper rather than inside the function. I've flattened the logic using guard clauses to reduce cyclomatic complexity from 12 to 4. ## Refactored processOrder ```javascript import { saveOrder } from './db.js'; import { isValidOrder } from './validators.js'; /** * Validates and persists an order to the database. * @param {Object} order The order data to process. */ export async function processOrder(order) { if (!isValidOrder(order)) { throw new Error('Invalid order data'); } const result = await saveOrder(order); if (!result.success) { throw new Error(`Persistence failed: ${result.error}`); } return result.id; } ``` **Next steps** 1. Verify that `saveOrder` in `db.js` correctly handles the connection pooling as assumed. 2. Run the existing test suite; the `processOrder` logic now relies on externalized validation which should be verified against edge cases. 3. Remove any unused database driver imports from `orders.js`.

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

    About this skill

    Development cycles often stall due to over-engineering, scope creep, and inconsistent coding standards. This skill enforces strict software engineering principles to ensure every line of code is necessary, maintainable, and performant. It eliminates speculative features and deep nesting by prioritizing simplicity and observable proofs. ## What it does - **Classifies intent** by branching between new behavior, refactoring for simplicity, or targeted performance improvements. - **Enforces complexity caps** by limiting cyclomatic complexity (CC) to 20 or less per function to ensure readability. - **Validates existence** by checking the codebase, stdlib, and dependencies before writing new code to prevent duplication. - **Generates observable proofs** using red-green testing patterns that mock only at trust boundaries like networks or filesystems. - **Normalizes style** by tracing and matching existing project conventions, naming patterns, and documentation shapes. ## How it works 1. **Classify:** Identify if the task is a `write`, `refactor`, or `improve` branch based on whether a performance hotspot is named. 2. **Trace:** Map the entrypoints, symbols, and callers while identifying the shared root for bug fixes. 3. **Climb:** Search for the simplest implementation rung, favoring existing helpers or stdlib over new custom code. 4. **Apply:** Implement the logic following KISS, DRY, and YAGNI principles. 5. **Prove:** Write the smallest possible test to observe the behavior change. ## Frameworks & tools This skill is language-agnostic and adapts to local project tools like `eslint`, `ruff`, or `gocyclo`. It integrates with existing `AGENTS.md` or `CLAUDE.md` convention files. ## Why this beats prompting it yourself Generic prompts often produce "hallucinated" utility functions or over-engineered abstractions. This skill forces a systematic search for existing code and strictly caps cyclomatic complexity, preventing the technical debt that standard LLM outputs usually introduce. ## Use cases - **Feature implementation** where you need the minimum viable code without extra knobs or layers. - **Code refactoring** to flatten deeply nested logic and improve readability without changing behavior. - **Performance tuning** to fix specific N+1 queries, hot loops, or quadratic complexity hotspots. - **Bug fixing** by identifying and patching the shared root cause rather than applying surface-level hacks. ## Known limitations This skill skips documentation-only tasks, agent instruction updates, Makefiles, and CSS-only restyles. Performance improvements require a named hotspot to avoid speculative optimization.

    Performance improvements require a specific named hotspot. Skips documentation, Makefiles, and CSS-only styling. Standard CC cap is 20 unless the project defines its own via linting tools.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Write Files
    Read Files

    These permissions is required because agents must be editing the files to implemente code.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill enforces strict KISS, DRY, and YAGNI principles by performing a systematic search for existing helpers before writing new code, and it applies a hard cap on cyclomatic complexity to prevent the 'spaghetti code' often generated by generic prompts.

    The skill is language-agnostic and adapts to your local environment; it integrates with your existing project conventions and tools like eslint, ruff, or gocyclo to ensure the output matches your current codebase style.

    'make code' requires a named hotspot—a specific area of inefficient code—to perform optimizations, ensuring it targets real bottlenecks rather than engaging in speculative or unnecessary performance tuning.

    While it excels at logic and structure, this skill specifically skips documentation-only tasks, agent instruction files, Makefiles, and CSS-only styling to stay focused on high-integrity application logic.

    The skill uses a red-green testing pattern, generating the smallest possible test case to verify behavior changes while mocking only at essential trust boundaries like networks or filesystems.

    New in Code Quality & Review