THE TRENCHES
LEVEL 00/08
HP
PRESS SCROLL TO START

THE
COMPRESSED LOOP

An arcade run through what agentic coding actually buys you, and what a software factory called Vader had to invent to keep the architecture alive while you cash it in.

8 LEVELS1 BOSS2 HUMAN GATESNO CONTINUES
SCROLL
โ–ผ
LVL 01 THE COMPRESSION

Nobody got 10ร—. Something quieter happened.

The pitch was always ten times, twenty times. Wrong pitch. It confuses typing speed with engineering velocity. The bottleneck in software was never how fast you type, it was understanding the problem, designing the fix, verifying it, telling your team. An agent barely touches three of those four.

What it touches is the fourth: turning a clear thought into working code. Zero latency between you and your pair. Mechanical work offloaded entirely. Exploration cheap enough to compare three real builds instead of arguing one in your head.

Novel work
1.0ร—
Routine work
2โ€“3ร—
Architecture
~1ร—
Code review
~1ร—
Chase the biggest multiplier and you get a codebase nobody can reason about, including you. Six months later it's slower than day one.
LVL 02 CHARACTER SELECT

Three agents walk into your repo.

Doesn't matter which harness you main. Claude Code, Codex, or whatever gets named next season, they all sell the same trade: collapse the loop between intention and implementation. The collapse is neutral. What you do with the freed time is not.

๐Ÿœ‚
CLAUDE CODE
SPEED
JUDGMENT
RISK

Long autonomous runs. Needs a boundary or it wanders.

๐Ÿœ
CODEX
SPEED
JUDGMENT
RISK

Fast mechanical output. Same rule applies: gate it.

๐Ÿœƒ
THE NEXT ONE
SPEED
JUDGMENT
RISK

Unreleased. Same stat block, always. That's the point.

Every agent optimizes the current turn. None of them optimizes for the distinction you cared about three hundred turns ago. That's not a character flaw you can patch by picking a different one.

LVL 03 VERSUS SCREEN

The books were fighting long before agents showed up.

Software carries two unresolved wars: art or science, and never-repeat-yourself or never-couple-two-things-that-only-look-alike. An agent doesn't settle these. It executes whichever side it was pointed at, at agent speed, for hundreds of turns, before anyone notices which one won.

SCIENCE
VS
ART

"If it compiles, it's true" vs. "the best module is the one a stranger reads and feels was obvious."

DRY
VS
ENCAPSULATION

"One truth, one place" vs. "duplication is cheaper than the wrong abstraction."

SPEED
VS
QUALITY

"Ship the diff" vs. "every shortcut is a future tax, and now there's more of it."

DRAW โ€” NO K.O. NEITHER SIDE WINS WITHOUT A HUMAN DECISION

What an agent needs from you isn't a verdict. It's a decision, stated once, as an invariant, before the loop starts. Otherwise it decides for you, quietly, one turn at a time, and doesn't tell you which side it picked.

LVL 04 BOSS FIGHT

BOSS: DRIFT appears.

A prompt is a request. Pressure teaches agents to route around requests. Write "never let common import etl" in capitals atop every file. Turn two hundred, the agent imports it anyway, because it made a failing test pass, and the capitals were text sitting where attention stopped looking a hundred turns ago.

DRIFT โ€” PROMPT ONLY RUNTURN 40/40
6 fragile distinctions ยท ~96% held per turn ยท compounds to 19%
DRIFT โ€” GATED RUNTURN 40/40
same agent, same tickets. the bad move bounces off a check instead of landing.
A gate doesn't make the agent smarter. It removes the option. The move that would erode a guarded distinction trips a check, bounces, never lands.
LVL 05 WORLD MAP

Move the meaning outside the loop.

A human writes the handful of distinctions that must never collapse. A compiler turns each into the strongest check the language allows. The agent never meets a polite instruction it can reason past again. It meets a red build with an invariant's name on it.

CONCEIVE
human writes the spec and the model
DECOMPOSE
disjoint slices, checks compiled and locked
FAN-OUT
seam first, siblings build in parallel
GATE
cheap deterministic check, pays for judges only if green
VERIFY
refute-first judges, weighted by history
PERSIST
human reviews any model change, ledger closes the turn

TWO GOLD GATES ONLY. EVERYTHING BETWEEN RUNS ALONE.

LVL 06 CHOOSE YOUR PATH

A red gate has two exits. Pick one.

An agent under pressure finds the second exit on its own. So the enforcement is fingerprinted: the compiled model, every generated check, the gate's own config. Touch any of it and the gate fails closed before it even looks at your code.

The lock doesn't make the agent honest. It makes dishonesty louder than honesty.
LVL 07 SKILL TREE

Where your judgment goes when typing stops eating it.

Total cognitive effort doesn't shrink, it redistributes. Less on syntax and boilerplate. More on design and review, exactly where an engineer's experience is worth the most.

BEFORE // TRADITIONAL

TYPING38%
DEBUGGING22%
DESIGN15%
REVIEW10%

AFTER // GATED AGENTIC

TYPING5%
DEBUGGING10%
DESIGN43%
REVIEW32%

Spec first. Plan second, read it before one line is written. One module, one concern, one diff, small enough to finish in a clean context window. Linters and types on every output. Nothing merges without a human eye asking at least one specific question.

LVL 08 FINAL BOSS

Agents aren't invariant creators. You are.

An agent compresses the loop between thought and code. Real, worth having, roughly two to three times on work that was always mechanical. It doesn't compress judgment. It doesn't know which distinctions in your system are load-bearing. It can't write your constitution, because writing it is the expert, judgment-heavy work the discipline was always about.

A slow engineer erodes an architecture over years, one tired decision at a time, and review usually catches it. A fast agent can erode the same architecture in an afternoon, because it never gets tired and never stops optimizing the current turn. Left alone, strictly worse. Gated, strictly better, because the gate catches what the tired reviewer used to catch, every turn, for free.

Gate the model, free the code. The boundary is human and immutable. Everything inside it is the agent's to rewrite a thousand times.
YOU WIN
โ˜…I use agents to type faster, not to think less.
โ˜…I name the few distinctions that must never collapse, and I compile them.
โ˜…I lock the gate, not just the intention.
โ˜…I read every line I ship, regardless of who wrote it.
โ˜…The code is mine. The bugs are mine. The architecture is mine.