Ask Claude to Replace Imperative Loops with Functional Array Methods

Imperative loops with manual index tracking and temporary variables are harder to read than they need to be. Claude Code can refactor them to functional array methods while keeping all the behavior identical.

Refactor all for loops in src/utils/ to use map, filter, reduce, 
or flatMap where appropriate. Don't change any behavior — 
the tests should still pass after the refactor.

Claude reads each loop, understands what it's actually doing — filtering, transforming, accumulating, or flattening — and picks the right method:

// Before: imperative loop
const activeUsers = [];
for (let i = 0; i < users.length; i++) {
  if (users[i].isActive) {
    activeUsers.push({
      name: users[i].name,
      email: users[i].email
    });
  }
}

// After: functional chain
const activeUsers = users
  .filter(user => user.isActive)
  .map(({ name, email }) => ({ name, email }));

Claude knows when not to convert too — some loops are better left as loops:

# Smart conversion
Refactor the loops in src/services/DataProcessor.ts to functional methods. 
If a loop has early returns, break statements, or complex state mutations 
that don't convert cleanly, leave it as a loop and add a comment explaining why.

This works for different patterns:

# Nested loops to flatMap
Convert the nested loops that build the options array to a single flatMap chain.

# Accumulator patterns to reduce
Replace the manual totaling loops in src/billing/ with reduce calls.

# forEach with side effects
Convert forEach calls that push to external arrays into proper 
map/filter chains that return the result directly.

After the refactor, ask Claude to verify the tests pass — functional refactors should be invisible to the test suite since they don't change behavior, only style.

Loops tell the computer what steps to take. Array methods tell the reader what's happening. Let Claude translate between the two.

via Claude Code