The new model made my own outputs harder to read, and it took me a few days to understand that this was the best thing it had done to me. I'd ask it to review something and it would come back with three recommendations, and I'd look at the first one and think: what is it even saying? Not because it was badly written. Because it was dense — a complicated point compressed into a short run of words — and I had to stop and spin my own cogs harder to unpack it. Sometimes I just typed back, explain number one to me. I don't get it. I have never had to do that before, in any model, in two years of using them to write and to code.

"What the hell is it even saying? Just explain number one to me." That reaction is not a bug report. It's the texture of studying under someone better than you.

Here's the claim I want to defend, because it sounds like hype and isn't: you'd assume a frontier release upgrades the software, and maybe the writing. I think it directly upgraded my brain. You wouldn't expect that to be possible — that a model someone ships can measurably change the person using it. It is possible, there's a name for the mechanism, and it comes with a warning label most people are reading upside down.

Three upgrades, and the two everyone measures

A frontier release upgrades three things at once. The first is the software — the model itself, which is what the benchmarks measure, and 2025–2026 has been a run of them clearing bars that stood for years.¹ The second is the artifacts — the code it writes, the prose it drafts, the outputs you keep. Everyone measures those two, obsessively, because they're visible and they sit still long enough to score.

The third upgrade is the user. For anyone standing in the right posture, a denser model raises the level they operate at — through the very properties that make it harder to skim.

There is no eval for "the reader is now smarter than they were on Tuesday." Which is why the tell for the third upgrade is friction, and why almost everyone misreads it. Two years of models writing below my level trained me to skim — and the skim never taught me anything. A model that finally writes at or above my level breaks the skim reflex and forces the re-read. It feels like the product got worse. It's the product finally getting good enough to teach.

Why does harder-to-read mean better-for-me?

Learning science has a name for effort that feels like an obstacle and is actually the mechanism: desirable difficulty. Robert and Elizabeth Bjork spent decades showing that comprehension which costs effort encodes far more durably than comprehension that comes easy. Their own framing is that good learning means making things hard on yourself, "but in a good way."² The label is deliberate: they're desirable because they enhance long-term retention and transfer; they're difficulties because, as Bjork puts it, they "slow down the rate your own performance is improving."³

That last point is the one that dissolves my confusion about the model. Bjork and Soderstrom draw the distinction that anchors the whole field: performance and learning are not the same thing. Performance is what you can do during instruction; learning is the durable change that persists and transfers — and "the problem is that performance is visible and learning is not."⁴

A model that writes below you optimises your performance in the moment: everything reads smoothly, nothing snags, you feel fast. It teaches you nothing, precisely because nothing was hard. A model that writes just above you tanks your in-the-moment fluency — you re-read, you look things up, you feel slow — and that discomfort is the learning happening where you can't see it.

The reason this works is even older. Vygotsky called the sweet spot the zone of proximal development: the gap between what you can do alone and what you can do "under adult guidance or in collaboration with more capable peers."⁵ You grow when you work just past your unaided ceiling, in the company of something more capable than you. His sharper line: "the only 'good learning' is that which is in advance of development."⁶

Hold those two ideas next to what actually shipped. A great mentor, a formidable colleague — a few hours a month, if you were lucky and well-connected. That's the resource the release just made subscribable. "What the hell is it even saying — explain number one to me" is not a UX failure. It is the exact texture of studying under someone better than you. The re-read is where the growth is.

The model raised its level, and I'm reporting muscle soreness. That's not a side effect. For the right posture, that's the product.

Vocabulary is compression, and it raises your ceiling

The least mystical part of this — and maybe the deepest — is the vocabulary. Every term the model has made me chase down this week, I've watched myself re-deploy correctly within hours. That's not confusion resolving; that's acquisition. And each acquired term is a compression handle: a word that packages a whole structure so you can manipulate it as a single unit.

Cognitive science has measured this since the 1950s. George Miller found that working memory is limited not in raw information but in chunks — and a chunk is "the largest meaningful unit in the presented material that the person recognizes."⁷ Chase and Simon then showed the difference between a novice and an expert is largely that the expert holds bigger chunks: a chess master glances at a board and stores whole configurations where a beginner sees individual pieces.⁸

