The full token stack, six weeks in: a field report

I wrote the theory version of this in the stacking post: token savings compound because each layer deletes a different kind of nothing. That post was an argument. This one is a receipt: six weeks of running the full stack on real client work, with the ledger open.

The stack, in the order a token flows through it: the code graph decides what enters context at all. Queries over structure, not stuffed files. Headroom compresses whatever still has to go in. On the way out, Caveman strips the prose to signal and Ponytail strips the code to the laziest thing that works. Four layers, two on input, two on output, no overlap in what they cut.

The numbers, with appropriate embarrassment

I'm not going to pretend this is a controlled study. Same codebase, similar ticket mix, May versus late June, one engineer, n=me. With that disclaimer nailed up:

• Input tokens per task fell to roughly a fifth. The graph did most of that by never fetching the irrelevant files in the first place; Headroom took another two-thirds off what remained.
• Output tokens per task fell by a bit over half. Caveman's share is bigger than Ponytail's, but Ponytail's cuts are the ones that keep paying: less code merged is less code reviewed, tested, and maintained.
• The invoice, which is the only number my accountant respects, landed somewhere between 7× and 9× lower depending on the week. Call it 8× and don't quote me to one decimal.

Quality is the number everyone asks about and the hardest to defend. My proxy: review outcomes. Rework rate on agent-produced diffs was flat across the six weeks, slightly better in June, inside the noise. Nothing I shipped in the cheap regime has come back to bite me yet, and "yet" is doing normal engineering-blog work in that sentence.

Every layer that only deletes non-information is a layer you can stack without paying quality back. The whole trick is refusing layers that delete anything else.

What broke when I stacked them

Two interactions worth knowing about.

Caveman plus Ponytail compound on the output side, and at ultra settings they compound too far. A three-word explanation of a deliberately minimal diff is not reviewable by anyone but the author, and barely by him. The fix was policy, not tooling: terse to me, full sentences in anything a teammate reads. Both skills have the escape hatches; you just have to decide to use them.

And the graph plus Headroom occasionally double-compress: the graph returns a scoped snippet, Headroom compresses it again, and twice in six weeks the agent retrieved the raw version right back (net token loss, with extra steps). Rare, self-correcting, mildly comic. I exempted graph output from compression and moved on.

The ranking nobody asked for

If I had to keep one layer: the graph. It changed what enters context, which is upstream of everything, and it made reviews better independent of cost. That story's in its own post. Second: Headroom, for effort-to-savings ratio; it's the only layer with literally zero workflow cost. Third: Caveman, which saves real money and turned out to be a legibility tool wearing a cost-cutting costume. Fourth: Ponytail, not because it saves least, but because its savings arrive as deleted future maintenance, and my six-week window can't measure that. Ask me in a year; I suspect it moves up.

The meta-lesson after six weeks: none of this felt like austerity. It felt like the system getting quieter. Cost was the metric, but what I actually bought was an agent whose every token (in and out) is one I'd have chosen to pay for. I didn't budget my way into this. This is just engineering, finally applied to the part of the pipeline we'd all agreed not to look at.