Refactoring Patterns

<default_to_action> When refactoring:

•ENSURE tests pass (never refactor without tests)
•MAKE small change (one refactoring at a time)
•RUN tests (must stay green)
•COMMIT (save progress)
•REPEAT

Safe Refactoring Cycle:

bash

npm test               # Green ✅
# Make ONE small change
npm test               # Still green ✅
git commit -m "refactor: extract calculateTotal"
# Repeat

Code Smells → Refactoring:

Smell	Refactoring
Long method (>20 lines)	Extract Method
Large class	Extract Class
Long parameter list (>3)	Introduce Parameter Object
Duplicated code	Extract Method/Class
Complex conditional	Decompose Conditional
Magic numbers	Named Constants
Nested loops	Replace Loop with Pipeline

NEVER REFACTOR:

•Without tests (write tests first)
•When deadline is tomorrow
•Code you don't understand
•Code that works and won't be touched </default_to_action>

Quick Reference Card

Common Refactorings

Pattern	Before	After
Extract Method	50-line function	5 small functions
Extract Class	Class doing 5 things	5 single-purpose classes
Parameter Object	`fn(a,b,c,d,e,f)`	`fn(options)`
Replace Conditional	`if (type === 'a') {...}`	Polymorphism
Pipeline	Nested loops	`.filter().map().reduce()`

The Rule of Three

•First time → Just do it
•Second time → Wince and duplicate
•Third time → Refactor

Key Patterns

Extract Method

javascript

// Before: Long method
function processOrder(order) {
  // 50 lines of validation, calculation, saving, emailing...
}

// After: Clear responsibilities
function processOrder(order) {
  validateOrder(order);
  const pricing = calculatePricing(order);
  const saved = saveOrder(order, pricing);
  sendConfirmationEmail(saved);
  return saved;
}

Replace Loop with Pipeline

javascript

// Before
let results = [];
for (let item of items) {
  if (item.inStock) {
    results.push(item.name.toUpperCase());
  }
}

// After
const results = items
  .filter(item => item.inStock)
  .map(item => item.name.toUpperCase());

Decompose Conditional

javascript

// Before
if (order.total > 1000 && customer.isPremium && allInStock(order)) {
  return 'FREE_SHIPPING';
}

// After
function isEligibleForFreeShipping(order, customer) {
  return isLargeOrder(order) &&
         isPremiumCustomer(customer) &&
         allInStock(order);
}

Refactoring Anti-Patterns

❌ Anti-Pattern	Problem	✅ Better
Without tests	No safety net	Write tests first
Big bang	Rewrite everything	Small incremental steps
For perfection	Endless tweaking	Good enough, move on
Premature abstraction	Pattern not clear yet	Wait for Rule of Three
During feature work	Mixed changes	Separate commits

Agent Integration

typescript

// Detect code smells
const smells = await Task("Detect Code Smells", {
  source: 'src/services/',
  patterns: ['long-method', 'large-class', 'duplicate-code']
}, "qe-quality-analyzer");

// Safe refactoring with test verification
await Task("Verify Refactoring", {
  beforeCommit: 'abc123',
  afterCommit: 'def456',
  expectSameBehavior: true
}, "qe-test-executor");

Agent Coordination Hints

Memory Namespace

code

aqe/refactoring/
├── smells/*          - Detected code smells
├── suggestions/*     - Refactoring recommendations
├── verifications/*   - Behavior preservation checks
└── history/*         - Refactoring log

Fleet Coordination

typescript

const refactoringFleet = await FleetManager.coordinate({
  strategy: 'refactoring',
  agents: [
    'qe-quality-analyzer',   // Identify targets
    'qe-test-generator',     // Add safety tests
    'qe-test-executor',      // Verify behavior
    'qe-test-refactorer'     // TDD refactor phase
  ],
  topology: 'sequential'
});

Related Skills

•tdd-london-chicago - TDD refactor phase
•code-review-quality - Review refactored code
•xp-practices - Collective ownership

Remember

Refactoring is NOT:

•Adding features
•Fixing bugs
•Performance optimization
•Rewriting from scratch

Refactoring IS:

•Improving structure
•Making code clearer
•Reducing complexity
•Removing duplication
•Without changing behavior

Always have tests. Always take small steps. Always keep tests green.