compact-guard-clauses

Compact Guard Clauses (Early-Return Pattern)

Overview

Default AI code generation often falls into the "Pyramid of Doom" anti-pattern: nesting execution logic 4 to 6 levels deep inside cascading if/else checks ("if user exists $\rightarrow$ if authorized $\rightarrow$ if has active plan $\rightarrow$ if payment valid...").

Deeply nested code increases cyclomatic complexity, wastes 2 to 6 tokens per line on leading indentation whitespace, and creates cognitive fatigue during subsequent code reviews and diff patching.

The Compact Guard Clause Protocol (also known as the Bouncer Pattern) checks for failure conditions at the very top of the function and returns/raises immediately, allowing the primary "happy path" to execute unnested at root indentation.

Nested Pyramid vs. Early-Return Guard Clauses

┌─────────────────────────────────────────────────────────────┐
│                 Indentation & Nesting Impact                │
│                                                             │
│  Nested Pyramid of Doom (Deep Nesting / Token Bloat):       │
│  function processOrder(order) {                             │
│    if (order !== null) {                                    │
│      if (order.isValid) {                                   │
│        if (order.items.length > 0) {                        │
│          // 25 lines indented 8 spaces deep...              │
│          return executeCheckout(order);                     │
│        } else { return { err: "Empty items" }; }            │
│      } else { return { err: "Invalid order" }; }            │
│    } else { return { err: "Null order" }; }                 │
│  }                                                          │
│                                                             │
│  Linear Guard Clauses (Bouncer Pattern - 40% Fewer Tokens): │
│  function processOrder(order) {                             │
│    if (!order) return { err: "Null order" };                │
│    if (!order.isValid) return { err: "Invalid order" };     │
│    if (!order.items.length) return { err: "Empty items" };  │
│                                                             │
│    // Happy path executes flat at root level                │
│    return executeCheckout(order);                           │
│  }                                                          │
└─────────────────────────────────────────────────────────────┘