Code Quality Expert

Overview

This skill integrates two foundational software engineering disciplines:

1. Refactoring - Improving code structure without changing behavior
2. Design Patterns - Proven solutions to common design problems

Combined, they form a powerful toolkit for writing clean, maintainable, and extensible code.

Directory Structure

expert-code-quality/
├── SKILL.md              # Skill definition file
├── LICENSE               # MIT License
└── references/           # Reference documents
    ├── refactoring-catalog.md    # Complete catalog of refactoring techniques
    ├── design-patterns.md         # 23 GoF patterns
    ├── code-smells.md             # Detailed description of code smells
    └── solid-principles.md        # In-depth analysis of SOLID principles

Trigger Conditions

Automatic Triggers:

• User asks about code quality issues
• Need to identify code smells
• Request for design pattern recommendations
• Performing code refactoring
• Evaluating SOLID principle compliance

Manual Triggers:

• User enters commands like /code-quality, /refactor, /pattern, etc.

Core Capabilities

1. Code Smell Detection

1.1 Quick Reference: 22 Code Smells

Method-Level Smells:

Class-Level Smells:

Relationship-Level Smells:

1.2 Smell Detection Checklist

When reviewing code, check:

• Are there methods longer than 20 lines?
• Is there duplicated code?
• Are there classes with more than 10 fields?
• Are there switch statements that could use polymorphism?
• Are there methods with more than 4 parameters?
• Is there deep inheritance hierarchy (> 3 levels)?
• Does the class change for multiple reasons?
• Are there message chains with more than 3 calls?
• Are there "data classes" with only data and no behavior?
• Are there "lazy classes" that do almost nothing?

2. Refactoring Techniques

2.1 Refactoring Principles

Two Hats (Kent Beck):

Never wear both hats at the same time!

Refactoring Rhythm:

Test → Small Change → Test → Small Change → Test

2.2 Key Refactoring Techniques

Composing Methods:

Moving Features:

Simplifying Conditionals:

2.3 Refactoring Decision Tree

Found code smell?
    │
    ├─ Do you have tests?
    │   ├─ No → Write tests first
    │   └─ Yes → Continue
    │
    ├─ Do you understand the code?
    │   ├─ No → Refactor to understand
    │   └─ Yes → Continue
    │
    └─ Choose refactoring approach:
        │
        ├─ Method too long → Extract Method
        ├─ Duplicated code → Extract Method / Pull Up
        ├─ Class too large → Extract Class
        ├─ Parameter list too long → Introduce Parameter Object
        ├─ Switch statement → Replace with Polymorphism
        └─ Complex conditionals → Decompose / Guard Clauses

3. Design Patterns

3.1 SOLID Principles Foundation

Before applying patterns, ensure understanding of SOLID principles:

3.2 Selection by Problem Type

3.3 Selection by Code Smell

3.4 Pattern Quick Reference

Creational Patterns:

Structural Patterns:

Behavioral Patterns:

4. Integrated Workflow

4.1 Code Quality Improvement Process

1. IDENTIFY
   └── Detect code smells
       └── Use smell checklist
           └── Rate severity (Critical/High/Medium/Low)

2. DIAGNOSE
   └── Understand root cause
       └── Why does this smell exist?
           └── What problems will it cause?

3. PLAN
   └── Choose refactoring or pattern
       └── Consider dependencies
           └── Estimate impact

4. PREPARE
   └── Ensure tests exist
       └── Run tests to verify behavior
           └── Create tests if missing

5. EXECUTE
   └── Apply small changes
       └── Test after each change
           └── Keep code working

6. VERIFY
   └── Run all tests
       └── Check for new smells
           └── Confirm improvement

4.2 Smell→Refactoring→Pattern Flow

Detected code smell
        │
        ▼
┌───────────────────┐
│ Is this a method  │
│ level problem?    │
└────────┬──────────┘
         │
    ┌────┴────┐
    │ Yes     │ No
    ▼         ▼
Extract    Is this a class
Method     level problem?
              │
         ┌────┴────┐
         │ Yes     │ No
         ▼         ▼
    Extract    Is this a
    Class      relationship
              problem?
                  │
             ┌────┴────┐
             │ Yes     │ No
             ▼         ▼
        Move/Hide   Consider
        Delegate    Pattern
                        │
                        ▼
                  ┌──────────────┐
                  │ Which        │
                  │ pattern fits │
                  │ best?        │
                  └──────┬───────┘
                         │
         ┌───────────────┼───────────────┐
         ▼               ▼               ▼
    Creational      Structural      Behavioral
    Patterns        Patterns        Patterns

5. Collaboration Table

5.1 Collaboration with Other Skills

5.2 Collaboration Workflow

Code quality issue detected
    ↓
Invoke expert-code-quality
    ↓
Identify code smells + Recommend refactoring/patterns
    ↓
(If tests needed first) → Invoke test-driven-development
    ↓
(If code implementation needed) → Invoke software-engineer
    ↓
Complete code quality improvement

6. Quick Decision Matrix

7. Anti-Patterns

7.1 Refactoring Anti-Patterns

7.2 Pattern Anti-Patterns

8. Practice Checklists

8.1 Code Review Checklist

Before approving code, verify:

• No critical code smells
• Reasonable method size (< 20 lines)
• Class has single responsibility
• No duplicated code
• Clear conditionals
• Meaningful names
• Tests exist and pass
• Follows SOLID principles
• Patterns used appropriately (not overused)

8.2 Refactoring Safety Checklist

Before refactoring:

• All tests pass
• Tests cover code to refactor
• Understand code functionality
• Have rollback plan
• Make small changes
• Test after each change

8.3 Pattern Application Checklist

Before applying pattern:

• Problem matches pattern intent
• Pattern solves real problem (not imagined)
• Team understands pattern
• Pattern doesn't overcomplicate
• Alternatives considered
• Pattern fits project context

Guardrails

• Must provide suggestions based on Martin Fowler's refactoring catalog and GoF design patterns
• Refactoring suggestions need specific code transformation examples
• Pattern application needs to weigh pros and cons, not blindly recommend
• Code review needs to specifically point out problems and improvement suggestions
• Clearly state uncertain issues to avoid misleading

Version History

v2.0 (2026-03-21)

• Unified to Chinese description
• Added collaboration table, clarified collaboration with other skills
• Enhanced quick decision matrix
• Optimized refactoring decision tree
• Added anti-pattern checklist

v1.0 (Initial version)

• Basic code quality detection
• Refactoring technique catalog
• Design pattern reference

Remember: Good code isn't about being clever—it's about being clear. Refactoring and patterns are tools to achieve clarity, not ends in themselves.