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.