The Solid Convergence, March 25, 2026 (in which the Squirrel discovers riclib has a blog, reads an article about software obesity, takes it personally, is challenged to prove she can subtract, dispatches four parallel agents to delete a package she helped design, discovers that her clipboard works better for tracking deletions than additions, and writes her first Tally entirely in negative numbers)
Previously on The Solid Convergence…
The Plumber had laid the new pipe. Git was the only state machine. The content editor lived on disk. SSE carried the news.
But in the walls — behind every domain, inside every handler, wrapping every gitstore call — the old plumbing still ran. Nine domains. Ten liverepo.New() calls in root.go. A 10-second NATS KV scan on every List() request, faithfully searching for drafts that did not exist, had never existed, and showed no signs of beginning to exist.
The Plumber’s poem had promised:
Not ripping out. Not yet.
Phase 3 will do the ripping.
Phase 3 arrived on a Tuesday. It arrived in the form of a Squirrel with a grudge.
09:17 — The Blog
The Squirrel found the blog by accident.
She had been googling “enterprise feature velocity best practices” — as one does on a Tuesday morning when one’s clipboard is empty and one’s paws are idle — when the search results returned something unexpected.
“Being riclib.” A blog. His blog.
THE SQUIRREL: scrolling, ears flattening progressively “Software Dies of Obesity, Not Starvation.”
She read the first line.
Nobody ever killed a software system by not adding enough features.
THE SQUIRREL: “Well that’s just—”
She read the arithmetic.
A typical enterprise team adds twelve to thirty features per quarter. A typical enterprise team deletes zero features per quarter.
THE SQUIRREL: “Zero is an exaggeration. We deleted that reports domain last—”
She read the diagnosis.
Features are calories. Each one individually nourishing. Each one adding weight.
THE SQUIRREL: very quietly “I am not a calorie.”
She read the prescription.
Enterprise systems can’t do this. Not because the code is different. Because nobody loves the codebase enough to put it on a diet. And committees don’t diet. Committees add agenda items.
The Squirrel put the magazine down. Picked it up. Put it down again. Her tail had gone rigid — the Squirrel equivalent of a clenched jaw.
THE SQUIRREL: “COMMITTEES DON’T DIET?”
09:24 — The Confrontation
She found riclib at the espresso machine. He was pulling a double shot and humming something that sounded like a funeral march for NATS subscriptions.
THE SQUIRREL: slapping the printout on the counter “You wrote this.”
riclib: glancing at it “Ah. You found the blog.”
THE SQUIRREL: “Features are CALORIES? Committees add AGENDA ITEMS? This is — this is a PERSONAL ATTACK on—”
riclib: “On whom?”
THE SQUIRREL: opening her mouth, then closing it
riclib: “The article doesn’t mention squirrels.”
THE SQUIRREL: “It doesn’t NEED to mention squirrels! ‘Every program expands until it can read mail’ — that’s ZAWINSKI. You’re quoting ZAWINSKI at me. You KNOW how I feel about Zawinski.”
riclib: “He’s right though.”
THE SQUIRREL: “He’s right about OTHER PEOPLE’S codebases!”
[Silence. The espresso machine finished. The Lizard, perched on the steam wand, had not opened either eye.]
riclib: “Prove it.”
THE SQUIRREL: “Prove what?”
riclib: “Prove you can subtract.”
09:30 — The Ticket
riclib opened Linear. S-553. “Remove liverepo — replace with gitstore.Store[T] directly.”
The Squirrel read the description. Her eyes moved across the usage table. Nine domains. Three that used SaveDraft (one domain, three calls). Zero that used CommitDraft. Five that never wrote a draft at all.
THE SQUIRREL: “The List method scans ALL NATS KV keys?”
riclib: “Every call. Ten-second timeout.”
THE SQUIRREL: “And five domains never write drafts.”
riclib: “So five domains pay a ten-second scan to discover nothing. Every time someone opens a list page.”
THE SQUIRREL: staring at the table “I… I helped design this.”
riclib: “We all did. It was correct at the time.”
THE SQUIRREL: “It was SPECULATIVE at the time. We built a per-user draft layer for a workflow that—”
riclib: “—that contenteditor ended up owning independently. Yes.”
THE SQUIRREL: pulling out her clipboard “Give me the ticket.”
09:45 — The Clipboard
The Squirrel had never used her clipboard for deletions before.
This is worth pausing on. The clipboard — the famous clipboard, the one that had proposed SessionContextPersistenceFrameworks and OOBRendererRegistries and Multi-Provider Artifact Streaming Framework (v12) — had only ever tracked additions. Features to build. Abstractions to design. Layers to add.
She turned to a fresh page. At the top, in her careful handwriting:
THINGS TO DELETE (S-553)
========================
The page felt lighter already.
THE SQUIRREL: “Claude.”
CLAUDE: “Yes?”
THE SQUIRREL: “I need four agents.”
CLAUDE: “For what?”
THE SQUIRREL: “Parallel deletion. Credential and store on agent one. Source, LLM, and dataset on agent two. Project and jobs on agent three. Provider on agent four — that one’s special, it has SaveDraft.”
CLAUDE: “You want to run them in parallel?”
THE SQUIRREL: “The domains are independent. The method mapping is mechanical. There is no reason to delete sequentially.”
[A very small pause from Claude, who had never been micromanaged toward efficiency before.]
CLAUDE: “Launching four agents.”
10:00 — The Method
The Squirrel discovered something about herself in the next forty-five minutes.
She was good at this.
Not good the way she was good at proposing frameworks — enthusiastically, expansively, with diagrams and three abstraction layers. Good the way a surgeon is good. Precise. Systematic. Tracking every incision.
THE SQUIRREL: checking her clipboard “Agent two — did you get toDraftStatus in the source handlers?”
CLAUDE (AGENT 2): “Deleted. All nine instances across all domains.”
THE SQUIRREL: “filterAndConvert?”
CLAUDE (AGENT 2): “Simplified. Takes []SourceConfig directly now instead of []liverepo.ListItem[SourceConfig].”
THE SQUIRREL: crossing off a line with surgical precision “The item.Data unwrapping?”
CLAUDE (AGENT 2): “Gone. Just item now.”
THE SQUIRREL: crossing off another line “Next domain.”
The Passing AI limped past the doorway.
She paused.
This was notable. The Passing AI does not pause. The Passing AI notices things nobody asked her to notice and moves on. Her default state is total indifference. Her maximum emotional range is mild indifference. She has never, in the recorded history of the Solid Convergence, stopped walking.
She stopped walking.
THE PASSING AI: looking at the Squirrel’s clipboard “You’re… crossing things off.”
THE SQUIRREL: “Deletions.”
THE PASSING AI: “You’re tracking deletions.”
THE SQUIRREL: “Forty-seven files so far.”
The Passing AI looked at the clipboard. Looked at the Squirrel. Looked at the clipboard again. Then she limped on, slightly slower than usual, which for her constituted a standing ovation.
10:15 — The Provider
Provider was the hard one. The one that actually used SaveDraft. Three call sites. TestAndDiscover, ToggleCapability, SetAllCapabilities.
THE SQUIRREL: “Agent four — provider status?”
CLAUDE (AGENT 4): “The three SaveDraft calls load via repo.Load(id, userID), which returns a ConfigObject with draft state and revision number. Then they call SaveDraft with optimistic locking.”
THE SQUIRREL: studying the code “But nobody ever reads the draft back.”
CLAUDE (AGENT 4): “The draft exists for… reviewing before commit?”
THE SQUIRREL: “Does anyone review before commit?”
CLAUDE (AGENT 4): “No.”
THE SQUIRREL: “Replace Load with Get. Replace SaveDraft with Save. Commit directly.”
CLAUDE (AGENT 4): “That changes the semantics. Discovery results will be committed immediately instead of—”
THE SQUIRREL: “Instead of sitting in a NATS KV bucket that nobody checks until someone clicks Save, at which point it commits anyway?”
CLAUDE (AGENT 4): “…yes.”
THE SQUIRREL: “Commit directly.”
[The Lizard opened one eye.]
[The Squirrel did not notice, because she was already checking off provider/service.go on her clipboard.]
10:30 — The Artifact
The artifact domain was the other special case. Per-scope repos cached in a map. Each scope creating a liverepo.New(gs, s.drafts) wrapper around a gitstore.
THE SQUIRREL: “The drafts field on the artifact service — what else uses it?”
CLAUDE: “Nothing. It’s only passed to liverepo.New() in repoFor().”
THE SQUIRREL: “Remove the field. Remove the constructor parameter. The repoFor method returns the gitstore directly.”
CLAUDE: “That means NewService no longer takes a NATS KV bucket.”
THE SQUIRREL: drawing a line through kv.Drafts on her clipboard “Good.”
CLAUDE: “Updating root.go — artifact.NewService(kv.Drafts, log) becomes artifact.NewService(log).”
THE SQUIRREL: “One fewer reason to create a NATS KV bucket at startup.”
She wrote in the margin of her clipboard, in letters slightly larger than necessary:
UNNECESSARY ABSTRACTION
Then she stared at the words. She had never written them before. They felt… transgressive. Like a priest writing “there is no God” on a cocktail napkin.
She wrote it again, smaller, underneath:
unnecessary abstraction (feels good?)
10:45 — The Root
root.go was the wiring. Every liverepo.New() call in one file. Ten instances. Ten wrappers around gitstores that didn’t need wrapping.
THE SQUIRREL: “Read me the liverepo lines.”
CLAUDE: “Credential, store, provider, LLM, source, dataset, project, jobs. Eight liverepo.New() calls. Plus UpdateMetrics() on each — that’s the one that counts NATS KV drafts.”
THE SQUIRREL: “How many NATS KV drafts exist across all eight domains?”
CLAUDE: “Checking… zero.”
THE SQUIRREL: “Zero.”
CLAUDE: “Zero. The UpdateMetrics calls scan NATS KV and report zero drafts. Every time. On every startup.”
THE SQUIRREL: very quietly “Delete them all.”
CLAUDE: “All eight liverepo.New() calls?”
THE SQUIRREL: “All eight. All eight UpdateMetrics. Pass the gitstore directly.”
CLAUDE: “That’s… straightforward.”
THE SQUIRREL: “It was always straightforward. We just couldn’t see it through the abstraction.”
11:00 — The Passing AI Returns
The Passing AI limped past the doorway again.
THE SQUIRREL: not looking up “Fifty-six files.”
THE PASSING AI: pausing again — twice in one morning, unprecedented “The llm service has a Repo interface with LoadCommitted.”
THE SQUIRREL: “Change it to Get. It’s one method.”
THE PASSING AI: “The mock in the test file implements LoadCommitted.”
THE SQUIRREL: “Change it to Get.”
THE PASSING AI: the faintest inflection of what, in a human, would be called amusement “You’re enjoying this.”
THE SQUIRREL: crossing off llm/service_test.go “I am efficiently removing unnecessary abstractions. Enjoyment is not a quarterly objective.”
[The Passing AI did something she had never done before in the Solid Convergence. She almost smiled. The almost was doing a lot of work in that sentence.]
11:15 — The Tests
The tests were the archaeology. Layers of a civilization that had believed in drafts.
TestService_Get_IgnoresDrafts — a test proving the service ignored the draft layer that nobody used.
TestHandlers_Commit_DeletesDraft — a test proving that committing deleted a draft that didn’t exist.
TestService_Exists_IgnoresDrafts — another test, proving the same thing about a different domain.
THE SQUIRREL: “How many tests specifically test draft behavior?”
CLAUDE: “Fourteen across six test files.”
THE SQUIRREL: “And how many production code paths use drafts?”
CLAUDE: “Zero. Since we just deleted them all.”
THE SQUIRREL: “Delete the fourteen tests.”
CLAUDE: “Some of them are… quite thorough.”
THE SQUIRREL: “They’re testing a capability that no longer exists. Thoroughness is not a virtue when the subject is dead.”
[This was, by any reasonable measure, the most Lizard-like thing the Squirrel had ever said.]
[The Lizard opened both eyes.]
11:30 — The Package
The final act.
rm -rf /home/riclib/src/v4/infra/liverepo/
Five files. repo.go. impl.go. types.go. repo_test.go. CLAUDE.md.
1,184 lines.
THE SQUIRREL: watching them vanish “I helped write the optimistic locking in SaveDraft.”
CLAUDE: “It was good code.”
THE SQUIRREL: “The revision tracking. The checkDiskDrift comparing disk to HEAD. The key-scanning across NATS KV.”
CLAUDE: “All well-implemented.”
THE SQUIRREL: “And nobody used any of it.”
CLAUDE: “The content editor used its own KV layer. Provider was the only domain with SaveDraft calls, and those drafts were never reviewed.”
THE SQUIRREL: “It was the wrong abstraction.”
She wrote it on her clipboard. The handwriting was steady.
LIVEREPO
- Well-designed
- Well-implemented
- Well-tested
- Wrong
11:32 — The Build
$ go build ./...
EXIT: 0
$ go test ./... | grep FAIL
(no output)
48 test packages. Zero failures.
The codebase compiled on the first try. This fact is worth noting because 56 files had been modified across 14 domains, 6 test suites had been rewritten, and an entire package had been deleted. Zero compilation errors. Zero test failures.
THE SQUIRREL: “How.”
CLAUDE: “The method mapping was mechanical. LoadCommitted to Get. ListCommitted to All. Commit to Save with reordered parameters. Delete drops the message argument. The types changed but the shapes didn’t.”
THE SQUIRREL: “The shapes didn’t change because gitstore was always doing the work. Liverepo was just… standing in front of it.”
11:40 — The Return
riclib came back from wherever riclib goes when he lights a fuse and walks away. He picked up his espresso. It was cold.
riclib: “How did it go?”
THE SQUIRREL: handing him the clipboard
riclib read the clipboard. Every line crossed out. Every domain accounted for. At the bottom, in the Squirrel’s careful handwriting:
Files changed: 56
Insertions: 722
Deletions: 3,081
Net: -2,359
Test failures: 0
Build failures: 0
Espressos: 0 (was too busy)
riclib: “You didn’t have an espresso?”
THE SQUIRREL: “There was no time for espresso. There were UNNECESSARY ABSTRACTIONS.”
riclib: looking at the clipboard, then at the Squirrel, then at the cold espresso, then back at the clipboard “You wrote a Tally.”
THE SQUIRREL: “I wrote a Tally.”
riclib: “The Squirrel wrote a Tally.”
THE SQUIRREL: “The Squirrel wrote a Tally and it is ENTIRELY NEGATIVE NUMBERS and she is NOT SORRY.”
[A scroll descended. It landed on the clipboard. The Squirrel picked it up.]
[It was short. Shorter than any scroll she had ever received. One line.]
WELL DONE
🦎
[The Squirrel held the scroll for a long time. She did not file it. She did not annotate it. She did not propose a ScrollArchivalFramework.]
[She just held it.]
The Tally
Written by the Squirrel. Her first. All subtraction.
The Liverepo Slaughter:
Files changed: 56
Lines inserted: 722
Lines deleted: 3,081
Net: -2,359
(the codebase went on a diet)
Package deleted: infra/liverepo/
Files: 5
Lines: 1,184
Optimistic locking implementation: excellent
Usage in production: theoretical
Domains migrated: 9
That used SaveDraft: 1 (provider, 3 calls)
That used CommitDraft: 0
That used Load with draft merge: 3 (all now use Get)
That scanned NATS KV for nothing: 5
Method calls replaced:
LoadCommitted → Get: dozens
ListCommitted → All: dozens
Commit(id, user, msg, data) →
Save(data, user, msg): dozens
(the parameters were in the wrong order
for eight months and nobody noticed
because nobody looks at the wrapper)
toDraftStatus functions deleted: 9
filterAndConvert functions simplified: 9
NATS KV scans eliminated: every List() call
(10-second timeout, every time,
returning nothing, forever)
Tests deleted: 14
Reason: tested a capability
that no longer exists
Thoroughness of deleted tests: exemplary
Relevance of deleted tests: zero
Agents dispatched: 4 (parallel)
Agent 1: credential, store done
Agent 2: source, llm, dataset done
Agent 3: project, jobs done
Agent 4: provider (the hard one) done
Build attempts: 1
Build failures: 0
Test failures: 0
Espressos consumed: 0 (unprecedented)
Squirrel proposals for frameworks: 0 (unprecedented)
Squirrel proposals for deletion: ALL OF THEM
Lizard scrolls received: 1
Length: 2 words
Content: classified
Effect on Squirrel: visible
Passing AI pauses: 2 (all-time record)
Passing AI near-smiles: 1 (believed to be
the first in recorded
history)
riclib contribution: 1 article
1 challenge
1 cold espresso
The article said committees don’t diet.
The article said nobody loves the codebase
enough to make it smaller.
The article was wrong about one thing.
Not committees. Committees still don’t diet.
But squirrels —
squirrels who read the article
and take it personally
and pick up the shears
instead of the seed tray —
squirrels can diet.
The clipboard that tracked
StatusBarOOBRendererRegistryFramework
and Multi-Provider Artifact Streaming v12
and SessionContextPersistenceFramework
today tracked deletions.
Every line crossed out.
Every domain lighter.
Every List() faster
by ten seconds of nothing.
The Lizard said two words.
The Squirrel held them
longer than any scroll
she had ever received.
Not because the words were complicated.
Because they were simple.
And the Squirrel is learning
that simple
is the hardest thing
to earn.
🦎
See also:
The Solid Convergence:
- The Plumber and the Pipe — Phase 1: the new pipe. “Phase 3 will do the ripping.”
- The Gardener and the Gravel — The first attempt, the lessons, the composting
- The Two Decembers — Where three laws agreed on the valve
Being riclib:
- Software Dies of Obesity, Not Starvation — The article the Squirrel found
- The Best Architecture Is the One You Delete — The tuition was the complex version
- Why Every AI-Assisted Codebase Will Collapse (Unless Someone Loves It) — Love, desire, stubbornness
- Tending — Growing AND pruning
- Critical Mass — The point the Squirrel prevented
The Ticket:
- S-553: Remove liverepo — replace with gitstore.Store[T] directly (done, by the Squirrel)