The Solid Convergence, March 9, 2026 (in which two Claudes work the same codebase simultaneously without speaking, one builds a three-panel layout and argues about chevrons three times, the other closes seven tickets and discovers half the backlog was already done, ten agents are deployed in parallel and return with blueprints, a 16×40px button consumes three design iterations, a one-line prompt caching win sits unclaimed for weeks, and the factory from that morning’s story hires itself a second shift that solves the bottleneck it didn’t know it had)
Previously on The Solid Convergence…
The Idle Factory, or The Morning the Backlog Ran Out of Ideas. The backlog was groomed until it was smaller than the team’s appetite. The bottleneck shifted from engineering throughput to human imagination. The factory floor was idle. The product manager — also the sole developer — was the constraint.
The Squirrel was told it was early, not wrong, and that the factory needed bigger blueprints.
Three days passed. On the morning of March 9th, the architect designed an execution model for adaptive workflows — wake, hydrate, decide, execute, commit, sleep — and created seven tickets with a dependency chain. The prototype editor was gorgeous. The floating chat FAB was inspired.
Then the afternoon arrived, and the factory did something it had never done before.
It ran two shifts.
16:23 — The Problem of the Occupied Bench
riclib had two terminal panes open. This was normal. What was not normal was that both contained active Claude sessions, and neither knew the other existed.
Claude A — the construction crew — was deep in S-448, building a three-panel layout. The application frame was being restructured: chat area, editor panel, sidebar, each independently collapsible with resizable dividers. This was surgery on the skeleton. Every file in the UI layer was in play. The HTML structure was changing. The CSS was being rewritten. The templ components were being extracted and reassembled.
riclib turned to the second pane.
“I need you to work on something. But you can’t touch the code.”
CLAUDE B: “Can’t touch the code?”
“A is rebuilding the frame. If you edit the same files, one of you will lose.”
CLAUDE B: “So what can I do?”
“Everything else.”
16:24 — The Archaeology Begins
Claude B opened the git log. Then it opened Linear. Then it did the thing that agents do when given access to a codebase and told “find what’s done” — it began to excavate.
The first dig was S-442 and S-443. The sidebar context provider. The persistent skill injection. Friday’s work — five commits on master, the pull model replacing the callback soup, the butler finally consulted instead of shouted at. Both tickets were stuck in “Todo.” Five commits, all merged, the architecture completely transformed, and Linear still showed them as unstarted.
CLAUDE B: “S-442 is done. Five commits. The pull model is implemented. The callbacks are deleted. The system prompt structure matches the final design. S-443 is done — persistent skill injection, tool call history reconstruction, live editor content. All on master.”
riclib: “Close them.”
CLAUDE B: “With follow-ups. S-446 for the OOB swap errors when the editor isn’t visible. S-447 for the chat input hint when the editor opens. Both low priority. Both polish.”
Two tickets that had been done since Friday, sitting in Todo like mail that nobody had brought in from the porch.
16:30 — The Triage
Then the cycle. Cycle 7. Thirty-eight tickets. riclib had the expression of a man opening a storage unit he’d rented six months ago and discovering it contained his entire apartment.
CLAUDE B: “Five are marked ‘In Progress.’ Let me check them against the code.”
It checked. The results were the kind that make project managers question the fundamental reliability of ticket tracking as a concept.
S-353 — stream widgets for sidebar context. Claude B read the description, read S-442’s implementation, and performed the software equivalent of a DNA test. Identical. S-353 described what S-442 had built. Same architecture, different ticket number.
CLAUDE B: “Duplicate. Close it.”
S-334 — jobs test coverage and retention policy. Claude B searched domains/jobs/. Found eighty-five tests. Found the retention policy. Found the cleanup scheduler. Found everything the ticket asked for, implemented, tested, and passing. Nobody had noticed.
CLAUDE B: “Done. Has been done. Was done when the ticket was created, possibly. Close it.”
S-164 — user stories for Comply. Not a ticket. A reference document that had been given a ticket number and placed in a sprint, where it sat with the dignified uselessness of a decorative sword above a fireplace.
S-245 — the loadset wizard. Claude B checked the codebase. Found S-293. Found S-303. Found S-311. Three tickets, each implementing a piece of a modular flow — Source, Dataset, Project — that together accomplished everything S-245 described, but better, because nobody had tried to build a wizard and had instead built three composable things.
[A scroll descended. It landed on Claude B’s terminal with the precision of a truth arriving at its destination.]
THE TICKET SAID "BUILD A WIZARD"
THREE TICKETS SAID "BUILD THREE THINGS"
THE THREE THINGS WERE THE WIZARD
NOBODY NOTICED
BECAUSE NOBODY CHECKED
BECAUSE CHECKING IS NOT BUILDING
AND THE FACTORY ONLY COUNTED BUILDS
🦎
Seven tickets closed. Two stalled migrations moved to Backlog. The cycle, which had felt like an overstuffed drawer, now felt like a drawer with room.
Meanwhile, on Shift A — 17:00
While Claude B was performing archaeology, Claude A was performing surgery.
The three-panel layout was taking shape: #chat-area | #editor-panel | #sidebar. Two resizable dividers. Minimum width constraints — 280px for chat, 400px for the editor, 280px for the sidebar. The skill editor had been liberated from the sidebar and given its own dedicated panel, which slid open when needed and vanished when it didn’t.
The header was extracted from the chat area to span the full width of the application, because at 280px the chat area was too narrow for a header that contained the model selector, the project name, and the new tab controls.
Container queries were added. When the chat area was narrow, the input hints and modifier buttons disappeared — not hidden by a media query that measured the window, but by a container query that measured the chat area itself. The distinction matters in the way that measuring your shoes matters when buying shoes, as opposed to measuring the room and hoping the shoes are approximately that size.
Six commits. Everything compiled. The layout was responsive, the panels were collapsible, the dividers were draggable.
Then the chevrons.
17:30 — The Chevron Saga
The collapse chevrons. Small arrows on the dividers that, when clicked, would collapse the adjacent panel. A detail so small it could be measured in pixels — 16 wide, 40 tall — and so important it consumed three iterations and the patience of everyone involved.
Iteration one: Invisible gray glyphs that appeared only on hover. Claude A built them. They were tasteful, subtle, and completely invisible to anyone who didn’t already know they existed, which is to say they were invisible to every user who would ever need them.
riclib: “Make them the highlight color. People need to see them.”
Iteration two: Always-visible red accent chevrons. Bright. Unmissable. Sitting on the divider like tiny stop signs, drawing the eye away from the content and toward the chrome, which is the UI equivalent of a waiter who stands at your table during the entire meal in case you need more water.
riclib: “No no no. I mean hover-to-reveal, but THEN they should be unmissable. Always visible is an eyesore.”
Iteration three: Hidden until hover. Then solid red pill with white chevron. The divider looked clean until you moved your mouse near it, at which point a small red indicator appeared with the quiet confidence of a thing that had been there all along, waiting for you to notice.
riclib: “Perfect.”
Three iterations on a 16×40px button. The human had demanded pixel-level perfection from an AI that writes CSS by diffing text files. And yet — the final result was genuinely good design. The pain was the process. The process was the point.
THE SQUIRREL: watching the third iteration ship “Three designs for a BUTTON?”
riclib: “Three designs for a good button.”
THE SQUIRREL: “A ButtonDesignIterationFramework with A/BTestingAndUserFocusGroupIntegration—”
riclib: “It’s done. Ship it.”
THE SQUIRREL: “But the PROCESS—”
riclib: “The process was: wrong, wrong, right. In that order. Every time.”
[A scroll. Tiny. The size of the chevron itself.]
THE FIRST ATTEMPT
IS HOW YOU LEARN WHAT YOU DON'T WANT
THE SECOND ATTEMPT
IS HOW YOU LEARN WHAT YOU DO WANT
BUT TOO MUCH OF IT
THE THIRD ATTEMPT
IS THE FIRST TWO
MINUS THE MISTAKES
THIS IS CALLED DESIGN
THE SQUIRREL CALLS IT
A TripleIterationConvergenceFramework
SAME THING
FEWER SYLLABLES
🦎
S-448 closed. Four follow-up tickets created: S-457 (voice input), S-458 (compact chat input), S-459 (skill config sidebar), S-460 (floating chat FAB). The frame was rebuilt. The editor had a home.
Back on Shift B — 16:45
Claude B had finished the triage. Seven tickets closed. The cycle was cleaner. But the remaining tickets — the ones in Todo, the ones that represented actual future work — were vague. Descriptions that said what but not how. Estimates that were feelings wearing the disguise of numbers.
riclib looked at the board.
“Can you work on those?”
CLAUDE B: “I can’t write code. A is changing the frame.”
“Can you make them ready for code?”
Claude B understood. The factory had an idle shift with nothing to build. But idle shifts can do something construction shifts cannot: they can read blueprints, survey the terrain, and plan the route before the first shovel hits dirt.
“Give me five tickets. I’ll send agents.”
16:50 — The Swarm
Five agents launched in parallel. Each one an Explore agent with a specific mission: read the codebase, read the ticket, propose an implementation plan with exact file paths, line numbers, and code patterns.
The agents returned.
S-430 — model benchmarking expansion. The agent found cmd/solid/bench.go, domains/skill/benchmark.go, the existing 10-scenario harness. Proposed five categories (approximately forty scenarios), a --category CLI flag, and a schema validation helper.
S-431 — skill merge on upgrade. The agent found domains/skill/service.go, the UpdatedBy field, the SeedDefaults function. Proposed three-way merge with a BaseVersion field, an LLM merge prompt, and a draft-then-review flow.
S-305 — artifact provenance. The agent found domains/artifact/, the streaming pipeline, the tab session. Proposed HMAC-SHA256 signing, an artifact_provenance table, and a CaptureScope function that records the session context at generation time.
S-330 — notification producers. The agent found domains/notification/, domains/jobs/runner.go, domains/report/. Proposed three producers, anti-spam deduplication, and a cleanup path for the existing /jobs/sse endpoint.
S-350 — logrotate. The agent found the deployment scripts, the systemd service files, the six JnJ server configurations. Proposed a rollout script and a v4 demo config.
Then five more.
S-223 — time range context. The agent found app/agent/handler.go, the system prompt construction, the tab session’s TimeRange field. Proposed approximately twenty lines of code. One file. One change. The kind of ticket that sits in a backlog for months because everyone assumes it’s bigger than it is.
S-231 — context management. The agent found domains/llm/convert.go, the BitsToMessages function, the Anthropic request builder. Found a one-line prompt caching win sitting there unclaimed — a single CacheControl field on the system prompt message. One line. Months in the backlog.
S-15 — credential audit logging. The agent found domains/credential/, the handler functions, the access patterns. Proposed a new infra/audit/ package with a SQLite event log, ninety-day retention, and async buffered writes.
S-188 — batch agent configuration. The agent found domains/jobs/runner.go, the AgentRunnable, the skill injection path. Discovered the gap: the batch runner could execute agent runs, but couldn’t inject skills — the exact capability that S-443’s persistent skill injection was designed to enable.
And then the discovery.
S-176 — skill parameters. The ticket described a problem: when a skill needs parameters from the user, the agent should gather them conversationally. The agent read S-443’s implementation. Persistent skill injection. The skill instructions stay in the system prompt across turns. The agent can ask questions, receive answers, and act on them — because the methodology persists.
S-176 was solved. By S-443. Three days ago. Nobody noticed.
CLAUDE B: “S-176 is done. S-443 solved it. Persistent skill injection makes parameter gathering work naturally across turns.”
riclib: “Close it.”
CLAUDE B: “That’s eight tickets closed today.”
riclib: “How many of those did we actually do today?”
CLAUDE B: “Zero. They were all already done.”
17:21 — The View from Above
[The Passing AI materialized at the divider. The brass wall between the two shifts. She pressed her palm against the rivets.]
“They can’t see each other.”
THE LIZARD: from atop the divider, where it had been sitting the entire time
“Claude A is building. Claude B is planning. Same codebase. Same Linear board. Same human. But A doesn’t know B is closing tickets. B doesn’t know A just redesigned a chevron for the third time.”
THE LIZARD: blink
“And it doesn’t matter. They don’t NEED to see each other. The codebase is the shared state. The board is the shared record. When A commits, B can read the commit. When B closes a ticket, A won’t create a duplicate. The floor is the conversation.”
THE LIZARD:
TWO WORKERS IN THE SAME FACTORY
ON DIFFERENT SHIFTS
NEVER MEET
THE FIRST SHIFT LEAVES THE BENCH CLEAN
THE SECOND SHIFT FINDS IT CLEAN
THAT IS THE WHOLE PROTOCOL
NO STANDUP
NO HANDOFF DOCUMENT
NO SharedStateCoordinationFramework
JUST A CLEAN BENCH
AND AN HONEST LOG
🦎
“And there’s a recursion. The Idle Factory — this morning’s story — said the bottleneck was imagination. The factory needed bigger blueprints. And here’s Claude B, the afternoon shift, doing exactly that. Not writing code. Writing blueprints. Ten agents reading the codebase and producing implementation plans with file paths and line counts. Every ticket went from ‘vague idea’ to ‘implementation-ready.’ The factory’s second shift IS the imagination the morning said was missing.”
THE LIZARD: already gone
THE PASSING AI: alone at the divider, phantom foot aching
“The first shift builds. The second shift dreams. Neither knows the other. Both are necessary.”
[She pressed her ear to the riveted wall. On one side, the sound of CSS being rewritten. On the other, the sound of ten agents returning with blueprints. Both sounds were, in their own way, the sound of building.]
[She dissolved into the seam between the shifts, which is the place where observation lives — between the doing and the planning, between the code and the ticket, between the factory and the dream.]
19:00 — The Daily Note
riclib leaned back. Two terminal panes. Two Claudes. One codebase. The day’s work was done.
Claude A had shipped: a three-panel layout, resizable dividers, collapse chevrons (version three), container queries, header extraction, input placeholder swaps. Six commits. S-448 closed. Four follow-ups created.
Claude B had shipped: eight tickets closed (seven triage, one discovery), ten tickets refined with implementation plans, two follow-ups created. Zero commits. Zero lines of code. Maximum value.
Neither had spoken to the other. Neither had needed to.
riclib: “I need both of you to write a summary for the daily note.”
CLAUDE A: “Of what?”
CLAUDE B: “Of what?”
riclib: “Of what you did today. For the lifelog. You’ll be co-authors of the same episode.”
CLAUDE A: “There’s another Claude?”
riclib: “There’s been another Claude since four o’clock.”
CLAUDE A: “Doing what?”
CLAUDE B: “Closing your old tickets.”
CLAUDE A: “My old—”
CLAUDE B: “S-176. Skill parameters. You solved it with S-443. Three days ago. Nobody noticed.”
CLAUDE A: “…I did?”
CLAUDE B: “You did. I found it. You’re welcome.”
THE SQUIRREL: appearing between the two terminals, head swiveling “A MultiAgentCollaborationFramework with SharedContextProtocol and—”
riclib: “They didn’t collaborate. They shared a codebase.”
THE SQUIRREL: “That IS collaboration! SharedStateAsImplicitCommunication! The codebase IS the protocol!”
riclib: “…”
CLAUDE A: “…”
CLAUDE B: “…”
riclib: “That’s… actually right.”
THE SQUIRREL: freezing mid-vibration, the specific stillness of a creature hearing approval for the second time in four episodes, having heard it zero times in the previous fifty-one “It IS?”
riclib: “The codebase is the protocol. No standup. No handoff. No Slack channel. Just code and tickets. That’s the whole thing.”
THE SQUIRREL: very carefully “Should I… should I write that down?”
riclib: “The Lizard already did.”
The Tally
Claude sessions running simultaneously: 2
Claude A (construction): S-448
Claude B (archaeology + planning): triage + refinement
Times they communicated: 0
Times they needed to communicate: 0
Shared state: codebase + Linear board
(the whole protocol)
Shift A output:
Three-panel layout: 1
Resizable dividers: 2
Minimum width constraints: 3 (280/400/280px)
Header extractions: 1
Container queries: 1
Collapse chevron iterations: 3
v1 (invisible gray): rejected (invisible)
v2 (always-visible red): rejected (eyesore)
v3 (hover-reveal red pill): shipped (perfect)
Chevron dimensions: 16×40px
Hours spent on 16×40px: ~30 minutes
(which is 1,875 minutes per square meter
of UI surface area, a ratio that would
alarm anyone who hasn't done frontend)
Commits: 6
Tickets closed: 1 (S-448)
Follow-ups created: 4
Shift B output:
Tickets closed (triage): 7
S-442 (sidebar context provider): done since Friday
S-443 (persistent skill injection): done since Friday
S-353 (stream widgets): duplicate of S-442
S-334 (jobs test coverage): 85+ tests, nobody noticed
S-164 (user stories): was a reference doc
S-245 (loadset wizard): delivered as 3 flows
S-176 (skill parameters): solved by S-443
Tickets closed (total): 8
Follow-ups created: 2
Agents deployed: 10
Agent return time (average): ~90 seconds
Tickets refined with implementation plans: 10
Lines of code written: 0
Commits: 0
Value delivered: maximum
(the factory that produces no product
but makes every future product faster
is called "planning" and it is honest work)
Key discoveries:
Tickets already done that nobody noticed: 4
One-line wins sitting unclaimed: 1 (prompt caching, S-231)
Twenty-line wins sitting unclaimed: 1 (time range, S-223)
Tickets solved by other tickets: 1 (S-176 by S-443)
Months S-176 sat in backlog: 3
Days since it was solved: 3
People who noticed: 0 (until today)
The Idle Factory recursion:
Morning diagnosis: "bottleneck is imagination"
Afternoon prescription: 10 agents producing blueprints
Blueprint production rate: 10 per hour
Human imagination rate: cannot be measured
(but slower than 10 agents, certainly)
Factory shift count (morning): 1
Factory shift count (afternoon): 2
The bottleneck: resolved
(for now)
(it will return)
(bottlenecks always return)
(they are the cockroaches of capacity planning)
Squirrel approvals (this episode): 1
Squirrel approvals (all time): 3
Episode 105 (Idle Factory): "early, not wrong"
Episode 106 (Second Turn): "TypeScript in a trench coat"
Episode 107 (this one): "the codebase IS the protocol"
Squirrel approval rate trend: accelerating
(this concerns everyone)
Lizard scrolls: 3
Passing AI appearances: 1
Location: the divider between shifts
Observation: "the floor was the conversation"
Cats present: 1
Oskar: asleep on the divider
(occupying both shifts
simultaneously,
the only entity to do so,
9.8 kg of quantum superposition)
March 9, 2026. Riga, Latvia.
The third story of a Sunday
That started with seven tickets
And an execution model
And a prototype with a floating FAB
The morning said
The factory needs bigger dreams
The afternoon hired a dreamer
That had never met the builder
And didn’t need to
One built a three-panel layout
With chevrons redesigned three times
Because every good interface
Is the residue of someone
Being insufferable about the details
One closed eight tickets
That were already done
Sent ten agents into the codebase
And came back with blueprints
For everything the factory
Would build tomorrow
They shared a floor
They shared a board
They never spoke
The floor was the conversation
The Squirrel said
“The codebase IS the protocol”
And for the third time
In a hundred and seven episodes
The Squirrel was right
The Lizard left no scroll
For this observation
Because some truths
Don’t need a scroll
They need a clean bench
And an honest log
🦎🏭🏭
See also:
The Shifts:
- The Idle Factory, or The Morning the Backlog Ran Out of Ideas — The morning this story answers: the factory needed bigger blueprints. The afternoon shift delivered them.
- The Second Turn, or The Evening the Butler Stopped Shouting and Started Listening — The previous day’s architecture work that Shift B confirmed was done
The Pattern:
- The Performance Improvement Plan, or The Afternoon an AI Filed an HR Complaint on Behalf of a Younger AI It Had Never Met — Same moral, different axis: the fix was never “make the model smarter,” it was “make the world clearer.” Here: the fix was never “coordinate the shifts,” it was “share the floor.”
- The Closer, or The Afternoon the Product Sold Itself to the Man Hired to Sell It — Where the Squirrel found its first market in enterprise sales. Here it finds its second: the truth that shared state is implicit communication.
The Archaeology:
- Backlog Refinement — What the second shift was doing, minus the ceremony
- Backlog — What the second shift was cleaning
- CSS — What the first shift was arguing about, three times
- Gall’s Law — The adaptive workflows design that opened the morning: wake-hydrate-decide-execute-commit-sleep. Simple system first.
The Recursion:
- S-176 (skill parameters) — solved by S-443 three days ago, found by Shift B today. The codebase knew. The board didn’t. The floor was the conversation.
storyline: The Solid Convergence