refactoring

Refactoring

When to use this skill

• Code is hard to read or understand
• Duplicated logic across multiple places
• Functions or classes are too large
• Adding a feature requires touching too many files
• Code smells identified during review
• Preparing code for a new feature

Golden rule

Refactoring must not change behavior. Tests should pass before and after. If no tests exist, write them first.

# Run tests before starting
npm test  # or pytest, go test, etc.
# Make refactoring changes
# Run tests after every change
npm test

Common refactoring patterns

Extract function

When a block of code does one distinct thing:

// Before
function processOrder(order: Order) {
  // validate
  if (!order.items.length) throw new Error('Empty order');
  if (order.items.some(i => i.quantity <= 0)) throw new Error('Invalid quantity');
  if (!order.customerId) throw new Error('No customer');

  // calculate total
  let total = 0;
  for (const item of order.items) {
    total += item.price * item.quantity;
  }
  const tax = total * 0.1;
  const finalTotal = total + tax;

  // save
  db.save({ ...order, total: finalTotal });
}

// After
function validateOrder(order: Order): void {
  if (!order.items.length) throw new Error('Empty order');
  if (order.items.some(i => i.quantity <= 0)) throw new Error('Invalid quantity');
  if (!order.customerId) throw new Error('No customer');
}

function calculateTotal(items: OrderItem[]): number {
  const subtotal = items.reduce((sum, i) => sum + i.price * i.quantity, 0);
  return subtotal * 1.1; // includes 10% tax
}

function processOrder(order: Order) {
  validateOrder(order);
  const total = calculateTotal(order.items);
  db.save({ ...order, total });
}

Replace conditional with polymorphism

// Before: switch on type
function calculateShipping(order: Order): number {
  switch (order.shippingType) {
    case 'standard': return order.weight * 1.5;
    case 'express': return order.weight * 3.0 + 10;
    case 'overnight': return order.weight * 5.0 + 25;
    default: throw new Error('Unknown shipping type');
  }
}

// After: strategy pattern
const shippingStrategies: Record<string, (weight: number) => number> = {
  standard: (weight) => weight * 1.5,
  express: (weight) => weight * 3.0 + 10,
  overnight: (weight) => weight * 5.0 + 25,
};

function calculateShipping(order: Order): number {
  const strategy = shippingStrategies[order.shippingType];
  if (!strategy) throw new Error('Unknown shipping type');
  return strategy(order.weight);
}