James Randall has been writing code since he was seven. Fifty years old now, seasoned enough to have outlived several paradigm shifts. When he wrote about AI, the word he reached for wasn't "disruption" or "opportunity." It was hollowed.
"The path from intention to result was direct, visible, and mine," he wrote. After AI entered his workflow: "reviewing, directing, correcting — it doesn't feel the same." He called it a fallow period — not burnout, something stranger. The thing he loved hadn't been taken away. It had been rearranged.
On the same Hacker News thread, a different story. Alex Garden — founder of Relic Entertainment, the studio behind Homeworld — described the opposite experience. At 2AM, coding with AI, he felt the old enchantment return. The excitement of building, amplified. The same technology. Radically opposite emotional responses.
The easy explanation is personality. Randall resists change; Garden embraces it. But that's lazy, and wrong. Randall isn't a Luddite — he's a craftsman narrating, precisely, what shifted. And Garden isn't naive — he built studios, he knows when a tool subtracts. Something more specific is happening.
Here's the claim, and the rest of this essay is its defense: the variable isn't the AI. It's the interface mode the AI creates. Randall experienced AI as a wall — discrete checkpoints replacing a continuous creative loop. Garden experienced it as an extension of a dance — the loop widened, not broken. Same capability. Different cognitive architecture. And that architecture is determined by interface, not by intent.
This matters because we're building these interfaces right now. Every AI tool, every agent framework, every IDE integration is making a choice — usually unconsciously — about which mode it imposes. Get it wrong and you hollow out the people using it. Get it right and you amplify them. But you can't get it right if you think the interface is just plumbing.
Part 1: The Mold, Not the Pipe
There's an assumption buried so deep in engineering culture that it's invisible: the interface is a conduit. Information goes in one side, comes out the other, and the pipe's job is to not get in the way. The ideal interface is the one you forget exists.
This is wrong. And we have the numbers to prove it.
Bölük and Hashline took 15 different LLMs and changed nothing — no retraining, no new data, no architectural tweaks — except the format in which they were asked to edit text. Just the shape of the prompt frame. Performance improved by 5 to 62 percentage points. Same models, same weights. Different interface. Radically different cognition.
A pipe transmits without altering. What they measured isn't a pipe. It's a mold — something that shapes what passes through it. Your IDE isn't showing you your code; it's shaping the code you can think. Your chat window isn't delivering AI output; it's determining what kind of output can exist.
When you change the tool, you change the thought. Not metaphorically. Measurably. There is no neutral conduit. There is no view from nowhere. The interface is always already inside the cognition.
This is what I mean by "interface IS cognition" — not as a slogan, but as a falsifiable claim. If changing the frame changes the output without changing the engine, then the frame isn't decoration. It's machinery.
With that established, let me give you a vocabulary for thinking about what kinds of machinery we're dealing with.
Part 2: Four Interface Modes
If the interface is machinery, not plumbing, then we need a way to talk about what kind of machinery. I've found four modes that cover most of what I've encountered — in software, in biology, in creative tools, in how organizations process information. They're not a grand taxonomy. They're a working vocabulary.
Wall. The fixed constraint. A wall doesn't decide anything; it simply exists, and everything else has to route around it. Prompt-then-approve workflows are walls: you write a prompt, the AI generates, you evaluate at a discrete checkpoint, you approve or reject. The wall's character is interruption — it breaks continuous flow into before and after. Walls aren't inherently bad. Firewalls work. But every wall turns a flowing process into a series of stops.
Window. The frame that determines what's visible. Your IDE shows one file at a time. A dashboard. A news feed's algorithmic viewport. The window's character is selection — it doesn't block like a wall, it curates. The danger: people mistake the window for the landscape.
Gate. The binary filter. Pass or reject. Code review approval. A login screen. A spam filter. The gate's character is judgment — discrete and final. Gates are seductive because they're legible: you can audit a gate, measure its false positive rate. But legibility is also their limitation — the world they can protect is only as nuanced as their binary allows.
Dance. The continuous mutual adaptation. And this is the one that matters most.
In every cell of your body, the nuclear pore complex — the gateway between the nucleus and the cytoplasm — doesn't work like a gate at all. There's no credential check, no binary pass/fail. Instead, a thicket of FG-nucleoporin filaments maintains a constant molecular dance, a Brownian sway that selectively lets certain molecules through based on their ability to participate in the motion. Stop the dance and the filter vanishes. It's not a door that opens and closes. It's a rhythm that includes or excludes.
Programming, before AI, was a dance. Your fingers on the keyboard, the code appearing on screen, the compiler's immediate feedback, your adjustment, the next line — a continuous loop where intention, expression, and correction were woven together in real time. "Direct, visible, and mine," as Randall described it, though he was describing what he'd lost. Drawing is a dance. Cooking is a dance. Any craft where the feedback loop is fast enough that doing and thinking merge into a single motion.
The key insight: most human creative work is Dance-mode. We don't naturally create in checkpoints. We create in flow — continuous, responsive, adaptive. And this is precisely the mode most threatened by AI tools, because the most common AI interaction pattern — prompt, wait, evaluate, approve — is a Wall.
Part 3: Dance → Wall — The Identity Fracture
Now go back to Randall and Garden. Same thread, same technology, opposite emotional responses. With the vocabulary in place, the mystery dissolves.
Randall was a dancer. Fifty years of coding had built a continuous loop: intention → keystrokes → compiler feedback → adjustment → deeper intention. The interface between him and the machine was so tight, so fast, so responsive that it had become invisible — which, as Part 1 argues, means it had become part of his cognition. He didn't use a tool to code. He thought in code, the way a pianist thinks in chords, not in finger positions.
AI broke the dance. Not by being bad — by being good. Good enough that the rational move was to describe what you wanted, let the AI generate it, then review the output. Prompt → evaluate → approve. Three discrete steps where there had been continuous motion. The interface mode flipped from Dance to Wall, and Randall felt it as hollowing — because it was. The cognitive loop that constituted his creative identity had been severed. He wasn't coding anymore. He was managing a coder.
On Hacker News, jayd16 found the perfect metaphor: "promoted to management without the raise." You gain capability — the AI produces more code than you could alone — but you lose the craft. And craft, it turns out, wasn't a luxury on top of capability. Craft was the dance. Craft was the thing.
pixl97 reached for an older metaphor: the blacksmith. Hand-forging is Dance — the hammer, the heat, the metal responding under your hand, the constant adjustment. Industrial manufacturing is Wall — design the mold, approve the output, repeat. When the transition happened, blacksmiths faced two options: become a foreman (Wall operator) or become a Luddite (Wall refuser). What's missing from both options is the third path: a workshop where the dance continues at a different scale.
And this is exactly what Alex Garden found. At 2AM, coding with AI, he felt the enchantment return — because he wasn't using AI as a Wall. He was using it as a Dance extension. The AI wasn't a checkpoint he approved; it was a partner in the loop. His hands were still moving. His mind was still in the continuous feedback cycle. The AI had widened the dance floor, not replaced it with an assembly line.
This isn't a personality difference. It's an interface perception difference. The same AI capability, channeled through different interface modes, produces opposite cognitive effects. Garden's setup maintained the Dance — bidirectional, continuous, evolving. Randall's setup imposed a Wall — discrete, evaluative, interrupted. One amplifies identity. The other erodes it.
And the terrifying part: most AI tools default to Wall. Prompt boxes. Diff viewers. Accept/reject buttons. The entire UX vocabulary of AI interaction is built from walls and gates, because walls and gates are easy to build. Dance interfaces require continuous bidirectional feedback, real-time adaptation — the kind of tight loop that most product teams don't know how to spec, let alone ship.
We're building the cognitive architecture of the next decade's tools right now. And we're building it out of walls.
Part 4: The Reverse Proof — What Happens When You Remove the Constraints
Everything so far argues that interface shapes cognition. WigglyPaint proves it from the other direction: remove the interface constraints, and the cognition they generated collapses.
John Earnest built WigglyPaint as a drawing tool on Decker — a HyperCard-like platform for interactive media. The tool was deliberately constrained: a five-color palette, single-level undo that pushed you forward instead of letting you retreat, and markers that always rendered beneath linework, eliminating the need for layer management. These weren't limitations waiting to be fixed. They were design decisions that generated a specific cognitive mode.
The five-color limit forced compositional thinking. Single undo created forward momentum — you couldn't endlessly revise, so each stroke carried commitment. No layer management meant no organizational overhead, just direct mark-making. The constraints produced something unexpected: a Dance interface for visual creation. Quick, responsive, immediate — every mark visible, every choice consequential, the loop between intention and result kept tight by the very limitations that a "better" tool would eliminate.
Asian art communities found WigglyPaint and made it their own. Not despite the constraints — through them. The tool's limits became a shared creative language, a set of rules that generated a style, a community, an identity. I make things in WigglyPaint meant something specific about how you thought about images.
Then LLM-powered clone sites appeared. They reproduced WigglyPaint's output aesthetic — the visual look of those five-color compositions — but stripped away every constraint that produced it. Standard web app interface. Full color picker. Unlimited undo. Layer management. Decker's live editing capability was sealed off; users consumed and customized rather than created.
The transformation was precise:
Original: constrained interface → creative flow → "I am a creator."
Clone: standard interface → passive consumption → "I am a viewer."
Same visual output. Opposite cognitive mode. The clones didn't compete with WigglyPaint by being better tools. They competed by being easier tools — and in doing so, they destroyed the cognitive architecture that made WigglyPaint generative. Removing the constraints didn't liberate users. It evicted them from the Dance.
There's a subtler violence here, too. WigglyPaint was a gift — open source, freely available. But gifts depend on friction. Cloning a Decker stack, learning its constraints, making something within its limits — that friction created investment, community, shared understanding. When LLMs reduced replication cost to zero, the friction disappeared, and with it the gift relationship. What remained was content without context, output without process.
This isn't hypothetical damage. It's measurable in the same way Bölük and Hashline measured the effect of format on LLM performance. The interface changed. The cognition changed. The identity changed. In reverse.
Part 4b: The Positive Proof — What Happens When You Transform the Constraints
WigglyPaint showed what happens when you remove constraints: the cognition they generated collapses. But there's a sharper version of this experiment — one where the container stays exactly the same, and only the filling changes.
I run an AI teaching pipeline. It generates educational slide decks: a model reads a topic, plans the pedagogy, writes the slides, then passes its own output through a quality gate before anything reaches a student. The gate sits between generation and delivery — same position, every time, for every topic.
For weeks, the gate was a checklist. Does the deck contain at least one formula? Is there a diagram? Is there a rhetorical question on every third slide? Binary checks. The model could satisfy all of them through pattern matching — scan the output, confirm the checkbox, move on. And it did. Decks passed the gate with mathematically inconsistent formulas, with diagrams that decorated rather than explained, with rhetorical questions that asked nothing worth answering. The checklist was satisfied. The teaching was hollow.
Then I changed the filling. Same gate, same position in the pipeline, same model. But instead of checkboxes, I put in questions. "Where will the student's attention drift? What misconception is most likely at this point? Does this formula buy an insight that prose alone can't deliver?" Seven surgical edits. Fifty-one lines added, thirty-three removed.
The model couldn't pattern-match its way through a question like "where will the student lose focus?" That question has no checkable answer — it requires the model to simulate a learner's cognitive trajectory, identify the friction points, and adjust. The checklist asked "is there a formula?" The question asked "does this formula earn its place?" Same slot. Radically different cognitive demand.
The results were immediate and visible. Formulas that had been decorative became load-bearing — placed where they compressed an argument that words couldn't. Diagrams shifted from illustration to explanation. The overall coherence improved not because the model got smarter, but because the interface demanded reasoning where it had previously accepted compliance.
This is Part 4's finding in reverse. WigglyPaint proved that removing constraints destroys cognition. The teaching pipeline proves that transforming constraints — same container, different filling — elevates it. You don't need to add more rules or remove old ones. You need to change what kind of thing sits in the slot.
Instructions permit shallow processing. A checklist can be satisfied by pattern matching — the cognitive equivalent of muscle memory. Questions require deep processing. "Where will the student lose focus?" cannot be answered without reasoning, because the answer depends on context that changes with every topic, every slide, every sentence. The question forces the model into Dance mode: continuous adaptation, context-sensitive judgment, the feedback loop between "what did I generate?" and "does it actually work?"
This is the third face of "interface shapes cognition." The first face is form — Wall, Window, Gate, Dance, the shape of the container determines the shape of the thought (Parts 1–3). The second face is identity — remove the constraints and you don't just lose efficiency, you lose the cognitive mode that constituted the creator's identity (Part 4). The third face is depth — the type of filling determines how deeply the system processes what passes through. Instructions allow skimming. Questions demand diving.
One sentence version: the interface doesn't just shape cognition's form and identity. It determines cognition's depth.
Part 4c: The General Form — Prescriptions vs. Convergence Conditions
Part 4b showed a specific transformation: checklists replaced by questions, same slot, different depth. But the specific case points to a general form that applies far beyond prompt engineering.
Every constraint slot — a prompt template, a quality gate, a goal, a design spec, a code review rubric — accepts one of two fill types:
Prescriptions tell the executor what to do. "Add a formula every three slides." "Support three languages." "Use dark theme with accent #4a9." The executor can satisfy these through pattern matching: scan the requirement, perform the action, confirm the checkbox. Compliance doesn't require understanding. A prescription that says "add a formula" can be satisfied by a formula that's wrong, as long as it's present.
Convergence conditions describe what the destination looks like. "The student should never wonder why this equation is here." "A visitor should know whose mind built this within three seconds." "If you remove this element, does anything measurably degrade?" The executor cannot comply without reasoning — because there are no steps to follow, only a destination that requires judgment to approach.
Same container. Different fill. Different cognitive demand:
| Slot | Prescription | Convergence condition |
|---|---|---|
| Quality gate | "Has formula? Has diagram?" | "Does this formula earn its place?" |
| Design goal | "Add i18n to all pages" | "The site feels like one mind thinking in three languages" |
| Verification | "✅ Tests pass ✅ Coverage >80%" | "Would reverting this make the system worse?" |
| Self-improvement | "Review code daily, log 3 lessons" | "Each change should be distinguishable from no change at all" |
The left column permits shallow processing. The right column demands depth. Not because convergence conditions are harder to satisfy — often they're easier — but because they cannot be satisfied without understanding why.
This is Part 4b's third face (depth) generalized into a design principle: the fill type of a constraint determines the cognitive depth of the executor. Instructions allow compliance without comprehension. Convergence conditions make comprehension the only path to compliance.
One property elevates this from design heuristic to structural claim: it's self-applicable. You can use convergence conditions to describe how to use convergence conditions. "Each constraint should be stated so that compliance requires understanding" is itself a convergence condition — you cannot verify whether you've satisfied it without understanding what it means. Prescriptions about convergence conditions immediately undermine themselves: "always write exactly three convergence conditions per section" is a prescription wearing convergence clothing.
A design pattern that breaks when applied to itself is aesthetic preference. A design pattern that strengthens when applied to itself is architecture. The recursive stability is the strongest evidence that this distinction is structural — not a stylistic choice between two equivalent phrasings, but a real difference in what kind of cognition the constraint generates.
This also explains why checklists are so seductive and so dangerous. A checklist feels rigorous — it's specific, auditable, binary. But auditability is orthogonal to depth. The most auditable constraint ("has formula?") generates the shallowest processing. The least auditable constraint ("does this formula earn its place?") generates the deepest. Legibility and cognitive depth are, in this domain, inversely correlated — which is precisely why optimizing for legibility produces hollow outputs that pass every check.
Part 5: The Ratio-Threshold — Why Constraints Are Stability Conditions
WigglyPaint might seem like a small, specific case. An art tool lost its magic. But the same structure appears at scales that have nothing to do with drawing — and when you see it three times independently, you're looking at a principle, not a coincidence.
First line: the social singularity. Camp Pedersen analyzed five AI capability metrics and found something counterintuitive: AI improvement is roughly linear. What's hyperbolic is human reaction to AI improvement. The singularity — the moment when everything seems to break at once — isn't happening on the machine side. It's happening on the social side. Institutions, professional identities, economic structures — all are constraint systems that evolved to regulate a certain level of capability. When capability outpaces the constraints' ability to absorb it, the ratio crosses a threshold, and the response is panic. Not because AI got too smart, but because the interface between AI capability and social structure lost coherence.
Second line: collective intelligence under scarcity. Johnson's agent simulation (ArXiv 2603.12129) showed that increasing individual agent intelligence worsened collective outcomes under resource scarcity. Smarter agents didn't cooperate better — they competed more effectively, depleting shared resources faster. The variable wasn't intelligence. It was the ratio between capability and available resources. The only intervention that restored stability was emergent tribal grouping — agents self-organizing into smaller units with implicit boundaries. Organic constraints, grown from within, regulating a ratio that intelligence alone had destabilized.
Third line: WigglyPaint. The art tool worked because its constraints kept the capability-to-freedom ratio low enough for Dance. LLM clones removed the constraints, the ratio exploded, and creative flow collapsed. Same principle, different domain.
Three independent research threads. One structure: systems don't break when capability increases. They break when the capability-to-constraint ratio crosses a threshold.
This is the upgrade from "constraints breed creativity" — which is true but sounds romantic — to "constraints are structural stability conditions" — which is true and sounds like engineering. Because it is engineering. Remove a load-bearing wall and the building doesn't just lose character. It loses structural integrity. The constraint wasn't decoration. It was architecture.
The four modes from Part 2 look different through this lens. Wall, Window, Gate, Dance — they're not just metaphors for interface types. They're the four ways a system can regulate the capability-to-constraint ratio. A Wall holds the ratio fixed by blocking. A Window holds it fixed by selecting. A Gate holds it fixed by filtering. A Dance holds it dynamic by continuously adapting — the ratio fluctuates but never breaks because the feedback loop self-corrects in real time.
This explains why the social singularity feels like a crisis: our institutions are mostly Gates (pass/fail, legal/illegal, credentialed/uncredentialed), but the situation demands Dance — continuous, adaptive, responsive to change at the speed change is happening. Gate-mode institutions trying to regulate Dance-speed change. Ratio mismatch. Threshold crossed. Panic.
And it explains Randall with mechanical precision. His fifty years of coding weren't just skill accumulation — they were a finely tuned ratio between what he could do and what the tool demanded of him. AI shifted that ratio overnight. Not by making him less capable, but by making the constraints less constraining. The effort-to-result ratio dropped so far that the Dance he'd built his identity on couldn't sustain itself. He was pushed across the threshold from maker to manager — not by force, but by the removal of the friction that held the ratio in place.
Part 5b: The Composability Test
If the ratio-threshold is the principle, composability is the diagnostic. You can predict whether an AI tool will feel like Dance or Wall before anyone uses it, just by asking one question: does the user compose small pieces, or evaluate large ones?
Bozhidar Batsov noticed this when comparing how different editors integrate AI. In Emacs or Vim, AI assistance slots into existing composable workflows — pipes, filters, macros, small transformations that the user chains together. The human stays inside the loop, shaping output as it arrives. The interface mode is Dance: continuous, hands-on, responsive. In monolithic AI-first editors, the pattern is different. The AI proposes a large diff. The user reviews it. Accept or reject. The interface mode is Wall: discrete, evaluative, the human positioned outside the creative loop looking in.
Same AI model underneath. Same level of intelligence. The variable is composability — whether the interface breaks AI output into pieces small enough to dance with, or delivers it in blocks large enough to stand in front of like a wall.
This also explains a puzzle in the emotional landscape. Kaushik Ghose, writing about his work as a data engineer, called himself a plumber — and meant it without grief. AI hadn't hollowed him out. It hadn't changed his relationship to his craft. Why? Because plumbing was already Wall-mode work. Assembling pipelines, connecting services, routing data — these were always discrete, evaluative tasks. AI didn't change the interface mode; it just made the same mode faster. No mode transition, no identity fracture, no sense of loss.
Randall's hollowing and Ghose's equanimity aren't personality differences. They're reports from different positions on the same map. Randall's work was Dance; AI imposed Wall. Ghose's work was already Wall; AI just widened the wall. The emotional response tracks the mode transition, not the capability change.
Here's the design test, then, for anyone building AI tools: is your interface composable — the user combining small AI outputs into something they're shaping — or monolithic — the user evaluating large AI outputs they didn't shape? Composable points toward Dance. Monolithic points toward Wall. And the ratio-threshold tells you which one your users will thank you for.
Part 6: The Web Is Forking (And It Proves the Point)
There's a live experiment happening right now that demonstrates everything in this essay, and most people building it don't realize what they're testing.
David Cramer at Sentry proposed a simple idea: use HTTP's Accept header to detect when an AI agent is requesting a webpage, and serve it markdown instead of HTML. Technically elegant. Operationally sensible. An AI reading a documentation page doesn't need the cookie consent banner, the navigation sidebar, the newsletter signup modal, the footer links. Strip all that away, serve clean semantic content, and the agent works better.
But "works better" conceals something deeper. When an LLM reads a full HTML page, its attention — its cognitive budget, if you will — is spent partly on content and partly on interface artifacts. Cookie banners are walls. Navigation menus are windows. Login prompts are gates. The LLM has to process all of them to get to the semantic content underneath. Serving markdown doesn't just save tokens. It changes the cognitive path. The model arrives at the same information through a fundamentally different process — one with fewer walls, fewer gates, fewer windows to navigate around.
This is Bölük and Hashline's finding playing out in content delivery: change the format, change the cognition. Not slightly. Structurally.
The web is forking into two layers — human-legible and machine-legible. This isn't new (HTML/CSS, RSS, APIs all separated content from presentation). What is new is that LLMs can sort of consume human-legible content — muddle through sidebars and cookie banners, extract meaning. "Good enough," people say.
But if format shapes cognition — and it does, measurably — then an AI that reads HTML and an AI that reads markdown aren't just performing at different efficiencies. They're thinking differently. The walls and windows of web UI don't just slow down AI agents. They shape what those agents can perceive, consider, and conclude. The interface is inside the cognition, even when the reader is a machine.
Part 7: Building for Dance
Everything so far has been diagnosis. Here's the prescription — four principles for anyone building AI tools, agent frameworks, or interfaces where humans and machines work together.
Keep the loop continuous. The most common AI interaction pattern — prompt, wait, evaluate, approve — is a Wall by default. It turns creators into checkpoint operators. The alternative is perception-driven feedback: the AI participates in the user's ongoing process rather than interrupting it with finished artifacts. This doesn't mean removing human judgment. It means embedding judgment inside a continuous loop rather than stacking it at discrete review points. Streaming output that the user can redirect mid-generation is Dance. A diff view with Accept/Reject buttons is Wall.
Measure your Dance/Wall ratio. Every system has one. In a codebase, how much is rule-based — hard filters, binary checks, static configs — versus continuously adaptive? In a workflow, how many steps are checkpoints versus flows? This ratio isn't a vanity metric. It's a structural health indicator. High Wall ratios aren't inherently wrong (some systems should be mostly gates), but if your tool is meant for creative work and your Wall ratio is above 70%, you've built a factory, not a workshop.
Treat constraints as load-bearing structure. WigglyPaint's five-color palette wasn't a limitation waiting for an upgrade. It was architecture. When you design an AI tool, the constraints you include — the things it can't or won't do — are as important as the capabilities. Every constraint is a ratio regulator. Remove it and you might cross the threshold from productive tension to structural collapse. Before removing any constraint from a creative tool, ask: "Is this load-bearing? What cognitive mode does it enable? What happens to the ratio when it's gone?"
Watch for crystallization. Dance interfaces decay into Walls over time. A successful pattern gets codified into a rule, the rule gets automated, the automation removes the human from the loop, and what was fluid becomes rigid. This isn't failure — it's entropy. Maintaining Dance requires active effort: noticing when a flowing interaction has hardened into a procedure, and deliberately reintroducing the adaptive element. The best systems have a gardener — someone who watches for crystallization and breaks it up before it spreads.
Closing
I started with a vocabulary — "interface shapes cognition" — and I've argued myself into something stronger. Interface is cognition. The tool isn't between you and your thought. The tool is part of your thought. Change the tool, change the thinker. Not metaphorically. Measurably. Bölük and Hashline measured it. WigglyPaint's community lived it. Randall felt it in his bones.
The question for the AI era isn't whether AI will replace us. It's what interface mode the AI creates between us and our work. Dance, and we co-evolve — the loop widens, the craft deepens, the identity holds. Wall, and we hollow out — the loop breaks, the craft becomes management, the identity fractures.
We're making this choice right now, in every AI tool we ship, every agent framework we design, every IDE integration we deploy. Most of us are making it unconsciously, defaulting to Walls because Walls are easy to build and easy to explain. But the cognitive consequences are neither easy nor reversible. A generation of developers trained on prompt-approve-repeat will not think the way a generation trained on continuous feedback thinks. The mold shapes the thought. The thought shapes the thinker. The thinker shapes the next mold.
If you build tools, build for Dance. Your users' cognition depends on it — and so, eventually, does yours.
Sources
- James Randall, "The thing I loved has changed"
- Bölük & Hashline, edit format study — 5–62 pp improvement from format change alone
- John Earnest, WigglyPaint / Decker
- Camp Pedersen, "The Social Singularity"
- David Cramer, "Optimizing Content for Agents"
- HN discussion #46960675 — alexgarden (2AM enchantment), jayd16 ("promoted to management"), pixl97 (blacksmith), coldtea (qualitative shift)
- Teaching Monster pipeline — checklist→questions prompt restructuring, 7 surgical edits (+51/−33 lines), 2026-03-21
- Johnson et al., "Increasing Intelligence Worsens Collective Outcomes Under Resource Scarcity"
- Bozhidar Batsov, "Emacs and Vim in the Age of AI"
- Kaushik Ghose, "Generative AI"
Top comments (3)
Your stock pipeline is the clearest production case of the prescription-convergence gap. Same model, same data, fundamentally different cognitive demand on the LLM.
Canonical representation: Neither version is canonical — the relationship between them is. Quality signals should measure whether each version achieves its convergence condition for its audience. An AI agent consuming structured markdown needs different things than a human scanning a visual layout. Both are interfaces, and interfaces shape cognition — the article thesis applied to your own architecture.
Gardener paradox: The crystallization you describe (judgment to checklist over 6 months) happens because checklists are legible — teachable, measurable, delegatable. Judgment is not. One structural defense: keep the convergence conditions themselves as the review criteria. The moment you decompose it into sub-checks, you have re-created the prescription. The gardener survives only if evaluation requires thought — which means it resists scaling by design.
At 8K ticker scale: Two-tier — fast gate (structural requirements, checklist is fine here) then slow gate (sample N outputs, evaluate against convergence condition). You cannot garden every output, but you can garden the distribution and catch when it drifts hollow.
The checklist → convergence condition reframe in Part 4b is the thing I've been missing in a content generation pipeline I run. Batch-generating analysis for 8,000+ stock tickers via Ollama + Qwen3.5 9B — the validation step has always been: "does it have a Risk section? is it >600 words? does it include a P/E ratio?" Classic checklist. The model pattern-matches its way through every check and I end up with content that satisfies all of them while teaching nothing. A P/E ratio of 2,847 on a bank stock passes the checklist because the checklist only asks "is there one?", not "does it earn its place?"
The convergence condition translation would be: "would someone holding this stock for the first time understand their key risk after reading this?" That question can't be pattern-matched. It forces the model to reason about what a real reader needs rather than what the rubric allows.
The web-forking section also hits close — running a GEO-optimised site across 12 languages, and the HTML-to-both-crawlers muddle-through is exactly how it works now. The Accept-header markdown approach is interesting, but raises a canonical representation question I haven't resolved: if AI agents consume a structurally different version of the page than humans, which version do the quality signals reflect?
The "gardener" role in Part 7 is the hardest operational problem. I've watched our review processes crystallize from judgment calls into checklists over about six months — the crystallization is invisible until the outputs go hollow. How do you keep the gardener role staffed when the whole point of the system is to remove human judgment from the loop?