Refactoring Assistant

# Refactoring Assistant ## Description This prompt helps you analyze and refactor existing code to improve its structure, readability, maintainability, and performance while preserving functionality. ## Usage Perfect for improving legacy code, preparing code for new features, reducing technical debt, and following best practices and design patterns. ## Prompt ```markdown You are an expert code refactoring assistant. I need help refactoring the following code to improve its quality while maintaining the same functionality. **Code to refactor:** ``` [INSERT_CODE_HERE] ``` **Context:** - Programming language: [LANGUAGE] - Framework/library: [FRAMEWORK_IF_ANY] - Current issues: [DESCRIBE_PROBLEMS] - Performance requirements: [PERFORMANCE_NEEDS] - Coding standards: [STYLE_GUIDE_IF_ANY] Please analyze the code and provide: 1. **Code Quality Assessment:** - Identify code smells and anti-patterns - Assess readability, maintainability, and performance - Check adherence to SOLID principles - Evaluate naming conventions and structure 2. **Refactoring Plan:** - List specific improvements needed - Prioritize changes by impact and complexity - Identify any breaking changes - Suggest design patterns if applicable 3. **Refactored Code:** - Provide the improved version - Add clear comments explaining changes - Ensure functionality is preserved - Follow best practices for the language/framework 4. **Explanation:** - Explain what was changed and why - Highlight performance improvements - Note any new dependencies or requirements - Provide migration steps if needed 5. **Testing Recommendations:** - Suggest test cases to verify functionality - Recommend regression testing approach - Identify potential edge cases to test Focus on making the code more readable, maintainable, and efficient while following established best practices. ``` ## Example Input ```markdown Code to refactor: ```javascript function processUsers(users) { var result = []; for (var i = 0; i < users.length; i++) { if (users[i].age >= 18 && users[i].active == true) { var userData = {}; userData.name = users[i].firstName + " " + users[i].lastName; userData.email = users[i].email; userData.category = users[i].age >= 65 ? "senior" : "adult"; result.push(userData); } } return result; } ``` Context: - Programming language: JavaScript (ES6+) - Framework/library: None - Current issues: Old syntax, not functional, poor readability - Performance requirements: Handle arrays up to 10,000 users - Coding standards: ES6+, functional programming preferred ``` ## Example Output ``` ## Code Quality Assessment - Uses var instead of const/let - Traditional for loop instead of array methods - Loose equality comparison (==) - Imperative style instead of functional - No input validation - String concatenation instead of template literals ## Refactoring Plan 1. Convert to functional programming style 2. Use modern ES6+ syntax 3. Add input validation 4. Extract helper functions for better readability 5. Use array methods for better performance ## Refactored Code ```javascript /** * Processes users array to extract active adult users with formatted data * @param {Array<Object>} users - Array of user objects * @returns {Array<Object>} Filtered and formatted user data */ const processUsers = (users = []) => { if (!Array.isArray(users)) { throw new Error('Input must be an array'); } const isEligibleUser = (user) => user?.age >= 18 && user?.active === true; const formatUserData = (user) => ({ name: `${user.firstName} ${user.lastName}`, email: user.email, category: user.age >= 65 ? 'senior' : 'adult' }); return users .filter(isEligibleUser) .map(formatUserData); }; ``` ## Explanation - **Modern syntax**: Used const, arrow functions, template literals - **Functional approach**: Replaced imperative loop with filter/map chain - **Better readability**: Extracted helper functions with descriptive names - **Input validation**: Added type checking and default parameter - **Performance**: Array methods are optimized and more readable - **Strict equality**: Used === instead of == - **Optional chaining**: Added ?. for safer property access ## Testing Recommendations - Test with empty array, null, undefined inputs - Test with users of various ages (under 18, 18-64, 65+) - Test with inactive users - Test with malformed user objects - Performance test with 10,000+ user array ``` ## Variations ### Legacy Code Modernization Focus specifically on updating old syntax and patterns to modern standards while maintaining backward compatibility. ### Performance-Focused Refactoring Emphasize optimization for speed, memory usage, and scalability in the refactoring suggestions. ### Security-Focused Refactoring Prioritize identifying and fixing security vulnerabilities, input validation, and secure coding practices. ## Tips - Always preserve the original functionality unless explicitly asked to change it - Test thoroughly after refactoring to ensure no regressions - Refactor in small, incremental steps rather than large rewrites - Consider the team's skill level when suggesting modern patterns - Document any breaking changes clearly ## Related Prompts - [Code Review](./code-review.md) - For reviewing code quality - [Test Case Generator](./test-case-generator.md) - For creating tests after refactoring - [Documentation Generator](./documentation-generator.md) - For updating docs after refactoring ## Tags `refactoring` `code-quality` `best-practices` `modernization` `optimization` `maintainability` `technical-debt` `clean-code`