/refactor-code

name: refactor-code
description: "Use when the user asks to refactor a file, module, or scope while preserving behaviour, for example /util refactor-code src/auth. Fills test gaps first, refactors incrementally with commits, then verifies tests, lint, and performance."

Intelligently Refactor and Improve Code Quality

Intelligently refactor and improve code quality

Instructions

Follow this systematic approach to refactor code: **$ARGUMENTS**

1. **Pre-Refactoring Analysis**

• Identify the code that needs refactoring and the reasons why
• Understand the current functionality and behavior completely
• Review existing tests and documentation
• Identify all dependencies and usage points

2. **Test Coverage Verification**

• Ensure comprehensive test coverage exists for the code being refactored
• If tests are missing, write them BEFORE starting refactoring
• Run all tests to establish a baseline
• Document current behavior with additional tests if needed

3. **Refactoring Strategy**

• Define clear goals for the refactoring (performance, readability, maintainability)
• Choose appropriate refactoring techniques:
• Extract Method/Function
• Extract Class/Component
• Rename Variable/Method
• Move Method/Field
• Replace Conditional with Polymorphism
• Eliminate Dead Code
• Plan the refactoring in small, incremental steps

4. **Environment Setup**

• Create a new branch from a slug you derive from the scope: `git checkout -b refactor/<slug>` (derive the slug; never paste the raw argument into a branch name)
• Ensure all tests pass before starting
• Set up any additional tooling needed (profilers, analyzers)

5. **Incremental Refactoring**

• Make small, focused changes one at a time
• Run tests after each change to ensure nothing breaks
• Commit working changes frequently with descriptive messages
• Use IDE refactoring tools when available for safety

6. **Code Quality Improvements**

• Improve naming conventions for clarity
• Eliminate code duplication (DRY principle)
• Simplify complex conditional logic
• Reduce method/function length and complexity
• Improve separation of concerns

7. **Performance Optimizations**

• Identify and eliminate performance bottlenecks
• Optimize algorithms and data structures
• Reduce unnecessary computations
• Improve memory usage patterns

8. **Design Pattern Application**

• Apply appropriate design patterns where beneficial
• Improve abstraction and encapsulation
• Enhance modularity and reusability
• Reduce coupling between components

9. **Error Handling Improvement**

• Standardize error handling approaches
• Improve error messages and logging
• Add proper exception handling
• Enhance resilience and fault tolerance

10. **Documentation Updates**

• Update code comments to reflect changes
• Revise API documentation if interfaces changed
• Update inline documentation and examples
• Ensure comments are accurate and helpful

11. **Testing Enhancements**

• Add tests for any new code paths created
• Improve existing test quality and coverage
• Remove or update obsolete tests
• Ensure tests are still meaningful and effective

12. **Static Analysis**

• Run linting tools to catch style and potential issues
• Use static analysis tools to identify problems
• Check for security vulnerabilities
• Verify code complexity metrics

13. **Performance Verification**

• Run performance benchmarks if applicable
• Compare before/after metrics
• Ensure refactoring didn't degrade performance
• Document any performance improvements

14. **Integration Testing**

• Run full test suite to ensure no regressions
• Test integration with dependent systems
• Verify all functionality works as expected
• Test edge cases and error scenarios

15. **Code Review Preparation**

• Review all changes for quality and consistency
• Ensure refactoring goals were achieved
• Prepare clear explanation of changes made
• Document benefits and rationale

16. **Documentation of Changes**

• Create a summary of refactoring changes
• Document any breaking changes or new patterns
• Update project documentation if needed
• Explain benefits and reasoning for future reference

17. **Deployment Considerations**

• Plan deployment strategy for refactored code
• Consider feature flags for gradual rollout
• Prepare rollback procedures
• Set up monitoring for the refactored components

Remember: Refactoring should preserve external behavior while improving internal structure. Always prioritize safety over speed, and maintain comprehensive test coverage throughout the process.