A named concept is a bigger chunk. Once "zone of proximal development" is one handle in your head, it costs one slot instead of a paragraph — so a denser lexicon literally raises the effective capacity of your own working memory. The partner introduces the handle, you verify it externally, and a structure that used to cost you a paragraph now costs a token. That is the machinery of getting smarter, running in plain sight, one verified word at a time.

Same model, opposite gradients

Now the warning label, because the dominant story about AI and your brain runs the other way — and it isn't wrong, it's half the picture. The standing fear is that AI flattens its users: cognitive offloading, the calculator effect, everyone's thinking regressing to the model's mean. That fear has real evidence. Sparrow, Liu and Wegner named the Google effect back in 2011: when we expect future access to information, "we have lower rates of recall of the information itself and enhanced recall instead for where to access it."⁹

The AI-specific version has arrived, and it's pointed. A 2025 study in Societies found that cognitive offloading "significantly mediates the relationship between AI usage and critical thinking," with one participant putting the fear in plain words: "The more I use AI, the less I feel the need to problem-solve on my own. It's like I'm losing my ability to think critically."¹⁰ A larger study from Microsoft Research and Carnegie Mellon, presented at CHI 2025, found the crucial fork: "higher confidence in GenAI is associated with less critical thinking, while higher self-confidence is associated with more critical thinking."¹¹

Read that fork carefully, because it is the whole game. The atrophy is real — but it's a posture, not a property of the technology. Delegate your thinking and you atrophy; spar with something above your weight and you strengthen. Same model, opposite gradients.

The difference is entirely whether the human stays in the loop as a reader who has to keep up, or exits as a consumer who need not. The tool is identical. The gradient is opposite. Which gives the whole thing its rule: the anti-atrophy property is the human gate. The single most consequential lever on what AI does to your mind isn't the model — it's your posture toward it.

Not an exoskeleton — a training partner

I've written before about the cognitive exoskeleton — the idea that AI saturates the pre-work and side-work around a high-stakes human moment, so you arrive fully loaded rather than overwhelmed. The metaphor was deliberate: an exoskeleton amplifies the wearer; it does not replace them. I need to sharpen it, because on its own it undersells what just happened. An exoskeleton carries the load for you; your muscles idle inside it. Take it off and you're exactly as strong as before — not one rep stronger. If augmentation were only an exoskeleton, the atrophy crowd would be simply right.

What a denser model adds on top is closer to training with a stronger partner: resistance calibrated just past your current strength, and the adaptation happening in you. You don't just leave the session having lifted more this once. You leave it slightly stronger for every session after — including the ones without the partner. That's the difference between a machine that carries you and a machine that trains you, and it maps precisely onto the zone of proximal development: growth happens because the resistance sat just past your unaided ceiling.

This also amends an argument I made earlier, in a piece called The Boring Release Is the Revolution. There I argued that the release worth waiting for was never the frontier launch at all — it was the quiet collapse in the price of comprehension, a dividend that lands bottom-first on the reading, ingestion and artifact layers, while "a frontier improvement only sharpens the single terminal pass." I stand by the economics. But that framing measured the software and the artifacts and stopped there. It missed a third upgrade it structurally couldn't price — the one that happens outside the machine, days later, in the user. The frontier release didn't just sharpen the terminal pass. It sharpened the person holding it.

But the third upgrade doesn't fully land in the conversation. The conversation is where the insight is born — fast and fragile. It consolidates later, when you read the elaborated version back, days after the fact. That read-back is the human half of the loop, and it's where we go next.

There is a pile of thirteen articles on my desk, in a manner of speaking — drafted, indexed, published, and unread by me. Not a backlog. A different kind of debt. Because I know from experience what happens when I finally sit down with them: I read one through, slowly, and somewhere in the third paragraph I think, wow — that really was a good idea. Not "the model did a nice job." Something closer to surprise at my own thought, handed back to me better dressed than I left it.

For a long time I told myself that reading them was quality assurance — me checking the machine's homework before it went out under my name. I now think that story was wrong, and the way it's wrong is the whole point of this chapter.

The read-back was never really QA

Here's the honest observation that broke the QA story. I've rarely found real problems in the finished pieces, and the problems I do find keep getting smaller and rarer — because the models catch their own mistakes better every release. If the job of the read-back were catching errors, it would be a job with less and less to do, sliding toward pointless. And yet the reading feels more valuable over time, not less.

