simplify-code

Simplify Code

Code costs more to read than to write. Treat every extra layer, branch, and clever trick as a debt that future readers pay interest on. Remove it unless it earns its keep.

The one rule that governs the rest

Simplicity is not a style preference; it is the absence of structure that does not pull its weight. Keep an abstraction only when you can name the concrete benefit it provides right now. "We might need it later" is not a benefit you have today.

What to hunt for

Indirection that adds nothing

You see	You probably want
A class that forwards every call to another object	The inner object, used directly
A factory that only ever builds one concrete type	A plain constructor call
An interface with exactly one implementer	The concrete class, interface deleted
A "strategy" with a single strategy	An ordinary function
A base class extended by one subclass	The two folded together
An options struct holding two fields	Two positional arguments

Code nothing reaches

• Imports referenced nowhere
• Branches that can never be true (confirm via tests before deleting)
• Old code left behind in comments — version control already remembers it
• Variables assigned but never read; functions called from nowhere
• Stale TODO notes — act on them or file a ticket, then delete
• Toggles guarding a feature that already shipped to everyone

Pyramids of nesting

Flatten with guard clauses and pipeline-style collection methods.

# Tangled: four levels before any real work happens
def notify_active(payload):
    if payload:
        if payload.get("recipients"):
            for r in payload["recipients"]:
                if r.get("subscribed"):
                    send(r)

# Flat: bail early, then express the intent in one chain
def notify_active(payload):
    recipients = (payload or {}).get("recipients") or []
    for r in recipients:
        if r.get("subscribed"):
            send(r)

Functions that ask for too much