refactor-with-ai

Refactor with AI

Safely refactor code with AI assistance while preserving behavior.

When to Use

• Cleaning up messy or complex code
• Extracting reusable functions/components
• Modernizing legacy patterns
• Reducing cyclomatic complexity
• Applying design patterns
• Preparing code for new features

The Safe Refactoring Process

┌─────────────────────────────────────────┐
│ 1. CHARACTERIZE - Understand current    │
│    behavior with tests                  │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│ 2. IDENTIFY - Find specific smells      │
│    and improvement opportunities        │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│ 3. REFACTOR - Small, incremental        │
│    changes with AI assistance           │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│ 4. VERIFY - Tests still pass,           │
│    behavior unchanged                   │
└─────────────────────────────────────────┘

Step 1: Characterize with Tests

Before ANY refactoring, ensure behavior is captured.

// If no tests exist, create characterization tests
describe('OrderProcessor (characterization)', () => {
  it('processes valid order', () => {
    const result = processor.process(validOrder);
    // Capture current behavior, even if not ideal
    expect(result).toMatchSnapshot();
  });

  it('handles edge cases', () => {
    expect(processor.process(null)).toBeNull();
    expect(processor.process(emptyOrder)).toEqual({ status: 'empty' });
  });
});

Step 2: Identify Code Smells

Common Smells to Look For

Smell	Sign	Refactoring
Long Method	>20 lines	Extract Method
Long Parameter List	>3 params	Introduce Parameter Object
Duplicate Code	Copy-paste	Extract and reuse
Nested Conditionals	>3 levels deep	Guard clauses, early return
Feature Envy	Uses other class's data	Move method
Data Clumps	Same params together	Create class/type
Primitive Obsession	Strings for everything	Value objects
Switch Statements	Type checking	Polymorphism