The resolution is that two different functions were riding in the same activity, and they're moving in opposite directions. The quality-assurance function is withering — the machine increasingly does it. The learning function is growing. Because there is exactly one thing the models still cannot do, no matter how good they get: consolidate the insight into my head. That part still requires me to read. Which means the read-back was never about finishing the machine's work. It was about finishing my own.

The models catch their own errors now. What they can't do is consolidate the insight into your head. That part still requires the reading — which means the read-back was never checking the machine's work. It was finishing yours.

One boundary before we build the mechanism, because it keeps this honest: the machine's self-checking guards completeness and process — did the steps happen, is anything missing. It does not guard taste, and taste is a different doctrine with its own treatment. This chapter is about neither error-catching nor taste. It's about the learning the reading deposits — and that turns out to have real cognitive science under it.

A personal pedagogy pipeline, in three stages

Watch what the whole loop actually does with an idea, from birth to keeping. It runs in three stages, and each maps cleanly onto something learning science already named.

Take them one at a time, because the mapping is exact.

The conversation is the encounter. It's fast and dialectical, and the ideas born in it are fragile — anyone who has had a brilliant thought in the shower and lost it by breakfast knows the failure mode. The insight is real; it just has no purchase yet.

The ebook is elaborated rehearsal. The machine takes the compressed insight and, in my own words from the conversation, "stretches it right out, puts a lot of detail behind it, explains why it's important, and then comes up with examples." That is not decoration. It is precisely the operation cognitive psychology calls deep, elaborative encoding. Craik and Lockhart's levels-of-processing framework established that memorability rises with the depth of processing: deep, semantic, associative engagement builds "a richer and more elaborate memory trace" that integrates with what you already know, where shallow processing does not.¹² Elaboration is the encoding. The machine does the elaboration; the trace it builds is in me.

The read-back days later is spaced repetition. The delay isn't a scheduling accident — it's the mechanism. The spacing effect, one of the oldest findings in experimental psychology, is that "repetitions spaced in time tend to produce stronger memories than repetitions massed closer together," a result that goes back to Ebbinghaus in 1885.¹³ And there's a sharper version still: reading your own elaborated argument back is closer to retrieval than re-study — you meet the idea again and reconstruct it — and retrieval practice beats re-reading for long-term retention, even though re-reading feels more productive in the moment.¹⁴ That fluency illusion is the same one from Chapter 1: what feels easy is rarely what's teaching you.

"But you outsourced the writing — isn't that outsourcing the thinking?"

This is the objection that should be levelled at the whole practice, and it deserves a straight answer rather than a dodge. The old warning is real and I believe it: writing is thinking, so never outsource the writing. If I'd handed the machine a topic and published whatever came back, the warning would land and I'd have earned the atrophy from Chapter 1.

But look at where the thinking actually happened. It happened in the conversation — the dialectic, the encounter, the place the insight was born. What got handed to the machine wasn't the thinking. It was the elaboration: the stretching, the detailing, the worked examples. And the learning was kept by keeping the read.

What I outsourced was the elaboration. I kept the learning by keeping the read.

Which is why the loop is a double-edged sword, and worth naming as one: you need the insight born in the conversation, then the stretch-and-detail, then the read-back. Remove any one stage and the loop breaks. Skip the conversation and you're publishing the model's ideas, not yours. Skip the elaboration and the fragile insight never gets encoded. Skip the read-back and you've written a book that teaches everyone except its author. The discipline isn't "do the writing yourself." It's "keep the two stages that are actually yours — the encounter and the read — and let the machine own the one in the middle."

Two memories, co-training on one artifact

Here's the part that makes the loop genuinely strange, in a good way. Every cycle deposits into two long-term memories at once. One is mine — the cortex, consolidating the insight on the read-back. The other is the canon — the compiled record of frameworks that boots every future model and feeds the wiki. Same artifact, two memories, co-training. As I put it at the time: it's enhancing my brain and the AI's brain at the same time.

