Get refactoring suggestions with houtini-lm

Quick Start

Jump straight in with these copy-paste prompts that'll transform your code:

Please suggest refactoring improvements for C:/project/src/UserService.ts

How can I improve the performance of this React component? C:/components/Dashboard.tsx

This legacy PHP code needs modernising - what would you change? C:/legacy/OldUserClass.php

Can you help make this code more readable and maintainable? C:/utils/DataProcessor.js

What It Does

Think of this as having a master craftsperson look at your work and show you the elegant solution you couldn't quite see. suggest_refactoring performs sophisticated code analysis to identify meaningful refactoring opportunities with project-specific patterns and expert-level risk assessment.

It's not about nitpicking every small detail - this function focuses on improvements that genuinely matter:

• Performance bottlenecks that slow down your application
• Readability issues that make maintenance a nightmare
• Maintainability problems that make future changes risky
• Architectural improvements that reduce coupling and complexity
• Modern patterns that leverage your framework's best features

Every suggestion comes with clear explanations, before/after examples, and a realistic assessment of implementation effort and risk. You'll know exactly what to change, why it matters, and how to do it safely.

Parameters

Here's what you can customise to get exactly the refactoring guidance you need:

*Either filePath or code is required - choose whichever suits your workflow

Real-World Examples

Here's how to use it in different scenarios:

React Component Optimisation

houtini-lm:suggest_refactoring with:
- filePath: "C:/project/src/components/Dashboard.tsx"
- focusAreas: ["performance", "maintainability"]
- context: {
    "framework": "React",
    "patterns": ["hooks", "functional", "typescript"],
    "performance": "high_traffic"
  }

Legacy PHP Modernisation

houtini-lm:suggest_refactoring with:
- filePath: "C:/legacy/UserManager.php"
- projectPath: "C:/legacy"
- focusAreas: ["readability", "maintainability", "architecture"]
- analysisDepth: "comprehensive"
- context: {
    "modernise": true,
    "target_php": "8.1",
    "patterns": ["PSR-4", "dependency_injection"]
  }

Node.js API Refactoring

houtini-lm:suggest_refactoring with:
- filePath: "C:/api/routes/users.js"
- focusAreas: ["performance", "architecture"]
- context: {
    "framework": "Express.js",
    "database": "PostgreSQL",
    "patterns": ["async_await", "error_handling"]
  }

Quick Function Improvement

houtini-lm:suggest_refactoring with:
- code: "function processUsers(users) { 
    let result = []; 
    for(let i = 0; i < users.length; i++) { 
      if(users[i].active == true) { 
        result.push({...users[i], processed: true}); 
      } 
    } 
    return result; 
  }"
- focusAreas: ["readability", "performance"]
- context: {"language": "JavaScript", "modern": true}

What You Get Back

The refactoring suggestions are practical, actionable, and designed to help you improve your code immediately:

🔧 Specific Improvement Recommendations

• Before/after code examples showing exactly what to change
• Clear explanations of why each change improves the code
• Implementation steps with the safest order of changes
• Alternative approaches when multiple solutions are viable

⚖️ Risk Assessment for Each Suggestion

• Low risk - Safe changes that won't break functionality
• Medium risk - Changes requiring careful testing
• High risk - Significant architectural changes with detailed migration guidance
• Impact analysis - What parts of the system might be affected

⚡ Performance Impact Analysis

• Quantified improvements - estimated speed gains, memory savings
• Bottleneck identification - the changes with biggest impact
• Scalability considerations - how changes affect performance at scale
• Framework-specific optimisations - leveraging your tech stack's strengths

🏗️ Architectural Pattern Improvements

• Design pattern opportunities - when and how to apply them
• Dependency reduction strategies - loosening tight coupling
• Separation of concerns - clearer responsibility boundaries
• Code organisation suggestions - better file and function structure

🧪 Testing Enhancement Recommendations

• Testability improvements - making code easier to test
• Coverage enhancement - areas that need better test coverage
• Mock-friendly refactoring - reducing dependencies for unit tests
• Test strategy guidance - what types of tests to add after changes

Focus Areas Explained

Choose the right focus areas to get targeted suggestions for your specific needs:

📖 Readability Focus

Perfect for code that works but is hard to understand or maintain:

• Variable and function naming improvements
• Code structure and organisation enhancements
• Comment and documentation suggestions
• Complexity reduction strategies
• Consistent formatting and style recommendations

⚡ Performance Focus

When you need speed improvements and efficiency gains:

• Algorithm optimisation opportunities
• Memory usage improvements
• Database query optimisation
• Caching strategy recommendations
• Bundle size reduction for web applications
• Framework-specific performance patterns

🔧 Maintainability Focus

For code that needs to be sustainable long-term:

• Separation of concerns improvements
• Dependency injection opportunities
• Error handling enhancements
• Configuration and environment management
• Testing and debugging improvements

🏗️ Architecture Focus

When you need structural improvements and design pattern implementation:

• Design pattern opportunities
• Component and module organisation
• Interface and abstraction improvements
• Dependency management strategies
• Scalability and extensibility enhancements

Perfect Use Cases

Here's when this function becomes your secret weapon for better code:

🏥 Legacy Code Modernisation

Inherited some old code that needs updating? Get a clear roadmap for bringing it up to modern standards whilst maintaining functionality. Perfect for gradual migration strategies.

🚀 Performance Optimisation

When your application is running slow, paste the bottleneck code and get specific suggestions for improvements. Great for both micro-optimisations and architectural changes.

👥 Code Review Preparation

Before submitting code for peer review, run it through refactoring suggestions to identify potential improvements. Show up with cleaner, more thoughtful code.

📚 Learning Better Patterns

Paste your working code and learn how experienced developers would approach the same problem. It's like having a mentor show you better techniques.

🔧 Technical Debt Reduction

Tackle that growing technical debt systematically. Get prioritised suggestions for which improvements will have the biggest impact on long-term maintainability.

🌟 Framework Migration

Moving from class components to hooks? From jQuery to vanilla JS? Get guidance on modern patterns and migration strategies that preserve functionality whilst improving code quality.

Best Practices

Get the most out of your refactoring suggestions with these proven approaches:

🎯 Be Specific About Your Goals

The more specific you are about what you want to achieve, the better the suggestions:

• Mention performance requirements: "high traffic", "large datasets"
• Include framework preferences: "prefer hooks over classes"
• Note constraints: "must maintain backward compatibility"
• Specify skill level: "junior developer friendly" or "advanced patterns welcome"

📊 Focus Your Analysis

Choose the right focus areas for your situation:

• Start with "readability" for inherited or complex code
• Use "performance" when investigating slow operations
• Choose "maintainability" for long-term projects
• Select "architecture" when planning major changes

🎬 Implement Changes Gradually

Follow the suggested implementation order:

• Low-risk changes first - build confidence and see immediate improvements
• Test thoroughly after each change before moving to the next
• Medium-risk changes with comprehensive testing
• High-risk architectural changes with feature flags or branches

🔍 Provide Project Context

Include your project path when possible for better suggestions:

• Helps understand your existing patterns and conventions
• Provides context about architectural decisions
• Identifies opportunities for consistency improvements
• Suggests patterns that fit your existing codebase

📈 Use for Learning

Make refactoring suggestions part of your professional development:

• Paste well-written code to understand why it's good
• Compare your solutions with suggested improvements
• Build a collection of patterns that work well in your projects
• Share interesting suggestions with your team for discussion

Troubleshooting

Hit a snag? Here are solutions to common issues: