clean-code

Enforce SRP, DRY, KISS, YAGNI, naming, and guard-clause coding standards.

Updated Jan 26, 2026
One-click install
npx skills add https://github.com/TwuanMinn/fadelab --skill clean-code-twuanminn
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/TwuanMinn/fadelab/tree/main/.agent/skills/skills/clean-code
Command: npx skills add https://github.com/TwuanMinn/fadelab --skill clean-code-twuanminn

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Pragmatic coding standards reduce boilerplate and over-engineering, promote clarity, and minimize unnecessary comments, helping teams deliver concise, maintainable code faster.

Core Features & Use Cases

  • Enforces core principles: SRP, DRY, KISS, YAGNI to keep code simple and focused.
  • Establishes naming and function rules to improve readability and reduce confusion.
  • Promotes safe coding practices: guard clauses, minimal nesting, and controlled side effects.
  • Provides a pre-flight self-check and mandatory verification steps to prevent regressions.

Quick Start

Audit a representative module and refactor it to satisfy SRP, DRY, KISS, and YAGNI.

Frequently Asked Questions about clean-code

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

FAQPage Schema
How do I enforce coding standards to reduce code complexity and improve readability?

To enforce coding standards and improve readability, apply core principles like SRP, DRY, KISS, and YAGNI. Establish strict naming and function rules, implement guard clauses, and minimize nesting to keep code focused and maintainable across small to medium codebases.

What is the best way to refactor a module for maintainability without over-engineering?

The best way to refactor a module for maintainability is to apply YAGNI and KISS principles to eliminate unnecessary boilerplate and over-engineering. Conduct a pre-flight self-check and run mandatory verification steps to prevent regressions while reducing complexity.

How do I reduce unnecessary comments and boilerplate in my codebase?

Reduce unnecessary comments and boilerplate by enforcing pragmatic coding standards that promote clarity. By adhering to functional rules, DRY, and naming conventions, your team can minimize redundant explanations and deliver concise, maintainable code faster.

Can I use pragmatic coding standards for large enterprise codebases?

Pragmatic coding standards are specifically useful for small to medium codebases. While the principles of SRP, DRY, and KISS apply universally, the self-check and verification guidance is tailored for development teams managing smaller scale refactoring to prevent regressions.

Why does enforcing functional rules and guard clauses help software engineering teams?

Enforcing functional rules and guard clauses helps software engineering teams by promoting safe coding practices and controlling side effects. This reduces deep nesting and confusion, ensuring high-quality code that is easier to read, maintain, and debug.

How do I verify code quality refactoring does not introduce regressions?

To verify code quality refactoring does not introduce regressions, follow mandatory verification steps and pre-flight self-checks. Auditing a representative module against SRP and DRY rules ensures the refactored code remains stable and maintainable.