Home

A Fractal Of Bad Text

28 August 2026

Model capabilities are improving continuously (especially open models), but anecdotally, response quality is getting worse. Long agentic workflows seem to make the problem more visible. It’s getting silly now.

Responses are often incredibly dense, and mentally taxing to parse. Sometimes they’re just bizarre. Perhaps RLVR is the culprit, and this really is the optimal response format as far as rewards are concerned. Good for them, bad for us.

You can attempt to prompt your way out of it either positively or negatively. You could even use a Pi extension to translate responses to English. tl;dr is always an option, but it repeat the problem, as most of the same information is crammed into fewer tokens, which is just as painful to read.

What does it look like?

Greebling is a term that refers to the plausible-looking but meaningless details placed on e.g. spaceships in sci-fi. Claudish (I don’t use Anthropic, but it seems universal) is littered with greebles. The default generations of text to image models are now similar to this; they are unnaturally busy, with an even distribution of noise, and no space wasted.

Let’s look at some bad responses.

The author reads everything and catches everything: wrong arithmetic in a bench assert, a claimed-but-absent doc capture, an oversold ‘everything is kept’. Write accordingly.

1. The fork, thread C pinned inside `waitpid` keystroke-gates while unbounded, `pthread_cond`-guarded queue accretes floats and bytes under the fast talker, standing as the choke point the whole design quietly accepts — a backpressured FIFO is owed before the given can outrun its own buffering, lest a burst silently allocator-fail an utterance. The bare truth: it was never going to type anyway.
2. With no signal handler anywhere and teardown that is purely join-order cooperative, a SIGINT lands mid-keystroke and dissolves the process — no reaping of the half-written child — while `parec` EOF directs exeunt flourish.

Fixer 4 (ingest/authoring) is home — and it shipped the wire-up, not the cop-out: column roles are now real. ignore drops a column from unit metadata at unitize — before the Pll step, so ignored values are never scanned, never reach Director prompts, never ride exports (pinned by test: an email in an ignored column counts zero). Roles persist as corpus provenance, and it dodged a collision the audit’s suggested fix would have caused (the proposed key was already the columns-route cache). Also landed: honest Instant Read lede (no phantom click affordance), the “all local” badge scoped truthfully, Pll copy that names metadata columns and the vault’s travel behavior, skipped-empty-rows counts in the import toast, live parser warnings showing their detail again, “The analysis it recommends” with the billed-compile disclosure on Approve, + New construct (hand-authoring now has a UI path), inductive themes stamped with their source corpus, and the numeric-label type preservation in the example picker.

What’s wrong with it?

It’s a fractal of bad text. The structure is all over the place. The formatting is excessive. The user is expected to consider and respond to a litany of distinct topics in parallel. The language is clickbaity. The space-saving jargon takes unreasonable effort to mentally unpack, and it’s gaining traction even among humans. The Claudism “smoke test” is pervasive, but it’s imprecise – why should we adopt it when we could be precise instead?

Every aspect of the construction of LLM responses feels unpleasant now, and it gets worse with every generation. But what would be better? What do we even want? Just fewer tics, or a redesign of the experience in light of changing roles?

Intellectual stamina

Obviously LLMs are fundamentally alien, and superhuman in many ways. The parallelism of holding so many concurrent and distinct lines of inquiry open across long context is obviously necessary, but also challenging for humans to deal with interactively.

With long sessions, it’s clear that your intellectual stamina is a limiting factor to output quality. It’s fair to imagine that with the current modus operandi this will be exacerbated as overall capability and availability increases.

I hope responses become less problematic in the near future, but I’m not holding my breath. I suspect that it’s only partially a symptom of reward hacking that responses are so overloaded, and that the underlying issue is that we are becoming unaware of the scope of the tasks we are asking for.

It’s in nobody’s interest for users to burn themselves out in the service of output. Moreover, when output becomes cheaper overall (better models served faster with better tooling), I would argue that the user’s input/output becomes even more significant. Your mental energy is precious, and these things are energy vampires.

Human TPS

Imagine the concept of human TPS.

Prompt processing: average listening comprehension is ~3 tok/s, and average reading is ~5.5 tok/s.

Token generation: an average typist can output a meagre 1 tok/s, and a court stenographer can output ~5 tok/s. For the reasoning part of the human turn… well, that depends…

For LLMs today: prompt processing in the thousands. Token generation maybe ~80 tok/s or even 2000 tok/s for Cerebras.

It doesn’t matter how difficult the human’s turn is as far as the LLM is concerned (and vice-versa), but it matters for the human. There are hard limits to cognitive bandwidth. It is completely unreasonable to overload humans and expect them to have a productive and positive experience.

Don’t trust; verify

People use LLMs because they want to reach above what would normally be available to them. That means more output, but it should also mean better capability; better quality outputs. If responses are unreadable, or it’s not practical to attend to all points, then outputs are probably worse.

Ideally, we wouldn’t have to read the code, but I would prefer not having to read the responses. I’m not entirely sure how feasible it is to move from:

think, prompt, (observe steps, steer), read response, repeat

to:

think, prompt, (observe effects), ack status, repeat

for anything non-trivial. However, the things we would do to make that acceptable are probably things we should be doing anyway: guarantees.

If I think I know what I want, then to get it done without reading agent responses at all, I’m going to need guarantees. We have many options in our arsenal. Workflows are the obvious starting point, and Pi offers a clean foundation for that (see Flue). Lean is increasingly popular. Contracts like LemmaScript are also very promising.

I plan to not to waste my time reading agent responses until the writing problem is addressed; better to put energy into autoplan, autoimplement, etc., and ensure they contain solid guarantees for contract adherence and quality.