clean-code

Enforce pragmatic coding standards with pre-edit checks and script verification.

1|Updated Feb 7, 2026
One-click install
npx skills add https://github.com/EliabParra/web-2-backend --skill clean-code-eliabparra
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/EliabParra/web-2-backend/tree/main/.agent/skills/clean-code
Command: npx skills add https://github.com/EliabParra/web-2-backend --skill clean-code-eliabparra

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill enforces pragmatic coding standards to ensure code is maintainable, understandable, and free from unnecessary complexity or bloat.

Core Features & Use Cases

  • Enforces SOLID principles: Promotes Single Responsibility, Don't Repeat Yourself, Keep It Simple, You Ain't Gonna Need It, and the Boy Scout Rule.
  • Standardizes Naming Conventions: Ensures clear and intent-revealing names for variables, functions, and constants.
  • Guides Function Design: Advocates for 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 Etiquette: Defines how AI agents should interact with users regarding code requests and bug fixes.
  • Pre-edit Checks: Mandates critical thinking before modifying any file, considering dependencies and tests.
  • Post-completion Self-Check: Requires verification of goal completion, code functionality, and error-free status.
  • Script Verification: Outlines mandatory script execution for validation and reporting.

Quick Start

Apply the clean-code skill to refactor the provided code snippet, ensuring it adheres to all defined principles and naming conventions.

Frequently Asked Questions about clean-code

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

FAQPage Schema
How do I refactor Python code to reduce complexity and improve maintainability?

Refactoring Python code for maintainability involves enforcing pragmatic standards like SRP, DRY, and KISS to eliminate unnecessary complexity. This skill guides AI agents to apply these principles, ensuring concise, direct, and solution-oriented code.

What are the best practices for enforcing clean code standards during AI-assisted development?

Best practices for clean code in AI development mandate strict naming conventions, small focused functions with minimal arguments, and guard clauses. This skill defines AI coding etiquette, requiring pre-edit checks and post-completion self-verification to ensure functionality.

How do I apply SOLID principles to existing Python scripts?

Applying SOLID principles to Python scripts requires checking for Single Responsibility, avoiding repetition, and keeping implementations simple. This skill enforces these standards alongside the Boy Scout Rule, ensuring code remains clean and maintainable.

Does this clean code approach require mandatory script execution for validation?

Yes, script execution for validation is mandatory in this clean code approach. It requires running scripts post-completion to verify goal achievement, confirm error-free status, and report functionality before finalizing any refactoring or new code.

Can I use this skill to implement function design guidelines and standardize naming conventions?

You can use this skill to implement function design guidelines by advocating for small, focused functions without side effects. It also standardizes naming conventions across variables and constants, ensuring clear and intent-revealing code structures.

What should I check before modifying files to avoid breaking dependencies during refactoring?

Before modifying files, you should perform critical pre-edit checks considering dependencies and tests. This skill mandates evaluating these factors upfront to prevent breaking existing functionality and to maintain structural integrity during refactoring.