Fear Complexity

Complexity enters a codebase quietly.

First it's just one abstraction that feels elegant. Then it's a pattern that handles multiple cases. Then it's a framework of frameworks. Before long, simple changes take days because you have to understand five layers of indirection to modify one behavior. Deployments become scary. Every change might break something in an unexpected place.

The instinct early in your career is to prove you're smart. Use the fanciest patterns. Build deep inheritance hierarchies. Create generic abstractions that handle every possible future case. Then you maintain that code for two years, and the lesson lands hard.

The engineers who've been through this cycle learn to fear complexity. They know how it compounds. They've watched projects collapse under the weight of their own cleverness. So they start choosing the boring option on purpose:

// Complex: Layers of abstraction for a simple operation
class PaymentProcessorFactory {
  createProcessor(strategy: PaymentStrategy): PaymentProcessor {
    return new ConcretePaymentProcessor(
      new PaymentValidatorDecorator(
        new LoggingPaymentWrapper(strategy)
      )
    );
  }
}

// Simple: Direct and clear
function processPayment(order: Order, card: Card) {
  validateCard(card);
  const charge = chargeCard(card, order.total);
  logPayment(charge);
  return charge;
}

Simple tools that just work beat elegant architectures that require a manual.

The best defense against complexity is prevention. That means saying no early — no, we're not building that feature yet; no, we're not abstracting this until we've written it a few times and seen the real pattern; no, we're not adding flexibility "just in case." Early in a project, everything is liquid. Abstract too soon and you freeze the wrong shape in place.

Complexity rarely announces itself. It accumulates in small decisions that each seemed reasonable at the time. The skill isn't spotting it after the damage is done — it's developing an instinct for when something is about to get harder than it needs to be, and choosing the simpler path before the window closes.