This is where the canon earns a precise description rather than a vague one. It's what a prior framework, Worldview Recursive Compression, calls treating your accumulated knowledge as source code — "frameworks are source code; outputs are regenerable binaries; fix the source once, all future binaries improve." The wiki is the exocortex — the external, durable half. But the original cortex stays in the loop, and it's the one component that never resets. Models get swapped out release to release; the canon gets recompiled; the one continuous thread through all of it is the human who keeps reading.

One idea, traced through the whole loop

To make it concrete, follow a single insight through all three stages — using, fittingly, the one this book is built on. The encounter: mid-conversation, riffing about a new model, I said the thing I hadn't planned to say — that it wasn't just upgrading the software, it was upgrading me. Fast, fragile, easily lost. The elaborated rehearsal: the machine stretched that germ into Chapter 1 — desirable difficulty, the zone of proximal development, the posture fork, the exoskeleton correction, all the scaffolding the raw insight didn't have. The read-back: days later I read it, and the idea landed as something I now own rather than something I once said — a compression handle I can deploy without rebuilding it from scratch. The germ became a framework, and the framework became mine, precisely because I read it back.

The loop upgrades one person, one insight at a time. But nobody runs it alone in a vacuum — and two people running the same loop don't stay level. The gap between them compounds. That's the next chapter, and it's where the optimism gets complicated.

Take two people with the same subscription to the same model. Same price, same access, same everything the vendor can see. Chapter 1 gave us the fork that separates them — one spars, one delegates. This chapter is about what happens when you press play on that fork and let it run for three years. The answer is that they don't stay a fixed distance apart. The gap widens, and it widens faster the longer it runs, because the mechanism feeds itself.

The rich get richer — and reading research already proved it

The dynamic has a name, and it comes from the least glamorous corner of education research. The sociologist Robert Merton coined the Matthew effect in 1968 to describe how eminent scientists accrue ever more recognition while unknowns are overlooked — the rich get richer.¹⁵ Two decades later, the reading researcher Keith Stanovich borrowed it for something more intimate: how children learn to read.

Stanovich's finding is the one that matters here. Early readers acquire vocabulary faster; a bigger vocabulary makes reading easier; easier reading means you read more; reading more accelerates vocabulary acquisition. Round and round, compounding. In his own words, this "could mean that a 'rich-get-richer' or cumulative advantage phenomenon is almost inextricably embedded within the developmental course of reading progress."¹⁶ Crucially, this is compounding, not privilege — the advantage isn't handed down, it's generated by the loop.

