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".
- License 许可
- MIT
- 最近更新
- 2026-07-18
- Stars
- ★ 0
- Forks
- 1
01 前言 Front Matter
- name
- clean-code-principles
- license
- MIT
- metadata
- { "author": "AsyrafHussin", "version": "1.0.2" }
- description
- 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".
02 资源文件 1
- 参考文档metadata.json493 B
03 SKILL.md 正文
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 Principlesolid-ocp- Open/Closed Principlesolid-lsp- Liskov Substitution Principlesolid-isp- Interface Segregation Principlesolid-dip- Dependency Inversion Principle
2. Core Principles (CRITICAL)
core-dry- Don't Repeat Yourselfcore-kiss- Keep It Simple, Stupidcore-yagni- You Aren't Gonna Need Itcore-separation-of-concerns- Separate different responsibilitiescore-composition-over-inheritance- Favor compositioncore-law-of-demeter- Principle of least knowledgecore-fail-fast- Detect and report errors earlycore-encapsulation- Hide implementation details
3. Design Patterns (HIGH)
pattern-factory- Factory pattern for object creationpattern-strategy- Strategy pattern for algorithmspattern-repository- Repository pattern for data accesspattern-decorator- Decorator pattern for behavior extensionpattern-observer- Observer pattern for event handlingpattern-adapter- Adapter pattern for interface conversionpattern-facade- Facade pattern for simplified interfacespattern-dependency-injection- DI for loose coupling
4. Code Organization (HIGH) — planned
org-feature-folders- Organize by feature, not layerorg-module-boundaries- Clear module boundariesorg-layered-architecture- Proper layer separationorg-package-cohesion- Related code togetherorg-circular-dependencies- Avoid circular imports
5. Naming & Readability (MEDIUM) — planned
name-meaningful- Use intention-revealing namesname-consistent- Consistent naming conventionsname-searchable- Avoid magic numbers/stringsname-avoid-encodings- No Hungarian notationname-domain-language- Use domain terminology
6. Functions & Methods (MEDIUM) — planned
func-small- Keep functions smallfunc-single-purpose- Do one thingfunc-few-arguments- Limit parametersfunc-no-side-effects- Minimize side effectsfunc-command-query- Separate commands and queries
7. Comments & Documentation (LOW) — planned
doc-self-documenting- Code should explain itselfdoc-why-not-what- Explain why, not whatdoc-avoid-noise- No redundant commentsdoc-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,
private repository: UserRepository,
) {}
createUser(data) {
this.validator.validate(data);
return this.repository.create(data);
}
}
// Dependency Inversion - depend on abstractions
interface Repository<T> {
find(id: string): Promise<T | null>;
save(entity: T): Promise<T>;
}
class OrderService {
constructor(private repository: Repository<Order>) {}
}
// 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 - Design patterns and code smells
- Martin Fowler's Refactoring Catalog - Comprehensive refactoring techniques
- Uncle Bob's Clean Coder Blog - Software craftsmanship articles
Pattern Catalogs
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
04 同仓库更多 Skills
arxiv-search
Search arXiv physics, math, and computer science preprints using natural language queries. Powered by Valyu semantic search.
arxiv-search
Search arXiv physics, math, and computer science preprints using natural language queries. Powered by Valyu semantic search.
working-with-legacy-code
Safely change and test untested codebases using Feathers' "Working Effectively with Legacy Code". Use when the user mentions "legacy code", "no tests", "untested codebase", "how do I test this", "seams", "characterization tests", "golden master", "sprout method", "afraid to change this code", "monster method", "dependency breaking", or "inherited a messy codebase". Also trigger when changing code without tests safely, getting a class under test when constructors, statics, or singletons block it, adding features to tangled modules, or planning incremental test coverage for an old codebase. Covers the legacy-code change algorithm, seams, characterization tests, sprout/wrap, and dependency-breaking techniques. For refactoring code that already has tests, see refactoring-patterns. For day-to-day code quality, see clean-code.
working-with-legacy-code
Safely change and test untested codebases using Feathers' "Working Effectively with Legacy Code". Use when the user mentions "legacy code", "no tests", "untested codebase", "how do I test this", "seams", "characterization tests", "golden master", "sprout method", "afraid to change this code", "monster method", "dependency breaking", or "inherited a messy codebase". Also trigger when changing code without tests safely, getting a class under test when constructors, statics, or singletons block it, adding features to tangled modules, or planning incremental test coverage for an old codebase. Covers the legacy-code change algorithm, seams, characterization tests, sprout/wrap, and dependency-breaking techniques. For refactoring code that already has tests, see refactoring-patterns. For day-to-day code quality, see clean-code.
web-typography
Select, pair, and implement typefaces for web projects. Use when the user mentions "font pairing", "which typeface", "line height", "responsive typography", "web font loading", "type hierarchy", "variable fonts", "FOUT/FOIT", "typographic scale", or "the text is hard to read". Also trigger when choosing between system fonts and web fonts, optimizing font-loading performance, or designing readable long-form content. Covers readability evaluation, CSS implementation, and performance optimization. For overall UI design systems, see refactoring-ui. For dramatic typographic experiences, see top-design.
web-typography
Select, pair, and implement typefaces for web projects. Use when the user mentions "font pairing", "which typeface", "line height", "responsive typography", "web font loading", "type hierarchy", "variable fonts", "FOUT/FOIT", "typographic scale", or "the text is hard to read". Also trigger when choosing between system fonts and web fonts, optimizing font-loading performance, or designing readable long-form content. Covers readability evaluation, CSS implementation, and performance optimization. For overall UI design systems, see refactoring-ui. For dramatic typographic experiences, see top-design.