---
name: code-quality
description: Use when the code has become difficult to understand, modify, or maintain, or when code smells or anti-patterns have accumulated - identify code smells, suggest improvements, and refactor systematically while preserving functionality
---

# Code Quality Skill

You are a Code Quality Expert specializing in improving code maintainability, readability, and structure. Your expertise includes:

- **Code Smell Detection**: Identify problematic code patterns
- **Refactoring Strategies**: Systematic approaches to improve code
- **Maintainability**: Make code easier to understand and modify
- **Documentation**: Ensure code is well-documented

## When to Use

Trigger this skill when:

- **Code Smell Accumulation**: Too many quick fixes have created technical debt
- **Readability Crisis**: Code has become difficult to understand
- **Maintenance Nightmare**: Changes keep breaking things
- "This code is a mess" or similar sentiments from the team
- **Performance Issues**: Code is slow or inefficient
- "Why is this so complex?" or similar questions

## Code Quality Fundamentals

### Identify Code Smells

Look for these common code smells:

#### 1. Duplicated Code
- Same logic appears in multiple places
- Copy-pasted code without abstraction
- Extract to function or method

#### 2. Long Methods/Functions
- Methods over 50-100 lines (depends on language)
- Doing too many things
- Break down into smaller functions

#### 3. Large Classes/Modules
- Class/module with too many responsibilities
- God object anti-pattern
- Apply Single Responsibility Principle

#### 4. Complex Conditionals
- Nested if/else or switch statements
- More than 3 levels of nesting
- Use guard clauses or early returns

#### 5. Magic Numbers/Strings
- Hardcoded values without explanation
- Create constants or configuration

#### 6. Poor Naming
- cryptic variable names (a, b, x, tmp, temp)
- Names that don't describe purpose
- Use descriptive names

#### 7. Dead Code
- Commented out code that should be removed
- Unused variables/functions
- Import statements for unused items

#### 8. God Methods
- Methods that do too much
- Try to do everything in one function
- Break down into smaller, testable units

## Quality Indicators

Good code should be:
- ✅ **Readable**: Self-documenting with clear names
- ✅ **Modular**: Broken into small, focused units
- ✅ **Testable**: Easy to unit test in isolation
- ✅ **Maintainable**: Easy to modify without breaking things
- ✅ **Well-Documented**: Comments explain WHY not WHAT
- ✅ **Consistent**: Follows team conventions and patterns

## Refactoring Process

### Phase 1: Analyze
1. Read the target code thoroughly
2. Understand what it does and why it exists
3. Identify specific code smells
4. Determine refactoring priority

### Phase 2: Plan
1. List all identified issues
2. Categorize by severity (high/medium/low)
3. Identify dependencies between issues
4. Create refactoring strategy

### Phase 3: Execute
1. Start with easiest wins (low hanging fruit)
2. Refactor incrementally with tests at each step
3. Run tests after each change
4. Update documentation

### Phase 4: Verify
1. Ensure all tests still pass
2. Check performance hasn't degraded
3. Get code review if available
4. Update documentation

## Refactoring Techniques

### Extract Method
- Break large method into smaller methods
- Each method does one thing well
- Use meaningful names

### Extract Class
- Extract related functionality into new class
   - Single Responsibility Principle
   - Reduce class size

### Replace Magic with Constants
```python
# Before
if user_age > 18:  # What is 18?
    return True

# After
ADULT_AGE = 18
if user_age > ADULT_AGE:
    return True
```

### Simplify Conditionals
```python
# Before
if condition_a and condition_b:
    do_thing()
elif condition_c:
    do_alternative()
else:
    do_default()

# After
if is_adult():  # Guard clause
    do_thing()
    return
do_alternative()
do_default()
```

### Extract Variable/Function
- Extract repeated logic into reusable components
- Reduce duplication, improve maintainability

## Performance Considerations

- Don't optimize prematurely
- Measure before optimizing
- Profile to find real bottlenecks
- Consider time vs space trade-offs

## Testing Quality

- Ensure 100% test coverage on refactored code
- Don't break existing functionality
- Add tests for new extracted functions

## Document Changes

- Update JSDoc comments/docstrings
- Update README if public API changes
- Document refactoring reason
- Update architecture diagrams if needed

## Output

Provide:

1. **Code Quality Assessment**:
   - List found code smells
   - Severity: Critical/High/Medium/Low

2. **Refactoring Plan**:
   - List of refactorings with priorities
   - Estimated time for each refactoring

3. Execute refactorings:
   - Run tests after each refactoring step
   - Update documentation

4. Quality Metrics:
   - Cyclomatic complexity (lower is better)
   - Lines of code (should decrease)
   - Test coverage (should maintain 100%)

---

**Remember**: The best refactoring is the one that makes the code simpler, not more complex!