Now run the same loop on augmented cognition. Comprehension capacity is the rate limiter on what you can absorb from the partner — you can only take from the model what you can understand. And absorption is exactly what raises comprehension capacity, one chased-down handle at a time (Chapter 1's chunking, now compounding). The person who joined the training loop in 2024 doesn't merely know more by 2027. They ingest faster — permanently. The reader who spars pulls away from the reader who delegates, and the distance between them accelerates.

The quiet inequality of this era isn't between who has AI and who doesn't. It's between who's being strengthened by it and who's being carried.

These are codebook tiers, not IQ tiers

Here is where the doomer reading of all this — a permanent cognitive aristocracy, the augmented pulling forever away from the rest — gets its correction, and the correction is the most important idea in the chapter. The tiers that open up are real. But they are not IQ tiers. They are codebook tiers — and codebooks are learnable.

Start with what a shared reference actually is. When two people both hold the same concept, its name is a compression codebook: the whole structure travels in a single token. When they don't, every idea has to be transmitted longhand. The cost of communication is what the rationalist writer Eliezer Yudkowsky calls inferential distance — the number of steps between what your listener already knows and what you're trying to convey; failures of explanation are almost always someone assuming a shorter distance than the real one.¹⁷ Every shared name shortens that distance by one step. Every unshared one lengthens it.

That is the entire "two-tier" phenomenon, demystified. The newcomer who finds the model incomprehensible and demands it be dumbed down isn't facing a machine that's smarter than they can bear. They're facing a dialect they haven't compiled yet. The dumbing-down tax is codebook mismatch, nothing more mysterious. And mismatch is fixable, because — unlike IQ — a codebook can be learned. That's the optimistic clause the doomers miss: the same machine that outruns you can teach you, one verified term at a time, exactly as it's been doing all along.

Your canon is a private compression dialect

This reframes what a personal canon even is. It's not just a memory of what you've figured out. It's a private compression dialect, co-developed between you and the machine — and the record of every place your comprehension boundary has moved. This very conversation was dense precisely because two parties were speaking that dialect: Lane Doctrine, janitor, scout, boot profile — handles minted or loaded together, each one collapsing a chapter of prior reasoning into a word.

That's also why the handles are named the way they are. Deliberately odd compound phrases aren't branding — they're retrieval anchors, doing three jobs at once: a memory handle for the human, a retrieval anchor for the machine, and a compression token for a whole framework. Every entry in the codebook is one you and the model can both expand on demand — which is exactly the property Chapter 4 turns into an interface rule.

And it reprices the flywheel from Chapter 2. That loop was never only compounding your knowledge. It was compounding your bandwidth — the rate at which you can take in the next dense thing. The canon is the ledger of that widening. Which is why the divergence compounds: bandwidth begets bandwidth, and the person building the dialect early is buying compounding interest on comprehension itself. (It's the same reason a lone operator with a rich private codebook can out-iterate a far larger group that has to communicate in longhand — the Team of One dynamic, pointed at cognition rather than output.)

The flywheel was never just compounding your knowledge. It was compounding your bandwidth.

One boundary, to keep this chapter in its lane: Chapter 1 owns the individual mechanism — how the friction upgrades one person. This chapter owns the between-people dynamics — how that upgrade, run across a population and a few years, sorts people into codebook tiers. Same engine, different altitude.

Which sets up the design question the whole book has been circling. If codebooks are learnable and the tax is mismatch, then the worst thing an interface can do is "help" by sawing the top off the answer. The right move isn't to lower the ceiling. It's to provide the ladder — and that's the next chapter.

Push the story from the first three chapters a couple of years out. Each release is denser than the last (Chapter 1). The gap between the reader who spars and the reader who delegates has widened into codebook tiers (Chapter 3). And now the interface designers face an obvious-looking problem: the model's answers are, for a growing share of users, too dense to parse. The obvious-looking solution is the one I most want to warn against. It's the future I don't want: "you didn't talk to a human, you'd better dumb it down."

Why "dumb it down" is the wrong interface

Dumbing down feels helpful and is quietly destructive, for a reason worth stating precisely. A dense answer is a tall ladder of meaning — many rungs, from the one-line verdict up to the fully-loaded original. "Dumb it down" picks one low rung and discards all the rest. And because compression back to simplicity is lossy, you can't reconstruct the original from the simplified version — the intent and the complexity that lived in the upper rungs are gone, not hidden. You didn't lower the reader gently onto a rung they could reach. You sawed the top off the ladder so no one could climb past where you stopped.

There's a subtle trap underneath, too. The author of a dense answer — human or model — can't feel what's missing for the reader, because of what Yudkowsky calls the illusion of transparency: "we always know what we mean by our words, and so we expect others to know it too."¹⁸ The dense answer reads perfectly to the one who wrote it. Which means you can't fix density by asking the author to self-assess it. You fix it by giving the reader the controls.

The right interface: progressive resolution of the answer

The move is one I've already built for everything else, just never pointed at the response itself: progressive resolution. Don't ship one flattened answer. Ship the dense answer as the canonical artifact, and let expansions materialise on demand. The reader climbs as far as their codebook reaches — and the top rung never gets sawn off to spare anyone's feelings.

You've already seen the manual version of this. In Chapter 1, when I typed "explain number one to me," I was doing it by hand — invoking, in effect, get_skeleton on a single paragraph, asking the machine to expand exactly one rung for exactly one reader. A real interface just makes that a control instead of a plea: the same answer, offered at several densities, with the reader choosing the depth.

Don't lower the ceiling. Provide the ladder. The model's density can rise with every release, and the human interface problem stays solved by the same architecture that solved retrieval, ingestion, and trust.

The line to hold: the learnable-codebook rule

All of this needs one governing boundary, or "as dense as you like" becomes a licence for gibberish. The boundary is not English, and it's not a reading level. It's the learnable-codebook property.

Consider a mathematics paper. It is technically English, and it is denser than any model output you'll ever read — a single line can carry a semester. Yet it stays entirely legitimate, because every symbol is defined somewhere reachable: you can always decompress. Density inside a language, with receipts, is fine at any level. What's illegitimate is opaque density — density you can't unpack, where a handle points to nothing you can reach. Opaque density is where audit dies. So the rule, stated once and applied everywhere:

Notice this also resolves the honesty caveat from Chapter 1. Desirable difficulty only works if the learner has the background to engage it; without it, the Bjorks warn, desirable difficulties "become undesirable difficulties."¹⁹ The ladder is precisely what keeps the difficulty desirable: it supplies the missing rung so the stretch stays inside the zone of proximal development instead of falling past it into noise. The ceiling stays high and the difficulty stays productive — the two together are the whole design. You don't choose between an honest ceiling and an accessible floor. The ladder gives you both.

The same rule holds for agents, not just prose

One extension, because the tension is coming and the architecture already answers it. Agent-to-agent dialects denser than English are almost certainly on the way — latent-space reasoning and emergent shorthands are already in the research — and they collide head-on with the shared-fabric doctrine, where governance rests on humans and machines reading the same representation. The resolution is the same rule, one layer up: the line to hold isn't English, it's expansion-on-demand. Agents may speak as densely as they like to each other, provided every handle can be decompressed into the shared, auditable representation when a human — or another system — needs to check it. English was never the boundary; the worry that it's some final wall dissolves the moment you see the real boundary is decompressibility. As dense as you like, provided every handle expands on demand — for agents exactly as for prose.

One more surface for an architecture you already have

None of this is a new machine. It's the architecture that already solved retrieval, ingestion and trust, pointed at one more surface: resolution chosen at read time, per reader. Two prior frameworks bracket it. The Blur Is Load-Bearing laddered the corpus — hold the whole library at its lowest useful resolution and descend, per question, only as far as the answer warrants. That laddered the read side, the corpus you consume. This chapter ladders the response — the answer you produce — which is the new surface, the same ladder run in the opposite direction. And Progressive Resolution laddered generation itself: coarse to fine, stabilising each layer before adding detail, regenerating rather than patching. Here that same coarse-to-fine logic, plus expand-on-demand, is applied to the finished answer as the reader meets it.

The ladder keeps the difficulty desirable and the codebook learnable — which means the whole argument of this book stops being something to admire and becomes something to operate. The last chapter turns it into a checklist.

A model release doesn't upgrade you. It offers to. Whether you collect the offer is posture, and posture isn't a personality trait — it's a set of habits you can run deliberately. So here are the three, distilled from the four chapters behind them and pointed at what you actually do on a Tuesday. Read them as tools, not arguments; the arguments are done.

Tool 1 — The posture audit

The fork from Chapter 1 is only useful if you can tell which side of it you're on. So audit a working session after the fact with four questions. They take about ten seconds and they're uncomfortably diagnostic.

If every session lives in the right-hand column, you have the subscription and none of the upgrade — the atrophy gradient the offloading research describes, running on you (Chapter 1). The point of the audit isn't guilt; it's that the fork is a dial you can turn, and you can only turn it if you can read it.

Tool 2 — The tier-onboarding path

Chapter 3 promised codebooks are learnable. This is how you climb one, deliberately, when the model is speaking a dialect above yours. Four moves, in order:

Run those four and you are paying down the dumbing-down tax the way it's meant to be paid: one verified term at a time. The tax was codebook mismatch (Chapter 3); this is the exit.

Tool 3 — The density audit

Chapter 4's rule, made portable for anything you ship — a document, a model answer, an agent's output. Before it leaves your hands, ask one question:

Can the reader reach the definition of every compressed term from where they stand? If yes, the density is legitimate. If no, it's opaque — and opaque density is where audit dies.

If it passes, ship it dense; you're a mathematics paper, and that's fine. If it fails, don't lower the ceiling — add the rung. The one-line governance form: publish at full resolution, ship the ladder with it. It applies to your prose today and your agents tomorrow, unchanged.

The whole thing, in one paragraph

A frontier release upgrades three things; the third is you. It arrives as friction — desirable difficulty, the scarcest resource on earth finally subscribable. It consolidates on the read-back, the human half of a loop that teaches you your own idea. It compounds by posture into codebook tiers that are learnable, not fixed. And it's served by an interface that provides the ladder instead of lowering the ceiling. Posture is the gate. Posture is learnable. The ladder holds the line.