clean-code

Enforces pragmatic coding standards for AI agents to ensure maintainable code.

1|Updated Dec 13, 2025
One-click install
npx skills add https://github.com/GrupoUS/gpus --skill clean-code-grupous
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/GrupoUS/gpus/tree/main/.claude/skills/clean-code
Command: npx skills add https://github.com/GrupoUS/gpus --skill clean-code-grupous

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill enforces a set of pragmatic coding standards to ensure code is concise, direct, maintainable, and avoids over-engineering or unnecessary complexity.

Core Features & Use Cases

  • Enforces SOLID principles: Promotes Single Responsibility, Don't Repeat Yourself, Keep It Simple, and You Aren't Gonna Need It.
  • Establishes clear naming conventions: For variables, functions, booleans, and constants.
  • Defines function best practices: Emphasizes small size, single responsibility, and minimal arguments.
  • Guides code structure: Recommends guard clauses, flat structures, and composition.
  • Provides AI-specific coding guidelines: For handling user requests and bug fixes.
  • Includes self-check mechanisms: For agents to verify their work before completion.
  • Mandates script verification: Ensures agents run and interpret validation scripts correctly.

Quick Start

Apply the clean-code skill to refactor the provided code snippet for improved readability and maintainability.

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 improve readability and maintainability?

To refactor code for maintainability, apply pragmatic coding standards like SRP, DRY, and KISS. This skill guides you in establishing clear naming conventions, designing small functions with single responsibilities, and structuring code with guard clauses to ensure concise, direct, and readable code.

What are the best coding standards to prevent over-engineering?

The best coding standards to prevent over-engineering enforce the YAGNI principle, ensuring you only build what is necessary. This approach avoids unnecessary complexity by promoting flat structures, composition, and concise code over premature abstractions.

How do AI agents ensure code quality when fixing bugs?

AI agents ensure code quality when fixing bugs by following specific coding guidelines and mandatory self-check mechanisms. They must run validation scripts, interpret the results correctly, and verify their work against maintainability principles before completion.

Does this clean code approach work with any programming language?

Yes, this clean code approach works across programming languages because it focuses on universal principles like naming conventions, function design, and code structure rather than language-specific syntax. The standards enforce maintainability regardless of your specific tech stack.

Why should I use composition over inheritance for code structure?

You should use composition over inheritance to achieve a flat code structure that is easier to maintain and modify. This pragmatic standard reduces deep class hierarchies, avoiding unnecessary complexity and keeping your codebase direct and concise.