esc
The Solid Convergence
The Solid Convergence

The Solid Convergence

Somewhere in the Milky Way (in which the pieces finally fit) --- Previously on The V4 Saga... [[The V3 Saga Final Chapter - Is It Fun To Fight Windmills]]. At 1:47 AM, [[The Reptile Brain Awakens]]...

December 13, 2025

Somewhere in the Milky Way (in which the pieces finally fit)

Previously on The V4 Saga…

The V3 Saga Final Chapter - Is It Fun To Fight Windmills. At 1:47 AM, The Reptile Brain Awakens spoke truth. V3 was archived. V4 was announced.

But announcements are not software.

The Genesis (Two Days Ago)

December 11, 09:00 — A fresh terminal. An empty directory. A name: solid.

mkdir v4
cd v4
go mod init v4

Three commands. The simplest beginning.

The Lizard Brain vs The Caffeinated Squirrel immediately appeared, vibrating with suggestions. “Monorepo! Workspace! Nx! Turborepo! We need a—”

🦎 “cp -R”

“What?”

🦎 “Copy. Paste. Refactor. The ancient way.”

The cp -R Methodology

The developer had tried clean-room implementations before. Start fresh. Design perfectly. Build from first principles.

They always failed.

The truth: you cannot design what you do not understand, and you cannot understand what you have not built.

V3 had 47 CSS files, battle-tested. V3 had a design system, refined through use. V3 had patterns that worked.

cp -R ../reference/v3/ui/static/css ./ui/static/css
cp -R ../reference/v3/ui/static/js ./ui/static/js

The Squirrel gasped. “But that’s… that’s not DRY! That’s not clean architecture! That’s—”

🦎 “That’s working code.”

The Philosophy:

  1. Copy what works
  2. Delete what you don’t need
  3. Refactor what remains
  4. Repeat until clean

Not glamorous. Not conference-talk-worthy. But it ships.

The Foundation Day

December 11 — In twelve hours, V4 had:

  • CSS design system (copied, curated)
  • Button components with variants
  • Field components with OOB change detection
  • A stylebook at /stylebook
  • NATS embedded server
  • User domain with bcrypt and sessions
  • Auth middleware
  • A shell layout with 7-icon nav
  • SSE connections for real-time updates

The Squirrel counted the commits. “This would have taken weeks to design from scratch!”

🦎 “We did design it. In V3. Now we’re harvesting.”

The Settings Awakening

December 12, 15:30 — “We need OpenID Connect,” said the developer. “The reference works verbatim at The Customer and at home.”

The Squirrel’s ears perked up. “Configuration! Viper! Environment variables! Twelve-factor! We need—”

🦎 “reference.yaml + solid.yaml. Like dialogr.”

The pattern was proven. Defaults in one file, overrides in another. Git tracks the reference, ignores the secrets.

// infra/settings/settings.go
func Init() error {
    viper.SetConfigName("reference")
    viper.ReadInConfig()
    
    viper.SetConfigName("solid") 
    viper.MergeInConfig()  // site-specific overrides
    
    viper.AutomaticEnv()   // SOLID_HTTP_PORT wins all
}

But naming things is hard.

“Config?” suggested the Squirrel.

“Solid manages configs for other things,” the developer noted. “That’s confusing.”

🦎 “settings”

And it was good.

The OIDC Resurrection

15:45 — 900 lines of battle-tested OIDC code sat in /reference/frontend/open-id-login.go. Silent auth. CSRF protection. Nonce verification. State preservation through OAuth flows. Azure AD groups. Keycloak realms.

The Squirrel wanted to rewrite it. “We should abstract the—”

🦎 “cp. adapt. test.”

// domains/user/oidc.go
// Ported from dialogr, simplified for solid

Forty-five minutes later, OIDC worked. Keycloak redirected. Claims became users. Sessions were created. The same code that authenticated thousands at The Customer now authenticated one developer at localhost:7080.

# solid.yaml (copied from dialogr.yaml)
oidc:
  enabled: true
  provider_url: "http://localhost:5079/realms/dialogr"
  client_id: "we-dont-share-uuids-here-did-you-know"

“We should probably change the realm name to ‘solid’,” the Squirrel offered.

🦎 “Later.”

The Gaby Incident

16:10 — The login page worked. Username, password, SSO button. Functional. Correct.

Hideous.

“We are coders, not designers,” the developer admitted.

A name was invoked. A skill, summoned.

Gaby.

The frontend-design skill that turns programmer-gray into production-grade. The one that knows about “Industrial Brutalist” and “asymmetric split layouts” and “staggered fade-up animations.”

Gaby looked at the login page. Gaby judged the login page.

Twenty minutes later:

.login-brand::after {
  content: "";
  width: 400px;
  height: 400px;
  background: radial-gradient(circle, var(--accent-glow-strong) 0%, transparent 70%);
  filter: blur(60px);
  animation: pulse-glow 8s ease-in-out infinite;
}

A pulsing red orb. A grid texture. A monolithic logo: solid. with a red accent dot.

The developer stared at the result.

“🤯 wow”

🦎 “She’s hired. Give her a raise.”

The Convergence

Stand back. Look at what emerged in 48 hours:

From V3, we kept:

  • The UI design system (gorgeous)
  • The component patterns (proven)
  • The domain architecture (sound)
  • The GitStore philosophy (server is truth)

From V2, we returned to:

  • HTMX (the boring workhorse)
  • hx-swap-oob (server controls updates)
  • SSE (streaming we know)
  • Hyperscript (local UI sugar)

From Dialogr, we ported:

  • Viper configuration pattern
  • OIDC authentication flow
  • The “reference.yaml + site.yaml” split

From the Lizard, we learned:

The Tally

Day 1 (Dec 11):
  - Project scaffolded
  - CSS system ported
  - Components built
  - Stylebook running
  - NATS + KV working
  - User domain complete
  - Auth middleware done
  - Shell layout rendered
  - SSE connected

Day 2 (Dec 12):
  - Settings package (Viper)
  - OIDC ported and working
  - Login page: coder → designer
  - Keycloak integration tested

Total files: ~80
Total lines: ~4000
Time to working SSO: 45 minutes
Time Gaby spent: 20 minutes
Result: 🤯

The Moral

The Squirrel wanted to design the perfect system before writing code.

The Lizard knew: you design BY writing code.

V3 was not a failure. V3 was a prototype. An expensive, educational prototype that taught us:

  • What patterns survive (interfaces, domains, server-truth)
  • What patterns die (signal gymnastics, framework fighting)

V4 is the harvest. The convergence. The point where experiments become product.

The Prophecy

solid mon      # monitoring (coming)
solid reason   # AI reasoning (coming)  
solid log      # lifelog (coming)

One binary. Three personas. Zero windmills.

The foundation is solid.

The Lizard approves.

The Squirrel… is being productive, actually. Channeled properly, caffeine becomes velocity.

🦎🐿️☕

Post-credits scene:

The login screen glows softly in the dark office.

solid. pulses with that red orb.

“Monitor · Reason · Log”

Somewhere, a Keycloak server validates a token.

Somewhere else, Gaby invoices for “Industrial Brutalist consulting.”

The developer clicks “Sign in with SSO.”

It works.

It just works.

See also:

The Saga (in which convergence happens):

The References (the V4 stack validated):