### Reduce Cognitive Load By:

*1. Simplify Conditionals*

``` // High cognitive load if val > someConstant && (condition2 || condition3) && (condition4 && !condition5)

// Low cognitive load isValid = val > someConstant isAllowed = condition2 || condition3 isSecure = condition4 && !condition5 if isValid && isAllowed && isSecure ```

*2. Use Early Returns*

``` // Nested ifs if isValid { if isSecure { doStuff() } }

// Early returns if !isValid { return } if !isSecure { return } doStuff() // Happy path is clear ```

*3. Prefer Deep Modules*

- *Deep module*: Simple interface, complex implementation (e.g., UNIX I/O with 5 methods) - *Shallow module*: Complex interface for simple functionality - Few deep classes > Many shallow classes

*4. Use Self-Describing Values*

``` // Numeric codes requiring mental mapping 401 // expired token? 403 // insufficient access?

// Self-describing { "code": "jwt_has_expired" } ```

*5. Apply DRY Carefully*

- Don't create abstractions too early - Avoid tight coupling between unrelated components

### Avoid These Anti-Patterns:

*1. Inheritance Chains*

``` AdminController extends UserController extends GuestController extends BaseController Use composition instead ```

*2. Too Many Layers*

- Unnecessary abstraction layers add indirection, not simplicity - Only add abstractions when you need actual need to

*3. Framework Magic*

- Keep business logic framework-agnostic - Use frameworks as libraries, not containers for your logic - New developers shouldn't need months to learn framework "magic"