clean-code

Enforce pragmatic coding standards to improve readability and reduce complexity.

Updated Mar 27, 2026
One-click install
npx skills add https://github.com/minhquan2904/vibe-check-scam --skill clean-code-minhquan2904
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/minhquan2904/vibe-check-scam/tree/main/base_knowledge/standards/base/clean-code
Command: npx skills add https://github.com/minhquan2904/vibe-check-scam --skill clean-code-minhquan2904

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Pragmatic coding standards promote concise, direct code, reducing noise and maintenance burden while avoiding over-engineering.

Core Features & Use Cases

  • Guardrails for coding quality (SRP, DRY, KISS, YAGNI) and clear naming conventions.
  • Encouragement of small, single-responsibility functions and flat control flow to improve readability.
  • Anti-pattern detection and guidance on when to refactor, with a self-check before modifications.
  • Use Case: A developer revises a module to improve clarity and reduce unnecessary complexity without changing external behavior.

Quick Start

Refactor the target module to comply with the clean-code standards, focusing on SRP, small functions, descriptive naming, and removal of unnecessary comments.

Frequently Asked Questions about clean-code

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

FAQPage Schema
What are the best practices for refactoring code to improve readability?▼

Refactoring for readability involves applying pragmatic coding standards like SRP, DRY, and KISS. You enforce small, single-responsibility functions, flat control flow, and descriptive naming to reduce unnecessary complexity and noise.

How do I apply clean code standards during a code review?▼

During code reviews, check for clean code guardrails like SRP, DRY, KISS, and YAGNI. Detect anti-patterns, ensure functions are small with clear naming, and verify the removal of unnecessary comments to reduce maintenance burden.

When should I refactor a module to reduce unnecessary complexity?▼

You should refactor a module to reduce complexity when anti-patterns emerge or readability declines. Perform a self-check before modifications, then revise the target module focusing on small functions and descriptive naming without changing external behavior.

Does the YAGNI principle help avoid over-engineering in software projects?▼

Yes, the YAGNI (You Aren't Gonna Need It) principle helps avoid over-engineering by encouraging concise, direct code. It acts as a pragmatic coding standard guardrail to reduce noise and maintenance burden across software projects of varying sizes.

Can I use these coding standards for both small and large software projects?▼

Yes, these pragmatic coding standards are applicable across software projects of varying sizes and teams. They enforce guardrails like DRY and KISS to improve readability and reduce maintenance burden without over-engineering, regardless of project scale.