clean-code-principles

SOLID principles, design patterns, DRY, KISS, and clean code fundamentals. Use when reviewing architecture, checking code quality, refactoring, or discussing design decisions. Triggers on "review architecture", "check code quality", "SOLID principles", "design patterns", or "clean code".

1,798
installs: 0 up / 0 down, score 0.00
votes: 92
repo stars
Updated: 2 months ago
In the catalog since: 1 Oct 2026
From: asyrafhussin/agent-skills

Get it through your agent npx skills add asyrafhussin/agent-skills@clean-code-principles

Skill instructions

Rendered from the published SKILL.md, 205 lines.

Clean Code Principles

Fundamental software design principles, SOLID, design patterns, and clean code practices. Language-agnostic guidelines for writing maintainable, scalable software.

When to Apply

Reference these guidelines when:

Designing new features or systems
Reviewing code architecture
Refactoring existing code
Discussing design decisions
Improving code quality

Rule Categories by Priority

Priority	Category	Impact	Prefix
1	SOLID Principles	CRITICAL	`solid-`
2	Core Principles	CRITICAL	`core-`
3	Design Patterns	HIGH	`pattern-`
4	Code Organization	HIGH	`org-`
5	Naming & Readability	MEDIUM	`name-`
6	Functions & Methods	MEDIUM	`func-`
7	Comments & Documentation	LOW	`doc-`

Quick Reference

1. SOLID Principles (CRITICAL)

solid-srp - Single Responsibility Principle
solid-ocp - Open/Closed Principle
solid-lsp - Liskov Substitution Principle
solid-isp - Interface Segregation Principle
solid-dip - Dependency Inversion Principle

2. Core Principles (CRITICAL)

core-dry - Don't Repeat Yourself
core-kiss - Keep It Simple, Stupid
core-yagni - You Aren't Gonna Need It
core-separation-of-concerns - Separate different responsibilities
core-composition-over-inheritance - Favor composition
core-law-of-demeter - Principle of least knowledge
core-fail-fast - Detect and report errors early
core-encapsulation - Hide implementation details

3. Design Patterns (HIGH)

pattern-factory - Factory pattern for object creation
pattern-strategy - Strategy pattern for algorithms
pattern-repository - Repository pattern for data access
pattern-decorator - Decorator pattern for behavior extension
pattern-observer - Observer pattern for event handling
pattern-adapter - Adapter pattern for interface conversion
pattern-facade - Facade pattern for simplified interfaces
pattern-dependency-injection - DI for loose coupling

4. Code Organization (HIGH) — planned

org-feature-folders - Organize by feature, not layer
org-module-boundaries - Clear module boundaries
org-layered-architecture - Proper layer separation
org-package-cohesion - Related code together
org-circular-dependencies - Avoid circular imports

5. Naming & Readability (MEDIUM) — planned

name-meaningful - Use intention-revealing names
name-consistent - Consistent naming conventions
name-searchable - Avoid magic numbers/strings
name-avoid-encodings - No Hungarian notation
name-domain-language - Use domain terminology

6. Functions & Methods (MEDIUM) — planned

func-small - Keep functions small
func-single-purpose - Do one thing
func-few-arguments - Limit parameters
func-no-side-effects - Minimize side effects
func-command-query - Separate commands and queries

7. Comments & Documentation (LOW) — planned

doc-self-documenting - Code should explain itself
doc-why-not-what - Explain why, not what
doc-avoid-noise - No redundant comments
doc-api-docs - Document public APIs

Essential Guidelines

For detailed examples and explanations, see the rule files:

core-dry.md - Don't Repeat Yourself principle
pattern-repository.md - Repository pattern for data access

SOLID Principles (Summary)

Principle	Definition
Single Responsibility	A class should have only one reason to change
Open/Closed	Open for extension, closed for modification
Liskov Substitution	Subtypes must be substitutable for base types
Interface Segregation	Don't force clients to depend on unused interfaces
Dependency Inversion	Depend on abstractions, not concretions

Core Principles (Summary)

Principle	Definition
DRY	Don't Repeat Yourself - single source of truth
KISS	Keep It Simple - avoid over-engineering
YAGNI	You Aren't Gonna Need It - build only what's needed

Quick Examples

// Single Responsibility - one class, one job
class UserService {
  constructor(
    private validator: UserValidator,

Show the whole skill (85 more lines)

private repository: UserRepository,

) {}

createUser(data) { this.validator.validate(data); return this.repository.create(data); } }

// Dependency Inversion - depend on abstractions interface Repository { find(id: string): Promise<T | null>; save(entity: T): Promise; }

class OrderService { constructor(private repository: Repository) {} }

// DRY - single source of truth const EMAIL_REGEX = /^[^\s@]+@[^\s@]+.[^\s@]+$/; const isValidEmail = (email: string) => EMAIL_REGEX.test(email);

// Meaningful names over magic numbers const MINIMUM_AGE = 18; if (user.age >= MINIMUM_AGE) { }


## Output Format

When auditing code, output findings in this format:

file:line - [principle] Description of issue


Example:

src/services/UserService.ts:15 - [solid-srp] Class handles validation, persistence, and notifications src/utils/helpers.ts:42 - [core-dry] Email validation duplicated from validators/email.ts src/models/Order.ts:28 - [name-meaningful] Variable 'x' should describe its purpose


## How to Use

Read individual rule files for detailed explanations:

rules/solid-srp-class.md rules/core-dry.md rules/pattern-repository.md


## References

This skill is built on established software engineering principles:

