clean-code

Enforce pragmatic coding standards to reduce over-engineering and unnecessary comments.

Updated Jan 21, 2026

Search Tags:#yagni #best-practices #coding-standards #clean-code #srp #kiss #dry

Ready to run

npx skills add https://github.com/ollieb89/orchestrator --skill clean-code-ollieb89

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: clean-code
Source: https://github.com/ollieb89/orchestrator/tree/main/.cursor/skills/clean-code
Command: npx skills add https://github.com/ollieb89/orchestrator --skill clean-code-ollieb89

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Pragmatic coding standards help teams avoid over-engineering, reduce unnecessary comments, and produce maintainable, readable code that stands the test of time.

Core Features & Use Cases

Single Responsibility Principle (SRP): Each function or class does one thing, making code easier to test and modify.
Don't Repeat Yourself (DRY): Encourage reuse and refactoring to remove duplication.
Keep It Simple (KISS): Favor simple, direct solutions over complexity.
YAGNI: Avoid building features not required for current goals.
Code Quality Guardrails: Early exits, flat structures, and careful naming to reduce bugs.

Quick Start

Refactor a sample module to follow SRP, DRY, and KISS by extracting responsibilities into small functions and removing redundant logic.

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 like SRP and DRY during code reviews?▼

Apply pragmatic coding standards to reduce over-engineering by checking functions against SRP, DRY, and KISS. Extract responsibilities into small functions and remove redundant logic to ensure flat structures and clear naming.

What is the best way to prevent over-engineering in software development projects?▼

Prevent over-engineering by applying the YAGNI principle to avoid building unnecessary features for current goals. Favor simple, direct solutions over complexity using KISS guidelines to produce maintainable code.

Can I use clean code principles to refactor an existing module with redundant logic?▼

Refactor existing modules by extracting responsibilities into small functions and removing redundant logic. Apply DRY to encourage reuse and SRP to ensure each function does one thing, making the codebase easier to test and modify.

Does applying coding standards help with onboarding new developers to a codebase?▼

Coding standards help onboarding by producing maintainable, readable code across modules. Clear naming, early exits, and flat structures reduce bugs and help new developers navigate the evolving codebase.

When should I not use YAGNI in software architecture planning?▼

Do not apply YAGNI when a feature is explicitly required for current goals. Avoid building unnecessary features, but ensure you do not skip structural foundations needed for the immediate project scope.