clean-code

Enforce concise coding standards using SRP, DRY, KISS, and YAGNI principles.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Pragmatic coding standards ensure concise, direct, and maintainable code by avoiding over-engineering and unnecessary comments.

Core Features & Use Cases

  • SRP, DRY, KISS, YAGNI, Boy Scout Rule as guiding principles.
  • Clear naming conventions and simple function rules to improve readability and reduce bugs.
  • Use cases include code review, refactoring sessions, and onboarding new developers to a shared style.

Quick Start

Refactor the current codebase to align with the pragmatic coding standards and remove redundant comments for improved clarity.

Frequently Asked Questions about clean-code

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

FAQPage Schema
What are the core principles for writing maintainable code and reducing over-engineering?

Core coding standards for maintainable code rely on SRP, DRY, KISS, and YAGNI principles to reduce over-engineering. These rules enforce concise, readable structuring and clear naming to improve software project clarity and speed up developer onboarding.

How do I refactor my codebase to improve readability and remove redundant comments?

To refactor your codebase, apply pragmatic coding standards by enforcing simple function rules, clear naming conventions, and removing unnecessary comments. This process restructures code using SRP and DRY to achieve concise, direct, and highly maintainable software.

When do I need coding standards for code review and onboarding new developers?

You need coding standards during code review, refactoring sessions, and onboarding to enforce a shared style. Applying principles like the Boy Scout Rule and KISS ensures new developers understand the architecture and reduces bugs through readable code.

Does applying clean code principles help reduce bugs in software projects?

Yes, applying clean code principles helps reduce bugs by enforcing clear naming conventions and simple function rules. Structuring code with SRP and DRY improves readability and maintainability, directly minimizing logical errors and over-engineering.

What is the best way to apply SRP and DRY without over-engineering my software architecture?

The best way to apply SRP and DRY without over-engineering is to pair them with KISS and YAGNI principles. This pragmatic coding standard approach ensures functions remain simple, direct, and free of unnecessary comments while maintaining a clean architecture.

Why should I remove unnecessary comments during code refactoring sessions?

You should remove unnecessary comments during code refactoring because pragmatic coding standards prioritize concise, readable code over redundant explanations. Clear naming conventions and simple functions make the code self-documenting, reducing bugs and improving overall maintainability.