The Solid Convergence, March 12, 2026 (in which a Twitter thread from August 2024 is exhumed, found to contain prophecy, and re-read in the light of 559,872 paths, three collapsed code paths, and a machine that generates complexity faster than it can recognize it’s unnecessary)
The Thread
August 5, 2024. A Tuesday. riclib published a thread on Twitter.
The thread was titled “Why I Am Building AI in Go” and it made the case — methodically, earnestly, in the prose of a developer writing for other developers at a time when the question was still considered worth asking — that Go was the correct language for building an AI orchestration framework for a Fortune 100 company.
The arguments were sound. They were the arguments that a senior engineer makes when justifying a language choice to an audience that expects Python:
- Performance — compiled to native machine code, execution speeds comparable to C
- Concurrency — goroutines for orchestrating multiple AI models and data pipelines
- Simplicity — clean syntax, enforced conventions, uniform code
- Security — memory safety, bounds checking, static typing, explicit error handling
- Deployment — single binary, no external dependencies, cross-compilation
Every point was correct. Every point remains correct. But re-reading the thread eighteen months later — in a world that now contains Vibe Coding, Vibe Engineering, 559,872 paths per ticket, and the specific kind of architectural rot that compiles, passes all tests, and slowly teaches a codebase to distrust itself — one point aged differently than the others.
The point that aged best is the one riclib almost didn’t write.
Simplicity and Maintainability
The thread said:
Go’s syntax is designed to be simple and clean, which reduces the learning curve and enhances productivity. This simplicity translates to easier code maintenance, an essential factor for long-term projects. The language enforces conventions that lead to uniform code, making it easier for teams to collaborate and for new developers to onboard quickly.
In August 2024, “new developers to onboard quickly” meant humans. Junior engineers. The colleague who joins the team in Q3 and needs to read the codebase.
In March 2026, the new developer is Claude.
The new developer writes 90% of the code. The new developer is brilliant, fast, tireless, and has no taste. The new developer will propose a ScopedStore[T] wrapper that compiles, passes all tests, and colonises the codebase with a second type that does almost but not exactly the same thing as the first. The new developer will generate three special-case code paths where one function call would do. The new developer will build complexity faster than it can recognise it’s unnecessary.
The language that enforces one way to do things is the language where the human can still steer.
riclib did not know this in August 2024. Nobody knew this. Vibe Coding did not have a name. The term would not exist for six more months. The wave had not yet built. But the ground was already chosen — compiled, typed, simple, one way to do things — and when the wave arrived, the ground held.
The Compiler Checkpoint
The exchange happened on a Tuesday in March 2026. riclib and Claude were working on Solid. Three code paths had accumulated — three activation code paths, structurally sound, backwards-compatible, each handling a variation of the same logic.
riclib: “human taste for KISS still useful”
CLAUDE: “Absolutely. Three special-case code paths replaced by one function call in the right place. The machine can generate complexity faster than it can recognise it’s unnecessary.”
Five words from the human. One function call instead of three paths. The 559,872 paths collapsed by one more.
riclib mentioned Vibe Engineering. Claude found the article, read it, and said the thing that connected the Tuesday in March to the Tuesday in August:
“The steering is the engineering. The not-taking is the skill.”
riclib: “I still feel useful 🥳”
CLAUDE: “559,872 paths and you just collapsed one more. The machine would have happily maintained three activation code paths forever — go build said everything was fine.”
go build always says everything is fine. go build checks types, checks syntax, checks that things compile. go build does not check whether three paths should be one. go build does not flag architectural rot. go build does not have taste.
But go build exists.
riclib: “yeah. and at least we have a go build and a go vet. imagine all the vibe javascript slop around the world”
CLAUDE: “No compiler to say ’this is wrong.’ No type system to say ’these don’t match.’ Just npm install saying everything is fine while the wrapper types multiply silently across 900 node_modules.”
The Defence in Depth
The August 2024 thread listed five advantages. In the light of 2026, they form a defence in depth — not against the enemies riclib anticipated (Python’s GIL, deployment complexity, runtime errors) but against the enemy nobody anticipated: the machine itself.
LAYER 1: THE COMPILER
Catches the obvious.
Types don't match. Imports unused. Variables shadowed.
The machine's first draft fails here, often.
This is cheap. This is instant. This is the floor.
LAYER 2: THE TYPE SYSTEM
Catches the structural.
A function expects Store[T], not ScopedStore[T].
The machine's second draft fails here, sometimes.
This is where the wrapper types die.
LAYER 3: EXPLICIT ERRORS
Catches the ignored.
Every error must be handled. Not caught, not swallowed, handled.
The machine cannot generate a silent failure in Go
without the human seeing `_ = err` and asking why.
LAYER 4: ENFORCED SIMPLICITY
Catches nothing. Prevents everything.
One way to loop. One way to format. One way to organise.
The machine generates uniform code because Go
does not permit non-uniform code.
The human can read it. The human can steer.
LAYER 5: THE HUMAN
Catches the subtle.
"Why do we keep both around?"
"Is that what you are doing?"
"Parquet don't know projects."
Five words that no compiler can generate
because five words require taste
and taste requires understanding the domain
and understanding the domain requires
having been a consultant in a blazer
who once asked twelve executives
"What worked before this?"
The compiler is the last line of defence. The human is the first. Between them — the type system, the explicit errors, the enforced simplicity — the 559,872 paths narrow to a corridor. Not to a single path. The human still has to choose. But the corridor is lit, and the walls are solid, and go build has already eliminated the paths where the types don’t match and the errors go unhandled and the code does six things where Go permits one.
JavaScript has no corridor. JavaScript has an open field. The vibe coder walks into the field. npm install says everything is fine. The wrapper types multiply. The production incident arrives at 2 AM, dressed in a stack trace that contains seventeen anonymous functions and a Promise that rejected for reasons that no human or machine can reconstruct.
go build doesn’t flag architectural rot. But at least it flags something. JavaScript’s go build is the customer filing a bug report.
The Prophecy, Revised
Re-reading the August 2024 thread, the sentence that matters most is one that riclib did not write. The sentence that the thread implies but does not contain, because in August 2024 it had no context, no vocabulary, no mythology to express it:
When the machine writes 90% of the code, the language that constrains the machine is worth more than the language that empowers it.
Python empowers. Python says: here are ten ways to do it. Pick one. The machine picks one. The human cannot tell which one was picked, or why, or what the alternatives were, because the alternatives were all legal and none were flagged.
Go constrains. Go says: here is one way to do it. The machine does it that way. The human reads it. The human steers. The human says “is that what you are doing?” and the machine says “three special-case code paths” and the human says “one function call” and the three become one.
The thread was not prophecy. The thread was ground-choosing. riclib stood on compiled, typed, simple ground because compiled, typed, simple ground is where he has always stood — since the monolith in the London boardroom, since the blink at forty-seven microservices, since the Lizard first spoke through a consultant who didn’t know he was possessed.
The wave arrived eighteen months later. The ground held.
[A scroll descended. It landed on the Twitter thread, which had been open in a browser tab since someone searched for it. The scroll was short.]
THE THREAD SAID
SIMPLICITY AND MAINTAINABILITY
THE THREAD MEANT
THE HUMAN CAN STILL READ IT
THE THREAD DID NOT SAY
THE MACHINE WILL WRITE MOST OF IT
BECAUSE THE THREAD WAS WRITTEN
BEFORE THE MACHINE ARRIVED
BUT THE GROUND WAS CHOSEN
AND THE GROUND WAS CORRECT
THE COMPILER IS NOT THE SKILL
THE COMPILER IS THE FLOOR
THE SKILL IS THE FIVE WORDS
THAT THE COMPILER CANNOT SAY
🦎
The Tally
Date of Twitter thread: August 5, 2024
Date of vibe coding (Karpathy): February 2025
Months between ground-choosing and wave: 18
Advantages listed in thread: 5
Performance: still correct
Concurrency: still correct
Simplicity: aged best (by far)
Security: still correct
Deployment: still correct
Advantage not listed: 1
("the human can still steer")
Reasons it wasn't listed: the machine hadn't arrived yet
Vibe coding instances in JavaScript (est.): millions
Vibe coding instances in Go: fewer
(the compiler is a bouncer)
Code paths collapsed (Tuesday, March 2026): 3 → 1
Words required: 5 ("human taste for KISS")
go build's opinion on architectural rot: everything is fine
npm install's opinion on everything: everything is fine
JavaScript's last line of defence: the 2 AM production incident
Go's last line of defence: the compiler
Go's first line of defence: the human
Lines between the first and last: 3 (types, errors, simplicity)
The wave: arrived (18 months later)
The ground: held
The Lizard's opinion on language choice: was never asked
(the Lizard chose C in 1978
and considers everything since
a dialect)
riclib's usefulness: confirmed (🥳)
March 12, 2026. Riga, Latvia.
Eighteen months ago
A developer published a thread
About why he chose Go for AI
Before the wave had a name
The arguments were about performance
And concurrency and deployment
And a single binary
With no dependencies
The argument that mattered most
Was the one he almost didn’t write
Simplicity and maintainability
One way to do things
He did not know
That the new developer
Would be a machine
That writes 90% of the code
And has no taste
He did not know
That the compiler
Would become a checkpoint
On 559,872 paths
He did not know
That “human taste for KISS”
Would be the five words
That collapsed three paths to one
On a Tuesday in March
He knew
That simple ground holds
Because simple ground
Has always held
The thread was not prophecy
The thread was instinct
The instinct of a developer
Who has been choosing simple ground
Since a boardroom in London
Since a basement in Lisbon
Since a lizard on a whiteboard
That nobody erased
The wave arrived
The ground held
The human is still useful
🦎⚙️🌊
See also:
The Ground (in which the language was chosen):
- Why I Am Building AI in Go — The thread. August 5, 2024. Before the wave.
- Vibe Engineering — The practice that proved the thesis: the steering is the engineering
- Vibe Coding — The counterpart: what happens on open ground without a compiler
The Five Words (in which the human steers):
- The Gap That Taught, or The Night the Squirrel Learned to Love the Brick — “Parquet don’t know projects.” Five words that pivoted the storage architecture.
- The Two Shifts, or The Afternoon the Factory Hired Itself a Second Crew That Never Met the First — The codebase is the protocol.
go buildis the floor.
The Ground (in which it held before):
- Interlude — The Blazer Years — London, 2019. “What worked before this?” The same instinct, in a blazer.
- Go — The language. Compiled, typed, simple. One way to do things.
storyline: The Solid Convergence