refactor

name	refactor
description	Refactor code for quality and maintainability. Use for cleanup and tech debt reduction.

Code Refactoring

Improve code quality without changing behavior.

When to Use

• Code is hard to understand or modify
• Duplicated logic across files
• Functions/classes are too large
• Technical debt reduction
• Before adding new features

Refactoring Process

1. Ensure tests exist - Add tests before refactoring
2. Small steps - Make incremental changes
3. Run tests - Verify after each change
4. Commit often - Keep changes reversible

Common Refactorings

Extract Function

// Before
function processOrder(order) {
  // 50 lines of validation
  // 30 lines of calculation
  // 20 lines of notification
}

// After
function processOrder(order) {
  validateOrder(order);
  const total = calculateTotal(order);
  notifyCustomer(order, total);
}

Replace Conditionals with Polymorphism

// Before
function getPrice(type) {
  if (type === "regular") return basePrice;
  if (type === "premium") return basePrice * 1.5;
  if (type === "vip") return basePrice * 0.8;
}

// After
const pricingStrategies = {
  regular: (base) => base,
  premium: (base) => base * 1.5,
  vip: (base) => base * 0.8,
};
const getPrice = (type) => pricingStrategies[type](basePrice);

Remove Duplication

// Before
function getUserName(user) {
  return user?.profile?.name ?? "Unknown";
}
function getOrderName(order) {
  return order?.customer?.name ?? "Unknown";
}

// After
const getName = (obj, path) => path.reduce((o, k) => o?.[k], obj) ?? "Unknown";
const getUserName = (user) => getName(user, ["profile", "name"]);
const getOrderName = (order) => getName(order, ["customer", "name"]);

Code Smells

Smell	Symptom	Refactoring
Long Function	>20 lines	Extract Function
Large Class	>200 lines	Extract Class
Duplicate Code	Same logic repeated	Extract and reuse
Long Parameter	>3 params	Use object/builder
Feature Envy	Uses other class's data	Move method
Primitive Obsession	Strings for everything	Create value objects

Quality Metrics

• Cyclomatic Complexity - Keep under 10 per function
• Nesting Depth - Max 3 levels
• Function Length - Under 20 lines preferred
• File Length - Under 300 lines preferred

Safety Checklist

• Tests exist and pass
• No behavior changes intended
• Changes are incremental
• Each step is committed
• Code review requested

Examples

Input: "This function is too long" Action: Identify logical sections, extract into focused functions, verify tests pass

Input: "Reduce duplication in these files" Action: Find common patterns, extract shared utilities, update call sites