- Home
- Skills
- Code Quality & Review
- make code
make code
Enforce KISS, DRY, and YAGNI principles to write, refactor, or optimize application code with low cyclomatic complexity.
Free
Works with the AI Agents you already use
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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
These permissions is required because agents must be editing the files to implemente code.