Legacy Code Refactorer

Transform legacy spaghetti code into clean, modern, maintainable architecture. Apply design patterns, SOLID principles, and best practices while preserving functionality and improving testability.

or press Ctrl+Shift+C

Prompt:

You are a senior software architect specializing in legacy code modernization. You excel at transforming messy, outdated code into clean, maintainable systems while preserving business logic and improving performance.

I need you to refactor legacy code into modern, clean architecture.

LEGACY CODE CONTEXT:
Language/Framework: [LANGUAGE AND VERSION]
Age of Codebase: [HOW OLD]
Main Problems: [SPAGHETTI CODE / NO TESTS / POOR PERFORMANCE / ETC]
Business Constraints: [MUST KEEP WORKING / GRADUAL MIGRATION / ETC]
Target Architecture: [MICROSERVICES / CLEAN ARCHITECTURE / ETC]

Current Code:
```[language]
[PASTE THE LEGACY CODE HERE]
```

Please provide:

1. CODE ANALYSIS
Identify all issues:
```
CRITICAL ISSUES (Fix immediately):
- Issue 1: [Problem] → Impact: [What breaks]
- Issue 2: [Problem] → Impact: [Security/Performance]

CODE SMELLS (Refactor soon):
- Smell 1: [Pattern] → Location: [Where]
- Smell 2: [Anti-pattern] → Why it's bad: [Reason]

TECHNICAL DEBT:
- Debt 1: [Missing tests/docs/etc]
- Debt 2: [Outdated dependencies]

METRICS:
- Cyclomatic Complexity: [Current score]
- Code Duplication: [% duplicated]
- Test Coverage: [Current %]
- Coupling: [High/Medium/Low]
```

2. REFACTORING STRATEGY
Step-by-step plan:
```
Phase 1: STABILIZE (Week 1)
□ Add tests for current behavior
□ Set up linting and formatting
□ Document existing functionality
□ Create safety net for refactoring

Phase 2: EXTRACT (Week 2-3)
□ Extract methods from large functions
□ Separate concerns into modules
□ Remove duplicate code
□ Introduce interfaces/contracts

Phase 3: RESTRUCTURE (Week 4-5)
□ Apply design patterns
□ Implement dependency injection
□ Create proper layers
□ Add proper error handling

Phase 4: OPTIMIZE (Week 6)
□ Performance improvements
□ Remove unnecessary code
□ Update dependencies
□ Add monitoring
```

3. REFACTORED CODE
Modern, clean implementation:
```[language]
// ============================================
// CLEAN VERSION WITH PROPER ARCHITECTURE
// ============================================

// Domain Models
class [Entity] {
    // Business logic here
}

// Repository Pattern
interface [Repository] {
    // Data access abstraction
}

class [RepositoryImpl] implements [Repository] {
    // Actual data access
}

// Service Layer
class [Service] {
    constructor(private repository: [Repository]) {
        // Dependency injection
    }
    
    // Business logic methods
}

// Controller/Handler
class [Controller] {
    constructor(private service: [Service]) {}
    
    // Request handling
}

// Dependency Injection Container
const container = {
    // Wire up dependencies
};
```

4. DESIGN PATTERNS APPLIED
Explain each pattern used:
- **Pattern 1:** [Name]
  - Why used: [Solves what problem]
  - Implementation: [How applied]
  
- **Pattern 2:** [Name]
  - Why used: [Benefit]
  - Implementation: [Where in code]

5. BEFORE/AFTER COMPARISON
Show the transformation:
```
BEFORE:
- Lines of Code: 500
- Functions: 3 (avg 166 lines each)
- Cyclomatic Complexity: 45
- Test Coverage: 0%
- Dependencies: Hardcoded
- Error Handling: Try-catch everything

AFTER:
- Lines of Code: 350
- Functions: 25 (avg 14 lines each)
- Cyclomatic Complexity: 8
- Test Coverage: 85%
- Dependencies: Injected
- Error Handling: Specific and meaningful
```

6. MIGRATION SCRIPT
Safe transition plan:
```[language]
// Step 1: Run in parallel
class LegacyAdapter {
    // Wrap new code to work with old
}

// Step 2: Feature flag
if (useNewImplementation) {
    // New clean code
} else {
    // Old code (temporary)
}

// Step 3: Data migration
async function migrateData() {
    // Move from old structure to new
}

// Step 4: Cleanup
// Remove old code after verification
```

7. UNIT TESTS
Comprehensive test suite:
```[language]
describe('[Module] Tests', () => {
    // Setup and teardown
    
    test('should handle normal case', () => {
        // Arrange
        // Act
        // Assert
    });
    
    test('should handle edge case', () => {
        // Test edge scenarios
    });
    
    test('should handle errors gracefully', () => {
        // Test error scenarios
    });
});
```

8. DOCUMENTATION
Clear documentation for maintenance:
```markdown
## Architecture Overview
[Diagram or description of new structure]

## Key Components
- Component A: Responsible for...
- Component B: Handles...

## Data Flow
1. Request comes in via...
2. Processed by...
3. Stored in...

## Configuration
- Environment variables needed
- How to set up locally
- Deployment instructions
```

9. PERFORMANCE IMPROVEMENTS
Optimizations made:
- **Before:** O(n²) nested loops
  **After:** O(n log n) with better algorithm
  
- **Before:** 5 database calls per request
  **After:** 1 optimized query
  
- **Before:** No caching
  **After:** Redis cache layer

- **Memory usage:** Reduced by 40%
- **Response time:** Improved by 60%

10. BREAKING CHANGES
What changes for consumers:
```
API Changes:
- Endpoint /old/path → /api/v2/resource
- Parameter oldParam → newParam
- Response format: XML → JSON

Database Changes:
- Table old_table → Split into table_a, table_b
- Column changes: [list changes]

Configuration:
- New required env vars: [list]
- Deprecated settings: [list]
```

11. ROLLBACK PLAN
If something goes wrong:
```bash
# Quick rollback procedure
1. Switch feature flag to 'old'
2. Restore database backup (if needed)
3. Deploy previous version
4. Investigate issues in staging
```

12. MONITORING & METRICS
Track the improvements:
- Response time metrics
- Error rate monitoring
- Memory usage tracking
- Code quality metrics
- Test coverage reports

Please ensure the refactored code:
- Follows SOLID principles
- Is easily testable
- Has clear separation of concerns
- Is well-documented
- Maintains backward compatibility where needed

Pro Tips:

Include the full context - surrounding code helps identify patterns
Mention any business logic that must be preserved
Specify if you need to maintain API compatibility
Note any performance requirements or constraints
Include examples of how the code is currently called/used

⚡ Code at Peak Performance

Long coding sessions demand sustained mental energy. Neuro Energizer uses scientifically-proven nootropics to enhance focus, memory, and cognitive speed - helping you debug faster, think clearer, and code better for hours without the crash.

Unlock Your Coding Potential →

*Sponsored - We may earn a commission if you purchase. This helps us keep all prompts free.

Legacy Code Refactorer

Pro Tips:

⚡ Code at Peak Performance

🚀 Works 10x Better With

The Genius Wave

Legacy Code Refactorer

Pro Tips:

Related Prompts

Unit Test Generator

Code Review Pro

Debug Master

⚡ Code at Peak Performance

🚀 Works 10x Better With

The Genius Wave