Cognitive Overload

1. Concept Overview & Systemic Problem

Software engineering involves manipulating invisible abstractions. A developer is forced to simultaneously hold in short-term memory:

• Business requirements of a feature.
• Structure of the relational database tables.
• State of the client cache and lifecycle of components.
• Potential network errors and security invariants.

When the number of active concepts exceeds the capacity of Working Memory, Cognitive Overload occurs. The brain begins to forcibly "offload" previous thoughts: the developer looks at the code and cannot remember why they wrote the previous line, misses obvious syntax errors, or feels a strong psychological reluctance to continue working (Brain Fog).

In the era of generative AI, the problem has intensified: the speed of information intake has increased tenfold. Instead of writing 10 lines, an engineer reads 100 lines of someone else's generated code every minute, leading to prefrontal cortex exhaustion before the middle of the workday.

Working Memory Capacity of an Engineer (Maximum 4 slots):
+-------------------------------------------------------------+
| Slot 1: Business logic for discount calculation              |
| Slot 2: State of the basket in Zustand store                |
| Slot 3: Database schema in Prisma                            |
| Slot 4: Handling HTTP error 401 Unauthorized                 |
+-------------------------------------------------------------+
  |
  +---> NEW INPUT SIGNAL: "Slack notification about a bug"
  v
OVERFLOW (Cognitive Failure):
Slot 1 drops from memory. The engineer loses the thread of logic and makes a critical bug.

2. Architectural Taxonomy & Mental Model

Protecting cognitive resources is based on the principle of Cognitive Offloading:

1. Externalized Cognition:
   • Everything that does not need to be held in the head should be recorded externally: Scratchpad (draft of thoughts in Markdown), architecture diagrams (Mermaid), or open interface contracts.
2. Reducing Extraneous Load:
   • Eliminating visual and syntactic noise: automatic code formatting (Biome / Prettier), categorical rejection of over-engineered patterns, clear naming of entities.
3. Chunking:
   • Grouping a set of low-level concepts into one high-level abstract block. For example, instead of holding 6 socket fields in memory, a single concept ConnectionState is used.

3. Technical Pipeline & Internal Mechanics

Architectural Refactoring to Reduce Load

Before (Cognitive Overload: 9 variables in the visibility zone):

function processOrder(order: Order, user: User, coupon: Coupon, db: DB, mailer: Mailer) {
  let discount = 0;
  if (coupon && coupon.active && order.total > coupon.min) {
    if (coupon.type === 'PERCENT') discount = order.total * coupon.value;
    else discount = coupon.value;
  }
  let tax = (order.total - discount) * 0.2;
  let finalPrice = order.total - discount + tax;
  if (user.balance >= finalPrice) {
    user.balance -= finalPrice;
    db.save(user);
    db.saveOrder(order, finalPrice);
    mailer.sendReceipt(user.email, finalPrice);
  }
}

After (Decomposed into clean modules: load 2-3 entities):

// Chunk 1: Clean price calculation (easy to hold in mind, 100% tests)
const pricing = calculateOrderPrice(order.total, coupon);

// Chunk 2: Transactional charge (clear business contract)
await paymentService.chargeUser(user.id, pricing.finalAmount);

Personal Engineering Hygiene Protocol "Clean Slate"

[Session Start] ---> Create SCRATCHPAD.md file
                            |
                            v
[Record current goal in one line: "Add index to users.email"]
                            |
                            v
[Absolute isolation: turn off Slack / Telegram notifications for 45 minutes]
                            |
                            v
[Complete atomic step: commit to git]
                            |
                            v
[Clear Scratchpad -> 10-minute screen-free break]

4. Production Engineering Scenarios

01. Offloading Working Memory via Architecture Decision Records (ADR)

The team maintains short Markdown files in the docs/adr/ folder, documenting why SQLite was chosen over PostgreSQL for a specific microservice. When a new engineer or agent enters the repository, they do not need to spend hours guessing or interviewing colleagues: context is restored in 3 minutes of reading the document.

02. Using Strict TypeScript Instead of Runtime Checks

Without strict typing, the developer must remember in every function: "Can the user object be undefined? Does it have an address field?" Enabling strict: true in tsconfig.json shifts this burden to the compiler: a red squiggly line immediately alerts to an error, offloading the brain for designing business logic.

03. Batch Reviewing Generated AI Code

Instead of checking each change mid-dialogue with the assistant, the engineer runs an agent in an isolated background window with a complete test suite. The engineer only reviews the results once the agent has completed the entire batch and run the linter. This replaces 20 exhausting context switches with one calm 5-minute audit.

5. Pitfalls, Common Mistakes & Security

1. Ignoring Early Symptoms of Exhaustion: When the brain is overloaded, the first areas to fail are self-control and critical thinking. The engineer begins to feel false confidence ("this will definitely work without checking") or falls into desperate chaotic debugging by trial and error. Upon noticing this state, the only correct solution is to step away from the computer for 20 minutes.
2. The Clean Architecture Trap: Attempting to create 6 layers of indirection (Controllers, Use Cases, Repositories, Entities, Data Mappers, DTOs) for a simple CRUD application generates colossal external cognitive load. The engineer spends 80% of their attention jumping between files instead of solving the client's problem.
3. Multimodal Information Bombardment: Trying to code while simultaneously listening to a technical podcast or reading messages in a work chat guarantees cognitive collapse. Complex logic requires 100% monopolization of attention on a single object.