clean-code

Enforce SOLID, DRY, KISS, and YAGNI coding standards with naming and function rules.

Updated Mar 7, 2026
One-click install
npx skills add https://github.com/devon87warren-afk/eboss-monorepo --skill clean-code-devon87warren-afk
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/devon87warren-afk/eboss-monorepo/tree/main/apps/manager/.agent/skills/clean-code
Command: npx skills add https://github.com/devon87warren-afk/eboss-monorepo --skill clean-code-devon87warren-afk

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill enforces pragmatic coding standards to ensure code is maintainable, readable, and efficient, preventing over-engineering and unnecessary complexity.

Core Features & Use Cases

  • Enforces SOLID principles: Promotes Single Responsibility, DRY, KISS, and YAGNI.
  • Standardizes Naming Conventions: Ensures clear and intent-revealing names for variables, functions, and constants.
  • Optimizes Function Design: Guides developers to write small, focused functions with minimal arguments and no side effects.
  • Promotes Clean Structure: Encourages guard clauses, flat code, and composition over deep nesting.
  • AI Coding Style: Directs AI agents to write code directly, fix bugs, and ask clarifying questions when requirements are unclear.
  • Pre-edit Checks: Mandates thinking about file dependencies and potential impacts before making changes.
  • Post-completion Self-Checks: Ensures all requirements are met, code is functional, and tests pass before task completion.
  • Mandatory Script Verification: Outlines specific scripts for various specialists to run for validation and error reporting.

Quick Start

Use the clean-code skill to refactor the provided UserService.ts file to adhere to the Single Responsibility Principle.

Frequently Asked Questions about clean-code

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I refactor code to follow clean code standards and SOLID principles?

Refactoring code to meet clean code standards involves enforcing Single Responsibility, DRY, KISS, and YAGNI principles. This process standardizes naming conventions and optimizes function design to ensure your code is maintainable, readable, and efficient.

What is the best way to prevent over-engineering and unnecessary complexity in software development?

Preventing over-engineering requires applying pragmatic programming rules like YAGNI and KISS. By enforcing strict function design rules and promoting flat code with guard clauses over deep nesting, this approach keeps your codebase concise and direct.

How do I structure functions to improve code quality and readability?

Improving code quality through function design requires writing small, focused functions with minimal arguments and no side effects. Clean code standards mandate using clear, intent-revealing names and guard clauses to maintain a flat, readable structure.

Can AI agents apply coding standards and perform pre-edit checks when fixing bugs directly?

Yes, AI agents can apply coding standards by writing code directly and fixing bugs while mandating pre-edit impact analysis. They must analyze file dependencies and potential impacts before changes, followed by post-completion verification to ensure tests pass.

Why does my refactored code fail validation after applying clean code principles?

Refactored code fails validation when mandatory script execution is skipped or post-completion self-checks are neglected. Ensuring all requirements are met, code is functional, and relevant specialists run validation scripts prevents these failures.

Do I need to clarify requirements before an AI agent starts writing clean code?

Yes, clarifying requirements before writing clean code is essential when project goals are unclear. AI agents guided by pragmatic programming standards are directed to ask clarifying questions to prevent unnecessary complexity and ensure accurate, direct coding.