How do I install the Logic Cleaner skill?

Run npx skillmds@latest add ralvarezdev/logic-cleaner in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

What does the Logic Cleaner skill do?

Universal Logic & Code Cleanliness Standards It is listed under Coding & Dev Tools on SkillMD.

Is Logic Cleaner safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Logic Cleaner?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Logic Cleaner free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Logic Cleaner?

ralvarezdev (@ralvarezdev) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Logic Cleaner by ralvarezdev — Agent Skill

Name: Logic Cleaner
Author: ralvarezdev

File contents

Universal Logic & Code Cleanliness Standards

1. Control Flow

Flattening: Maximum 2 levels of indentation per function. Extract deeper logic into helpers.
Guard Clauses: Handle edge cases and errors at the very top with early returns. Keep the happy path left-aligned.
Fail Fast: Halt execution immediately on invalid states instead of passing nulls or error flags down the stack.

2. Conditionals

Phrasing: Enforce positive phrasing; avoid double negatives (e.g., use isPending, not isNotFinished).
Extraction: Extract conditions with more than two logical operators into well-named boolean variables or functions.
Simplification: Apply De Morgan's Laws to simplify negated compound conditions (e.g., convert !(A || B) to !A && !B).

3. State & Mutation

Scope: Declare variables as close to their first use as possible. Never shadow variables from an outer scope.
Immutability: Treat function parameters as strictly read-only. Never reassign them; assign results to new variables instead.

4. Naming

Rules: Avoid abbreviations (req, idx) unless they are universal language standards (e.g., ctx in Go). Use symmetric pairs for related concepts (start/stop, open/close).
Verbs: Function names must begin with strong, specific action verbs (e.g., CalculateTotal, not ProcessData or Handle).

5. Magic Values & Hardcoding

Constants: Extract raw strings and numbers (except 0 and 1) into named constants that explain why the value exists.
Config: Inject all environment-dependent values (timeouts, retry limits, paths) via configuration. Never hardcode them.

6. Duplication (Rule of Three)

WET vs DRY: Logic may be duplicated once without abstraction (Write Everything Twice). Refactor into a shared, generic function only upon the third occurrence (Don't Repeat Yourself).

7. Out of Scope

This skill is expression-level only — intentionally narrow. Anything broader belongs to a different skill:

Module decomposition, class hierarchies, dependency direction → code-design-refactor
Architecture-level friction, deepening opportunities → improve-codebase-architecture
API / contract design → api-contract-reviewer

If a finding requires changing module boundaries or class structure, stop and surface it — don't expand scope.

---name: logic-cleanerdescription: Universal Logic & Code Cleanliness Standards---# Universal Logic & Code Cleanliness Standards## 1. Control Flow* **Flattening:** Maximum 2 levels of indentation per function. Extract deeper logic into helpers.* **Guard Clauses:** Handle edge cases and errors at the very top with early returns. Keep the happy path left-aligned.* **Fail Fast:** Halt execution immediately on invalid states instead of passing nulls or error flags down the stack.## 2. Conditionals* **Phrasing:** Enforce positive phrasing; avoid double negatives (e.g., use `isPending`, not `isNotFinished`).* **Extraction:** Extract conditions with more than two logical operators into well-named boolean variables or functions.* **Simplification:** Apply De Morgan's Laws to simplify negated compound conditions (e.g., convert `!(A || B)` to `!A && !B`).## 3. State & Mutation* **Scope:** Declare variables as close to their first use as possible. Never shadow variables from an outer scope.* **Immutability:** Treat function parameters as strictly read-only. Never reassign them; assign results to new variables instead.## 4. Naming* **Rules:** Avoid abbreviations (`req`, `idx`) unless they are universal language standards (e.g., `ctx` in Go). Use symmetric pairs for related concepts (`start`/`stop`, `open`/`close`).* **Verbs:** Function names must begin with strong, specific action verbs (e.g., `CalculateTotal`, not `ProcessData` or `Handle`).## 5. Magic Values & Hardcoding* **Constants:** Extract raw strings and numbers (except 0 and 1) into named constants that explain *why* the value exists.* **Config:** Inject all environment-dependent values (timeouts, retry limits, paths) via configuration. Never hardcode them.## 6. Duplication (Rule of Three)* **WET vs DRY:** Logic may be duplicated once without abstraction (Write Everything Twice). Refactor into a shared, generic function only upon the *third* occurrence (Don't Repeat Yourself).## 7. Out of ScopeThis skill is **expression-level only** — intentionally narrow. Anything broader belongs to a different skill:- **Module decomposition, class hierarchies, dependency direction** → `code-design-refactor`- **Architecture-level friction, deepening opportunities** → `improve-codebase-architecture`- **API / contract design** → `api-contract-reviewer`If a finding requires changing module boundaries or class structure, stop and surface it — don't expand scope.

Frequently asked questions

Logic Cleaner