In the 1940s, the Dutch psychologist Adriaan de Groot showed chess players a position for a few seconds, removed it, and asked them to rebuild it.1 Masters reconstructed nearly the whole board. Ordinary players got a fragment. The easy explanation — masters have better memories — is wrong, and the experiment that proved it wrong is the one worth keeping.
Twenty years on, William Chase and Herbert Simon ran the control.2 Same exposure, same task, but the pieces were scrambled into arrangements no real game could produce. The masters' advantage fell off a cliff. Take the structure out of the board, and the grandmaster recalls about what the novice does — four or five pieces, then nothing.
Note
Later replications found masters kept a slight edge even on random boards; the shape of the result survived.3 Remove the meaning, remove the gap.
The master had never been memorizing twenty-five pieces. He was recognizing four or five configurations he'd seen ten thousand times — a castled king, a pawn chain, a familiar tactical shape — and storing those. Chunks, Chase and Simon called them. The expert had compressed the board before he tried to remember it.
Say it plainly, because everything downstream depends on it: expertise is not more memory or faster calculation. It is a better representation.
The master doesn't see more of the board. He sees less of it — because he has already turned it into meaning.
The board is now a model
I spent years building code generators off database schemas. Point them at a set of tables, and they'd emit the entities, the relationships, the persistence layer, the services, the interfaces. People sometimes read that as automating typing. It wasn't. Before I could automate any of it, I had to see that
schema → entities → relationships → persistence → services → interfaces
was one repeated shape. Once you see the shape, hand-writing each class is absurd — you're already standing a layer above the code. The generator was just the compression made mechanical.
An AI model is that, turned up until the mechanism disappears. And it splits people into two motions that look identical on the surface and are opposite underneath.
The practitioner who already holds the patterns runs:
problem → recognize the shape → build a model of it
→ have the AI instantiate and explore it → read the output
→ catch the violations → redirect.
The AI is leverage. It moves them through the solution space faster than they could move alone.
The practitioner who doesn't runs:
problem → ask → receive something plausible → keep or tweak it → move on.
The artifact can be the same. The cognition is the reverse. The first person is steering the model. The second is being steered by it.
"The wrong shape"
Hand an experienced developer five hundred lines of generated code, and they don't read five hundred lines. They see repository pattern, an allocation that shouldn't be there, a race condition, a leak in the abstraction, a service quietly doing three jobs, a state transition that ought to be impossible. The volume doesn't overwhelm them because they compressed the domain long before the code arrived.
Give the same five hundred lines to a beginner, and they get the random board. Every line carries roughly equal weight. Nothing has shape. There is nothing to compress toward, so there is nothing to be suspicious of.
This is why expert prompting is misunderstood. The expert usually doesn't have a magically better prompt. They recognize when the answer is the wrong shape. The novice asks does this work. The expert asks why are we doing it this way at all — this solves the local problem and violates the architecture — you're tuning the implementation when the bottleneck is the data model. That is steering, and steering requires a model outside the model.
You cannot correct a system you cannot represent.
AI raises the return on prior expertise
The reigning story is that AI democratizes expertise: everyone gets the same intelligence on tap, so the field levels. The premise is true, and the conclusion doesn't follow. Access to the same model is not access to the same capability. The model supplies the pieces. Someone still has to recognize the board.
So the scarce asset isn't access. It's pattern capital — the internal library of structures, failure modes, causal chains, and analogies that lets a person collapse a messy situation into something they can hold and manipulate. Two people query the identical model and get unequal value out of it, and the gap between them tracks what they brought, not what the model gave.
AI doesn't flatten the expertise curve. It steepens it.
The apprenticeship was the friction
Here is the part that deserves real attention, and it isn't a coding story.
Important
If you build the patterns first and get AI second, it strips away mechanical work and leaves the higher-order judgment intact — often amplified. That's the happy case, and it's the one every current senior is living in. We are borrowing against schemas we already paid for.
Reverse the order and the trade changes.
If AI arrives before the patterns exist, it can remove the very experiences the patterns would have formed from. The old sequence was attempt → failure → diagnosis → correction → abstraction → pattern. The friction in the middle wasn't waste. It was training data for the human. Debugging the race condition is how you learn concurrency. Writing the ugly data layer is how you learn why abstractions exist. Shipping three bad APIs is how you come to recognize a good one. Maintaining the thing you built five years ago is how architectural consequence stops being a word and becomes a scar.
Replace that sequence with request → solution, and you get someone who is enormously productive and not proportionally more capable. The output goes up. The rate at which expertise forms goes down.
Warning
It is entirely possible — I'd say likely — to raise measured productivity while quietly lowering the rate at which the next generation of judgment is manufactured.
Where this actually lands
Watch what's happening to junior hiring, and you can see the two arguments meet. The junior developer, the first-year analyst, the associate — those roles were never only labor. They were the apprenticeship. They were the random-board years, the ones where you accumulate the chunks by grinding through positions that mean nothing to you yet.
Automate that tier away, and you haven't just cut a cost line. You've closed the pipe that produces the people who can steer.
Today's seniors were forged by friction that tomorrow's juniors won't be allowed to touch, because the AI will touch it first and touch it faster. The compression advantage is real, and for anyone who already holds the patterns, it is the best tool they'll ever be handed. The open question is where the next people who hold the patterns are supposed to come from, once the experiences that build them have been optimized out of existence.
The chess study wasn't about memory. It was about the moment the structure disappears, and everyone is a beginner again.
The thing worth watching isn't whether AI removes execution. It's whether it removes the mechanism by which humans acquire abstraction in the first place — and whether we notice before the board goes random on us.