clean-code

Enforce pragmatic AI coding standards for maintainable code.

Updated Sep 2, 2025
One-click install
npx skills add https://github.com/rafaelminatto1/fisioflow-51658291 --skill clean-code-rafaelminatto1
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/rafaelminatto1/fisioflow-51658291/tree/main/.agent/skills/clean-code
Command: npx skills add https://github.com/rafaelminatto1/fisioflow-51658291 --skill clean-code-rafaelminatto1

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Pragmatic AI coding standards reduce boilerplate, prevent over-engineering, and enforce clear, maintainable code across teams.

Core Features & Use Cases

  • SRP & modular design: Ensure each function/class has a single responsibility and manageable size.
  • DRY & readability: Eliminate duplication and rename ambiguous identifiers for clarity.
  • Guardrails & anti-patterns: Avoid deep nesting, magic numbers, and unnecessary comments; provide a clear pathway for code review and onboarding.

Quick Start

To start, audit a single module for SRP violations and refactor it into focused, well-named functions.

Frequently Asked Questions about clean-code

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

FAQPage Schema
How do I enforce clean code standards during AI code reviews?

Enforce clean code standards during AI code reviews by applying pragmatic rules like SRP, DRY, and KISS. This reduces boilerplate and prevents over-engineering, ensuring code remains clear and maintainable across software-engineering teams.

What is the best way to refactor AI code to improve maintainability?

The best way to refactor AI code for maintainability is auditing modules for SRP violations and breaking them into focused, well-named functions. This eliminates duplication and ensures each component has a single responsibility.

How do I prevent over-engineering in software engineering projects?

Prevent over-engineering in software engineering projects by applying YAGNI and KISS principles. Avoiding deep nesting, magic numbers, and unnecessary comments keeps the codebase concise and prevents bloated, hard-to-maintain logic.

Does this coding standards approach work for onboarding new developers?

This coding standards approach works effectively for onboarding new developers by providing clear guardrails and anti-pattern avoidance. Specifying naming rules and small function sizes gives new team members a structured pathway for understanding the codebase.

When should I avoid adding comments to maintain code quality?

You should avoid adding unnecessary comments to maintain code quality when the code is already self-documenting through clear naming and small function sizes. Eliminating redundant comments reduces boilerplate and improves overall readability.

How do I eliminate side effects and magic numbers in my codebase?

Eliminate side effects and magic numbers by enforcing guardrails that require explicit constant definitions and pure functions. Avoiding these anti-patterns during development ensures your code remains predictable and easy to debug.