Clean Code Principles

# Clean Code Principles - Agent Documentation

**Version:** 1.0.2
**Focus:** SOLID Principles, Core Principles (DRY, KISS, YAGNI), Design Patterns
**Rules:** 23 (10 SOLID + 12 Core + 1 Pattern); 4 categories planned
**License:** MIT

---

This skill provides comprehensive clean code principles, SOLID guidelines, and design patterns for building maintainable, scalable software.

## Overview

The clean-code-principles skill offers language-agnostic software design principles organized into 7 categories, from CRITICAL (SOLID, Core Principles) to LOW priority (Comments). Each rule provides bad/good examples, explanations, and practical guidance.

## When to Use This Skill

Activate this skill when:
- Reviewing code architecture or design
- Refactoring existing code
- Making design decisions
- Establishing coding standards
- Teaching software design principles
- Addressing technical debt
- Improving code quality and maintainability

## Trigger Phrases

The skill activates on:
- "review architecture"
- "check code quality"
- "SOLID principles"
- "design patterns"
- "clean code"
- "refactoring advice"
- "code smells"
- "best practices"
- "DRY principle"
- "separation of concerns"

## Skill Structure

```
clean-code-principles/
├── SKILL.md              # Main skill definition
├── AGENTS.md             # This file - agent documentation
├── README.md             # User-facing documentation
├── metadata.json         # Structured metadata and references
└── rules/
    ├── _sections.md      # Category definitions and organization
    ├── _template.md      # Template for new rules
    ├── solid-*.md        # SOLID principles (10 rules)
    ├── core-*.md         # Core principles (12 rules)
    └── pattern-*.md      # Design patterns (1 rule)
```

## Rule Categories

### 1. SOLID Principles (CRITICAL - 10 rules)
**Prefix:** `solid-`

Five fundamental object-oriented design principles:
- **S**ingle Responsibility: `solid-srp-class`, `solid-srp-function`
- **O**pen/Closed: `solid-ocp-extension`, `solid-ocp-abstraction`
- **L**iskov Substitution: `solid-lsp-contracts`, `solid-lsp-preconditions`
- **I**nterface Segregation: `solid-isp-clients`, `solid-isp-interfaces`
- **D**ependency Inversion: `solid-dip-abstractions`, `solid-dip-injection`

**Use when:** Designing architecture, planning refactoring, discussing system design

### 2. Core Principles (CRITICAL - 12 rules)
**Prefix:** `core-`

Fundamental coding practices:
- **DRY** (Don't Repeat Yourself): 3 rules
- **KISS** (Keep It Simple): 2 rules
- **YAGNI** (You Aren't Gonna Need It): 2 rules
- **Other**: Separation of Concerns, Composition Over Inheritance, Law of Demeter, Fail Fast, Encapsulation

**Use when:** Daily coding, code reviews, addressing duplication or complexity

### 3. Design Patterns (HIGH - 1 rule)
**Prefix:** `pattern-`

Common solutions to recurring problems:
- Repository Pattern (data access abstraction)

**Use when:** Solving architectural problems, abstracting infrastructure concerns

### 4-7. Future Categories
- **Code Organization** (`org-`): Module structure, boundaries
- **Naming & Readability** (`name-`): Identifier naming conventions
- **Functions & Methods** (`func-`): Function-level best practices
- **Comments & Documentation** (`doc-`): Documentation guidelines

## How to Use Rules

### Accessing Rules

1. **By ID:** Reference specific rules using their ID
   ```
   Check against solid-srp-class and core-dry
   ```

2. **By Category:** Apply all rules in a category
   ```
   Review this class against SOLID principles
   ```

3. **By Scenario:** Choose relevant rules for the context
   ```
   This has duplicated validation logic - check DRY rules
   ```

### Rule Format

Each rule follows a consistent structure:

```markdown
---
id: {rule-id}
title: {Full Title}
category: {category}
priority: {critical|high|medium|low}
tags: [{tags}]
related: [{related-rule-ids}]
---

# {Rule Title}

{One-sentence summary}

## Bad Example
{Anti-pattern code with problems liste