Initial commit

skills/refactoring-patterns/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: refactoring-patterns
+description: Common refactoring patterns and techniques for improving code quality, reducing complexity, and enhancing maintainability. Use when planning or executing code refactoring.
+---
+
+# Refactoring Patterns
+
+This skill provides proven patterns for safe, effective code refactoring.
+
+## Core Refactoring Principles
+
+### Design Principles
+1. **SOLID**: Single responsibility, Open-closed, Liskov substitution, Interface segregation, Dependency inversion
+2. **KISS** (Keep It Simple, Stupid): Favor simplicity over complexity
+3. **YAGNI** (You Aren't Gonna Need It): Don't add functionality until necessary
+4. **DRY** (Don't Repeat Yourself): Avoid code duplication
+
+### Refactoring Guidelines
+1. **Red-Green-Refactor**: Ensure tests pass before and after refactoring
+2. **Small Steps**: Make incremental changes, commit frequently
+3. **One Thing at a Time**: Refactor OR add features, not both
+4. **Maintain Behavior**: External behavior stays the same
+5. **Avoid Premature Optimization**: Focus on clarity first, optimize when needed based on metrics
+
+## Refactoring Approaches
+
+### Architectural Level
+- Restructure system components and module boundaries
+- Refactor service boundaries in microservices/modular monoliths
+- Redesign database schema and data access patterns
+- Improve system scalability and performance architecture
+
+### Module/Package Level
+- Reorganize package structure for better cohesion
+- Extract shared libraries or utilities
+- Improve dependency management and reduce coupling
+- Refactor cross-cutting concerns
+
+### Class/Component Level
+- Apply SOLID principles to class design
+- Extract interfaces and abstractions
+- Reduce class complexity and responsibilities
+- Improve encapsulation and information hiding
+
+### Method/Function Level
+- Simplify complex logic
+- Extract reusable functions
+- Improve naming and readability
+- Reduce parameter lists
+
+## Refactoring Strategy
+
+### 1. Understand the Code
+
+Before refactoring:
+- [ ] Read and understand the existing code
+- [ ] Identify all test coverage
+- [ ] Document current behavior
+- [ ] Note any dependencies
+
+### 2. Ensure Test Coverage
+
+- [ ] Add tests if missing to cover refactored parts
+- [ ] Verify all tests pass
+- [ ] Focus on testing the specific code being refactored (no specific coverage percentage target)
+
+### 3. Plan Refactoring
+
+Create a markdown file documenting:
+- [ ] What needs to be refactored and why
+- [ ] Sequence of small, incremental steps
+- [ ] Checklist format with tasks that can be marked as done (- [x]) before moving to next task
+- [ ] Dependencies and potential risks
+
+### 4. Execute Incrementally
+
+- [ ] Make one change at a time
+- [ ] Run tests after each change
+- [ ] Commit working code frequently
+- [ ] Roll back if tests fail
+
+### 5. Verify and Clean Up
+
+- [ ] All tests pass
+- [ ] Code is clearer and simpler
+- [ ] Update documentation
+
+## Safe Refactoring Checklist
+
+- [ ] Tests exist and pass before starting
+- [ ] Each refactoring step is small and focused
+- [ ] Tests pass after each step
+- [ ] Behavior remains unchanged
+- [ ] Code is more maintainable
+- [ ] Team has reviewed changes
+- [ ] **Never remove existing tests** - only add new tests for refactoring validation
+
+## Integration Points
+
+Works with:
+- `senior-engineer` agent for refactoring execution
+- `technical-architecture-advisor` for large-scale refactoring
+- `/refactoring-plan` command for structured refactoring
+- `code-reviewer` agent for validating improvements