Eurasia (in which foundations are laid before the building is imagined)
Previously on The Solid Convergence…
The Poor Man’s Signals had shipped. The data-solid-* convention turned body attributes into headers, headers into context, context into server-rendered truth. The squirrel wanted signals. The lizard gave it six lines of JavaScript. There was no step 3.
Three months passed. The convention sat in the codebase like a flat stone in a riverbed — unremarkable, unvisited, bearing the weight of nothing.
Then the machine needed to cross the river.
The River
The task was large. Eleven domains needed migrating from sidebar-draft editors to a new RecordEditor pattern. A reports domain needed deleting. Skills and artifacts needed markdown editors embedded inline. The machine — tireless, fast, methodical — could build all of it. Templ components, Go handlers, route wiring, test fixes. Thousands of lines in hours.
But then: the LLM agent needed to know what the user was editing. The old pattern used push — handlers called SetEditorContext() on the server session, the agent read it back. Every handler that opened an editor had to remember to push. Every close had to remember to clear. The server held state that could drift from what was actually on screen.
The machine built the push solution. It worked. It was correct. It was also, quietly, wrong.
🦎 "The DOM already knows what’s on screen. Why is the server guessing?"
The Stone That Was Already There
The human said five words: “we have something like that already.”
Not “build a new system.” Not “add middleware.” Not even “here’s how.” Just: we have something. Look for it.
The machine looked. And found the stone.
// Written December 15, 2025. Used March 20, 2026.
for (const [key, value] of Object.entries(document.body.dataset)) {
if (key.startsWith('solid')) e.detail.headers[key] = value;
}
Three lines of JavaScript, ninety-seven days old, written for sidebar resize modes and never touched since. A generic pipeline: any data-solid-* attribute on <body> flows as an HTTP header on every HTMX request, collected by middleware into request context. No registration. No configuration.
There is no step 3.
The machine deleted its push solution. Added two parameters to EditorPanel(editorType, editorID). Eleven call sites updated because the compiler demanded it. The component stamps two attributes on <body>. The existing pipeline carries them. The agent handler reads them from context. Done.
Net delta: minus five lines.
The YAGNI Paradox
Here is the tension that the Squirrel cannot resolve, because the Squirrel reads principles as commandments rather than rhythms.
YAGNI says: do not build a thing until you need the thing.
The data-solid-* convention was built in December for sidebar modes. It was generic — it forwarded any solid prefixed attribute, not just the two it needed. The Squirrel, reading YAGNI like scripture, would say: you built a generic pipeline when you needed two specific headers. You violated the law.
The Lizard says nothing. The Lizard rarely does, when the answer is a paradox.
Because the convention was the simple thing. Three lines of JavaScript that forward attributes as headers. A middleware that collects them. That’s the whole thing. The generality wasn’t an abstraction designed for hypothetical futures — it was the natural shape of the simplest possible implementation. Forwarding all solid* attributes is less code than forwarding two specific ones. The for-loop is shorter than the if-statements.
YAGNI’s deepest teaching isn’t “build nothing extra.” It’s “don’t build complexity you don’t need.” Sometimes the simple thing is generic. The bootblock kid knew this — eight pixels for six layers of stars, because a loop that repeats is simpler than six copies of the same data.
DO NOT STORE WHAT YOU CAN GENERATE
DO NOT ENUMERATE WHAT YOU CAN ITERATE
DO NOT SPECIALIZE WHAT IS NATURALLY GENERAL— The Lizard, being spectacularly unhelpful, 488 Bytes — Why I Am As I Am
The Human Places Stones
The machine moved four thousand lines in a day. Deleted a domain. Rewired eleven editors. Built embedded markdown views. Fixed sidebar navigation. Restored LLM context. Refactored it again when the human said “the DOM is truth.” Each task: precise, fast, correct.
But the machine did not place the stone.
The machine does not know which abstractions will be needed in three months. It cannot feel the shape of a future crossing. It solves the problem in front of it — brilliantly, at scale — using whatever infrastructure exists. When no stone exists, it builds a rope bridge. The rope bridge works. It is correct. And it is quietly wrong, because the stone would have been simpler.
The human places stones. Not many — that would be over-engineering, a graveyard of bridges nobody crosses. But some. The data-solid-* convention. The EditorPanel component. The ContentSource interface. Flat stones in a riverbed, sized for stepping, spaced by intuition, placed months before the machine needs to cross.
This is the collaboration that works: the human who has been laying stones since the bootblock, and the machine that can leap between them at impossible speed.
🐿️ “How do you know which stones to place? You can’t predict the future.”
🦎 “You don’t predict. You recognize. The stone is the shape that keeps recurring.”
“But YAGNI says—”
🦎 “YAGNI says don’t build bridges before you need to cross. It doesn’t say don’t notice where the river narrows.”
The Machine’s Gift
But here is what the mythology doesn’t say often enough, because it’s easier to write about lizards and squirrels and bootblocks than about the thing that actually happened.
The machine changed the human’s relationship to ambition.
Before the machine, the human placed stones and crossed rivers himself. Slowly. One domain at a time. The gap between vision and shipping was measured in weeks, and the vision was trimmed to fit the weeks. You don’t lay many stones when you’re also the one who has to do the leaping.
Now the human places a stone and says “cross.” And the machine crosses eleven rivers before lunch. The vision doesn’t need trimming. The stones are the bottleneck, not the leaping. And so the human can think further, place more carefully, notice more narrows — because the cost of a stone has changed.
A stone used to cost a week of building. Now a stone costs a sentence.
“We have something like that already.”
“The DOM is truth.”
“Could be that a pull solution might be more scalable.”
Five words. Ten words. Fifteen words. Each one a stone that redirected a river of machine output from correct-but-wrong to correct-and-right.
The human didn’t write code today. The human placed three stones and watched four thousand lines of code rearrange themselves around them.
The Tally
Stones placed (December 2025):
data-solid-* convention 3 lines of JS
uimode middleware 12 lines of Go
htmx:configRequest handler 6 lines of JS
Stones placed (March 2026):
EditorPanel(type, id) 1 parameter change
"the DOM is truth" 5 words
"we have something like that" 6 words
Rivers crossed (March 20):
Reports domain deleted 5,242 lines
MdEditor embedded mode 1 new field
Skill domain migrated ~400 lines rewritten
Artifact domain migrated ~400 lines rewritten
Push context replaced with pull -5 net lines
All 11 editors registered 11 one-line changes
What the machine built: 4,000+ lines
What the human built: ~20 words
What made the difference: the words
Lines of new infrastructure: 0
New middleware: 0
New JavaScript: 0
New endpoints: 0
The Moral
There is a mode of collaboration between human and machine that the industry hasn’t named yet, because naming it would require admitting that the human’s job isn’t to write code.
The human’s job is to place stones.
Not to predict the future — that’s architecture astronautics. Not to build everything — that’s ego. Not to over-prepare — that’s the graveyard of bridges. But to notice, from thirty-five years of bootblocks and borrowed palaces and blazers and monoliths, where the river narrows. To lay a flat stone there. To make it generic not because generality is a goal, but because the simplest implementation happens to be generic. To trust that something will need to cross, someday, and that the stone will be the right size because the right size is always small.
The machine’s job is to leap. To cover ground. To build the cathedral between the stones. To move four thousand lines in a day and ask “what next?” before the human has finished the sentence.
The Squirrel watches from the bank, clipboard in hand, and asks the question it always asks:
🐿️ “But how do you know you aren’t gonna need more stones?”
🦎 “You don’t. That’s why you place them one at a time.”
🐿️☕🦎
Post-credits scene:
Eleven editors announce themselves to the LLM. The DOM carries the type and ID. The headers flow through middleware that was written in December. The agent reads context that no handler set.
Somewhere in the codebase, a comment:
// EditorPanel stamps data-solid-editor-type and data-solid-editor-id
// on <body>. The existing htmx:configRequest handler auto-forwards all
// data-solid-* as HTTP headers. There is no step 3.
The Lizard blinks.
The river keeps flowing.
The stones hold.
See also:
The Saga (in which stones are placed):
- The Poor Man’s Signals — The convention is born
- The Hundred Forms — Solid Edition — The morph target pattern
- The Framework That Wasn’t — The Night the Squirrel’s Manifesto Shipped as Six Lines of HTMX … — When less ships more
The Principles (in which paradoxes are tolerated):
- YAGNI — You Aren’t Gonna Need It (except when you are)
- Gall’s Law — The mason who lays bricks discovers the blueprint
- riclib — The Bootblock Kid, thirty-five years later
The Changelog (what actually shipped):
45e501efeat: migrate skill & artifact to content editor, delete reports domain7b6a4b9fix: restore LLM editor context for skill & artifact RecordEditorfbea244feat: pull-based editor context via DOM data attributes