### Core Books
- **Clean Code** by Robert C. Martin - Foundation for clean code practices
- **Design Patterns** by Gang of Four - Classic design pattern catalog
- **Refactoring** by Martin Fowler - Improving code structure
- **The Pragmatic Programmer** by Hunt & Thomas - Practical wisdom

### Online Resources
- [Refactoring Guru](https://refactoring.guru/) - Design patterns and code smells
- [Martin Fowler's Refactoring Catalog](https://refactoring.com/catalog/) - Comprehensive refactoring techniques
- [Uncle Bob's Clean Coder Blog](https://blog.cleancoder.com/) - Software craftsmanship articles

### Pattern Catalogs
- [Refactoring Guru - Design Patterns](https://refactoring.guru/design-patterns)
- [Martin Fowler - Enterprise Patterns](https://martinfowler.com/eaaCatalog/)

## Metadata

**Version:** 1.0.2
**Status:** Active
**Coverage:** 23 rules across 3 implemented categories (SOLID, Core Principles, Design Patterns); 4 planned
**Last Updated:** 2026-03-07

### Rule Statistics
- SOLID Principles: 10 rules
- Core Principles: 12 rules
- Design Patterns: 1 rule

Get it through your agent

Call the Graph-of-Skills MCP server's retrieve_skill_bundle tool and it returns this skill's text inside your budget.

{
  "tool": "retrieve_skill_bundle",
  "arguments": {
    "query": "clean-code-principles"
  }
}

New to this? Set up Graph-of-Skills or get a free key. The text on this page comes from its authors: how skills are sourced and what we check. If none fits your task, your agent can write a skill for your own library. To keep a skill from your own library on a machine, see how to install one of your skills.

Share on X Share on LinkedIn Share on Bluesky Share on Hacker News

Share on Reddit

Source

Source repository asyrafhussin/agent-skills
Listing on skills.sh

From asyrafhussin/agent-skills via skills.sh

Related skills

clean-code
Write readable, maintainable code through disciplined naming, small functions, and clean error handling. Use when the user mentions "clean up this code", "this function is too long", "code smells", "naming conventions", "boy scout rule", "single responsibility", or "unit test quality". Also trigger when reviewing a pull request for readability, untangling a messy function, debating comment styles, or improving error-handling patterns. Covers SRP, comment discipline, formatting, and unit testing. For refactoring techniques, see refactoring-patterns. For architecture and dependency rules, see clean-architecture.
6,569 installs
clean-architecture
Clean Architecture principles and best practices from Robert C. Martin's book. This skill should be used when designing software systems, reviewing code structure, or refactoring applications to achieve better separation of concerns. Triggers on tasks involving layers, boundaries, dependency direction, entities, use cases, or system architecture.
2,029 installs
clean-code-guard
Review generated or changed production code before it ships, using Clean Code, SOLID, DRY, KISS, YAGNI, and LLM-specific failure-mode checks in any programming language. Best used reactively after an agent writes, edits, refactors, or fixes code, before presenting, committing, or merging the result. Use when the user asks "review this PR", "is this safe to merge?", "make this cleaner", "audit this code", "refactor this", "fix this bug", or after a coding agent produced implementation code. Can also guide writing when explicitly invoked before a risky edit. Invoke it on your own initiative the moment you finish writing, editing, or refactoring non-trivial production code, before presenting or committing — don't wait to be asked. DO NOT USE for factual/conceptual questions, CI/tooling config, git workflow, running/debugging tests, pure architecture discussion, prose writing, data analysis, or test-code review (use test-guard).
4,636 installs
ddd
Domain-Driven Design tactical patterns for .NET applications. Covers aggregates, aggregate roots, value objects, domain events, domain services, strongly-typed IDs, and repository patterns for aggregate persistence. Load this skill when implementing DDD, working with aggregates, value objects, domain events, bounded contexts, or when the architecture-advisor recommends DDD + Clean Architecture. Pair with the clean-architecture skill.
2,833 installs
clean-architecture
Clean Architecture for .NET applications. Covers the 4-project layout (Domain, Application, Infrastructure, Api), dependency inversion, use case handlers, domain entities with behavior, and infrastructure as a plugin. Load this skill when building a project with Clean Architecture, discussing layered architecture, dependency inversion, use cases, or when the architecture-advisor recommends Clean Architecture.
2,921 installs

More from asyrafhussin/agent-skills

php-best-practices
PHP 8.x modern patterns, PSR standards, and SOLID principles. Use when reviewing PHP code, checking type safety, auditing code quality, or ensuring PHP best practices. Triggers on "review PHP", "check PHP code", "audit PHP", or "PHP best practices".
3,642 installs
react-vite-best-practices
React and Vite performance optimization guidelines. Use when writing, reviewing, or optimizing React components built with Vite. Triggers on tasks involving Vite configuration, build optimization, code splitting, lazy loading, HMR, bundle size, or React performance.
2,851 installs
laravel-best-practices
Laravel 13 conventions and best practices. Use when creating controllers, models, migrations, validation, services, or structuring Laravel applications. Triggers on tasks involving Laravel architecture, Eloquent, database, API development, or PHP patterns.
2,249 installs
laravel-inertia-react
Laravel + Inertia.js + React integration patterns. Use when building Inertia page components, handling forms with useForm, managing shared data, or implementing persistent layouts. Triggers on tasks involving Inertia.js, page props, form handling, or Laravel React integration.
1,931 installs
typescript-react-patterns
TypeScript best practices for React development. Use when writing typed React components, hooks, events, refs, or generic components. Triggers on tasks involving TypeScript errors, type definitions, props typing, or type-safe React patterns.
1,054 installs

Content is provided as published by its creators; you are responsible for how you use it.

To request removal, use the contact form.