ARCHITECTURAL DOCTRINE • ESSAY

Why Alum?
The Anatomy of an AI Code Collapse.

Everyone is vibe-coding. AI enables software creation at 200 mph until you slam into the architectural wall. Generating code is cheap—maintaining messy AI spaghetti is ruinously expensive. Here is why unconstrained code collapses, and why mechanical AST friction is the only permanent solution.

The Four Stages of AI Code Decay

How effortless prototypes decay into untestable, fragile monoliths within days.

STAGE 01 • 100% EUPHORIA

The Vibe-Coding High

You type intent into Cursor, Claude Code, or Windsurf. Code materializes instantly. The frontend looks polished, database migrations execute, and an entire working SaaS prototype emerges in a single afternoon. You feel invulnerable—traditional software engineering feels obsolete.

Symptom: Velocity is infinite. Architecture is completely ignored. Zero tests exist.

STAGE 02 • INVISIBLE ROT

The Hidden Creep

Feature additions begin sprawling across the codebase. Because autonomous coding agents prioritize generating immediate working syntax over structural design, files quietly swell past 800 lines. The agent nests conditional logic 4 to 5 levels deep, handles error states by slapping on else if cascades, and passes raw primitive strings across decoupled boundaries.

Symptom: Diff size balloons. Methods take 6 arguments. God objects accumulate all business logic.

STAGE 03 • ZERO VELOCITY

The Refactoring Wall

Modifying a simple payment checkout button inexplicably breaks session authentication. You ask the AI to fix it: the model hallucinates, overwrites critical business logic, re-introduces previously solved bugs, and produces cyclic dependencies. Context windows choke. The developer spends 8 hours prompting in circles trying to undo the damage, eventually wanting to scrap the repository and start over.

Symptom: Negative velocity. Every prompt causes 3 regressions. Founder desperation peaks.

STAGE 04 • PERMANENCE

The Alum Cure

Alum rejects untidy code mechanically at the AST layer before it is ever committed. It serves as an external verification cage that coding agents invoke directly. By forbidding more than 1 level of indentation, banning else, and requiring wrapped domain primitives, Alum forces the agent to self-correct and refactor code into clean, micro-modular components on the fly.

Result: High velocity remains durable. Codebase remains legible and modular indefinitely.

CRITICAL STRATEGY

The Anti-Captivity Mandate: Stop Renting Your Architecture

The mega-labs want you to believe that "bigger context windows and frontier reasoning models will fix your messy code." This is cognitive feudalism.

When your codebase is composed of 1,500-line God objects and tangled dependencies, lightweight models choke. You become permanently captive to expensive closed frontier models ($20/M tokens) just to make a routine bug fix. If mega-labs raise prices, rate-limit your keys, or suffer outages, your engineering operations halt.

Alum breaks the trap: By mechanically enforcing micro-functions (<15 lines) and bounded Value Objects, every unit of your code fits cleanly into small, fast context windows. You can run, maintain, and evolve your entire system using hyper-efficient, commodity models like Gemini 3.5 Flash or local 8B LLMs for pennies.

Architectural Model Comparison

Comparing raw unconstrained AI code generation against Alum-governed architecture:

Dimension	Unconstrained Vibe-Coding	Alum Governed Architecture
Indentation Depth	Unlimited (4–6 nested levels)	Strict Maximum: 1 Level
Conditionals	Sprawling `else if` cascades	Zero `else` keywords (Polymorphism / Early Return)
Domain Types	Raw primitives (`string`, `number` everywhere)	Wrapped Domain Value Objects
File Sizes	God classes (500–2,000 lines)	Micro-modules (≤200 lines max)
Model Dependency	Locked into $20/M token frontier models	Commodity & local models (Gemini 3.5 Flash, 8B SLMs)

How Autonomous Agents Consume Alum

Alum is designed from first principles as an external CLI instrument that agents like Claude Code or Cursor invoke in the terminal. Here is the instruction stencil developers stamp into CLAUDE.md or AGENTS.md:

CLAUDE.md / AGENTS.md STENCIL

# Architectural Invariant Verification Cage (Alum) Before presenting any code diff or declaring a task complete, you MUST execute: `alum audit --context src/` Rules Enforced by Alum AST Governor: 1. Max 1 level of indentation per method. 2. ZERO use of the 'else' keyword. Use guard clauses or polymorphism. 3. Wrap all primitives into domain Value Objects. 4. First-class collections only. 5. Max 2 instance variables per class. If `alum audit` exits with code > 0, you must refactor the implementation until all invariants pass with exit code 0. Do NOT attempt to disable or bypass the governor.

Why Alum? The Anatomy of an AI Code Collapse.