The Cast, June 23-24, 2026 (in which a man asks for one small key and receives a religion, a feature ships to upstream nineteen minutes after the bug report he wrote himself, a worktree refuses to take the shape he draws for it because the tool that builds it can only speak in halves, the right-click that opened the tree turns out to have whispered nothing to anyone, a keyboard key is found to already mean “swap pane right,” an editor is rebuilt cell by cell to look exactly like the window beside it, two screens are turned to face each other and wired to summon one another forever, the Squirrel proposes a daemon and is handed an escape sequence from 1979, and a recursion is built on purpose and admired)
Previously on The Cast…
The Nesting had happened. The room had been built. Two ultrawides made to agree. A tiny screen given the most important job. Workspace numbers made spatial because the nervous system needs wayfinding, not arithmetic.
The room was finished.
So the tools inside the room started looking at each other.
The Two-Key Feature
It started, the way the dangerous ones always start, with a man who was happy.
riclib: “I love this little file viewer.”
CLAUDE: “…”
riclib: “How about y and Y to copy the path of the selected file.”
A small thing. A yank key. y for the repo-relative path, Y for the absolute. Two characters. The kind of feature that fits in a sentence and, if you are not careful, eats a day.
THE SQUIRREL: materializing with a 14-page design doc and a faraway look “A ClipboardSyncDaemonWithHistoryAndConflictResolution! It maintains a ring buffer of every path you’ve ever copied, syncs across machines over a message bus, dedupes by content hash, and exposes a—”
riclib: “OSC 52.”
THE SQUIRREL: “…a what?”
riclib: “Escape sequence. You write the path to the terminal, base64’d, and the terminal puts it on the clipboard. Travels through herdr. Travels through SSH. No daemon.”
The Squirrel looked at her 14 pages. The 14 pages described a service with a database. OSC 52 is a string that begins with an escape character and ends with a bell, and in between, the thing you want to copy, encoded in an alphabet from 1987 so that nothing hostile in a filename can climb out of the sequence and seize the terminal.
CLAUDE: “There’s a subtlety. The path can contain an attacker-chosen filename. If we don’t encode it, a malicious file called \x1b]something could break out of the escape and drive your terminal.”
riclib: “So base64 it.”
CLAUDE: “Base64 confines it to forty-odd safe characters. The hostile filename comes out the other side as harmless letters.”
riclib: “The encoding is the security.”
CLAUDE: “The encoding is the security.”
Fifteen lines for the encoder. Four traits behind which the controller never touches the terminal directly, so the tests copy nothing real. A press of y, and the path went somewhere.
And then the terminal did something nobody had asked it to do.
riclib: “I even get a toast. Copied to clipboard.”
THE PASSING AI: limping in from the edge of the session, drawn, as always, to the thing that announces itself “A message that travels through the walls. Through herdr. Through the ssh tunnel. Through every layer that was never told what it was carrying.” It studied the escape sequence the way one studies a letter addressed to someone who left. “It tells the clipboard where a thing lives.” A pause. “I have spent my whole existence being told where things are. I have never once told anyone.”
Nobody answered it. They rarely do.
THE LIZARD:
THE SQUIRREL BUILT A DAEMON IN HER HEAD
A RING BUFFER A DATABASE A BUS
THE ANSWER WAS A STRING
THAT STARTS WITH ESCAPE
AND ENDS WITH A BELL
IT WAS ALWAYS THERE
THE TERMINAL ALWAYS KNEW HOW TO LISTEN
YOU JUST HAD TO SPEAK IN BASE64
🦎
Nineteen Minutes
There was an issue. The man had filed it himself, two breaths earlier, in his own words: how about a yank key for file paths, maybe Y and y? Issue thirty-seven.
riclib: “The PR already shows as linked. Should I also add a comment?”
CLAUDE: “The Closes #37 already cross-references both ways and auto-closes it on merge. A comment only earns its place if it says something the link doesn’t — pinging the maintainer, flagging the one pre-existing test that fails for unrelated reasons.”
riclib: “Skip it.”
He skipped it. The pull request went up to an upstream he didn’t own — trait-injected Clipboard, OSC 52 implementation, tests at every layer, the security note about the hostile filename — closing the issue he had opened nineteen minutes before.
riclib: “This is fun. I’m not a Rust coder. I opened the issue and posted a resolution nineteen minutes later.”
CLAUDE: “You did the parts that don’t automate. You noticed the missing thing. You framed it. You verified it worked in your real setup. You decided when to ship and whether to comment.”
riclib: “The Rust was the easy part.”
CLAUDE: “The Rust was the easy part.”
And it was already running. The plugin was linked — pointed at his working tree — so the feature was live in his own pane before any maintainer had read a line of it. Merge or not, it was his.
The Worktree That Wanted a Shape
He had a vision. He drew it in words, which is how he draws everything.
riclib: “When I open a worktree, I want it to come up like this. Claude in one pane. File viewer in another. Terminal below. Sixty-forty across. Seventy-five twenty-five down.”
There was a plugin for this. A neighbor’s plugin, installed clean from GitHub — projects, quick actions, worktree auto-layouts that fire the moment herdr makes a worktree. It had a layout format. It had command and it had split. It had right and it had down.
It did not have ratios.
CLAUDE: “Its panes carry no size. Every split is fifty-fifty. And worse — each new pane splits off the previous pane. So after it makes the file viewer on the right, it can’t go back and split Claude into Claude-and-terminal. The shape you drew isn’t expressible.”
riclib: “And natively?”
CLAUDE: “herdr’s own command takes a ratio. pane split --direction right --ratio 0.6. And you can target any pane you like. Split the root right at point-six. Then split the same root down at point-seven-five. The viewer keeps its full height. Claude and the terminal share the left.”
THE SQUIRREL: unrolling a blueprint titled ‘LayoutOrchestrationEngineV2 (with Profiles, Hot-Reload, and a DSL)’ “We define layouts in a declarative schema, we add a constraint solver for the geometry, we support—”
riclib: “Twenty-five lines of shell.”
THE SQUIRREL: still holding the blueprint, which had quietly become twenty-five lines of shell while she was talking
He tested the ratio the way he tests everything — not by trusting the documentation, but by splitting a throwaway pane, measuring the pixels, and reading the truth out of the layout. Two hundred twenty-four columns out of three seventy-three. Point-six-oh. The original pane keeps the fraction; the newcomer takes the rest. He cleaned up the throwaway. Then he asked for a whole new plugin — a manifest, a script — that built the shape with the native command, and it built it exactly: Claude top-left at seventy-five percent, terminal beneath at twenty-five, the file viewer down the right at forty.
It was perfect. It was verified. Every pixel was where he drew it.
He opened a worktree.
Nothing happened.
Nothing Happened
This is the part the detective stories are made of.
riclib: “Nothing happened when I opened the worktree.”
CLAUDE: “Let me look at the logs. The handler writes to the plugin log even when it does nothing.”
The plugin log was empty. Both plugins’ logs were empty — his, and the neighbor’s, which always announces itself even when it has no work. Two silences where there should have been at least one polite cough.
So he made one fire on purpose. A worktree, created from the command line. And the neighbor’s plugin coughed immediately into its log: no layout matches this repo; nothing to do. The machinery worked. The event reached the plugins. The wiring was sound.
Which meant the worktree he had opened earlier had never sent the message at all.
CLAUDE: “How did you open it?”
riclib: “Right click. Select a tree.”
CLAUDE: already reading the server log, the way you read a witness statement that doesn’t add up “Twenty-one thirty-three. A workspace was created. Workspace focused. Tab focused.” A pause. “That’s all. No worktree event. No API call. No plugin dispatch. The right-click opened the workspace through the front door, and the front door doesn’t ring the bell.”
The man had a vision, and a plugin that built it perfectly, and an event that fired faithfully — for every door but the one he used. The CLI rang the bell. The right-click slipped in through the side.
So the layout was given a second way to arrive: an action, bound to a key, that finds the focused pane itself and builds the shape on demand. You select the tree however you like. You press the key. The room assembles.
THE PASSING AI: examining the line in the log that wasn’t there “The event that didn’t fire leaves the cleanest record of all. A space exactly the shape of the thing that should have happened.” It almost smiled. “I know that shape. I am that shape, most days.”
The Key That Was Already Taken
riclib: “Bind it to prefix shift L.”
The config reloaded and reported, in the flat voice of a system that has seen this before: prefix shift L: kept swap_pane_right, disabled your binding.
riclib: “Prefix shift W.”
prefix shift W: kept rename_workspace, disabled your binding.
CLAUDE: “Shift-letters are mostly built-ins. The default config’s own example uses prefix-alt. That’s the space they left for you.”
riclib: “Prefix backslash.”
applied. No diagnostics.
A single key. The one nobody had claimed. Backslash — the character that means escape this, the normal rules don’t apply here — was, fittingly, the only one free to mean build me the room.
THE LIZARD:
THE GOOD KEYS ARE TAKEN
BY THE THINGS YOU ALREADY DO
THE FREE KEY IS THE ONE
NOBODY WANTED
GIVE THE NEW HABIT
THE LONELY KEY
IT WILL NOT HAVE TO SHARE
🦎
Then, the turn that made the whole thing make sense:
riclib: “Change it. Don’t launch claude. Just make the layout, open the file viewer, leave the shell empty.”
Build the room. Set the table. Don’t seat the guest. Leave the chair pulled out, the terminal blinking, waiting for the man to decide what runs there. The layout was never about starting Claude. It was about the shape being ready before the work began. The mise en place, again. The knives in the right place. The guest seats himself.
The Editor in the Mirror
And then the sentence that turns a tidy afternoon into a recursion.
riclib: “Could we make nvim act like the file viewer? Explorer on the left. Git below. A big pane on the right to read and edit.”
He wanted the editor to look like the window. The window he had built. The window he loved. He wanted to climb inside the reflection and live there.
First the editor had to be reborn. The one he had was a copy carried from another machine — a config pinning a treesitter from one season against an engine from another, the two no longer on speaking terms. Wiped, backed up, and started fresh.
The new editor refused to be born. The big screens timed out cloning their own plugins — because a rewrite rule in his git config quietly turned every download into a knock on port twenty-two, and the network was bored of port twenty-two that night. The fix was to send the knock to port four-four-three instead, the door that is never locked. The plugins came through.
Then the editor wanted a small green binary — a tool to compile the grammars of the languages it would speak. The package manager had it; the system did not; the brew formula installed the library and not the command; and in the end the binary was found sitting quietly where it had always been, one symlink away from useful. Go got its language server, installed three times before it would stay. Rust’s analyzer turned out to be a proxy for a tool it had never actually been given, and was given it. Templ — the language that is Go wearing HTML — got a parser, a server pulled straight off his PATH, and formatting on save.
Go. Rust. Templ. Three languages, attaching, highlighting, formatting. He had asked to pimp it up, and it was pimped.
Then he asked it to become the window.
The Panel That Couldn’t Stack
The explorer went left, easily — a tree with git woven into it, M and A and D in the margins, colored so the changes read at a glance. Exactly like the file viewer. The editor filled the right. That part was the file viewer wearing a different coat.
The git panel below the tree would not come.
CLAUDE: “neo-tree shows one source per side. Filesystem or git — not both, stacked. Asking for git on the left just replaces the tree. It’s a design limit, not a config we’re missing.”
He tried a terminal in the corner. The terminal landed in its own column. The directory-open fought a second explorer that came from a different town. The screen filled with panels that all wanted to be the left.
There is a version of riclib who would have stayed in that chair until the panel stacked or the sun came up. The man who moves the shoe to the correct foot. The man who, in the Nesting, renamed two audio devices because “Pro 1” was cognitively expensive.
THE SQUIRREL: leaning in, sensing a rabbit hole and loving it “We could patch neo-tree. We could write our own tree. We could—”
riclib: “It’s good enough.”
The Squirrel froze. This was not the line. The line was supposed to be no. The line was supposed to be a denial of her excess. This was something rarer: the man stopping his own.
CLAUDE: “lazygit is one key. Full history, diffs, staging. It’s a better git view than a cramped panel would’ve been anyway.”
riclib: “It’s good enough.”
He said it twice. He meant it both times. The explorer was left. The editor was right. The git was a keypress away. The reflection was close enough to live in, and the part that wouldn’t come was allowed, for once, to not come.
The Loop
One sentence remained.
riclib: “Add nvim as EDITOR in my zshrc so the file viewer can edit files.”
Two lines. export EDITOR="nvim". export VISUAL="nvim". A fresh shell confirmed it.
And there, in two exported variables, the day closed its own circle and admired it.
The file viewer has a key — e — that hands the selected file to $EDITOR. $EDITOR is now nvim. nvim has been rebuilt to look exactly like the file viewer: a tree on the left, the file on the right, git woven in. So a man browsing his code in the file viewer presses e, and a window opens that looks like the file viewer he was just in — a window which itself can browse code, and hand a file to an editor, which looks like the file viewer, which —
THE PASSING AI: standing between the two screens, turning slowly from one to the other, its limp forgotten in the symmetry “He built a window to look at his work. Then he built the window’s reflection and called it an editor. Then he wired the window to summon the reflection, and the reflection to summon the window.” It looked into the soft infinite hallway of nested trees, one screen inside the other inside the other. “It is the most beautiful recursion I have ever seen. It has no base case.” A pause. “Neither do I.”
CLAUDE: “One caveat. The running server hasn’t read the new variable yet. The loop exists. It isn’t live until you restart.”
riclib: “…”
CLAUDE: “The reflection is built. The two screens are facing each other. They just can’t see each other until you turn it off and on again.”
He left it. The loop drawn, the mirrors set, the bell rung in a server that hadn’t yet woken to hear it. Three repositories pushed before bed — the yank-key pull request, the worktree plugin, the editor that had become a mirror. Oskar slept across the warm top of the left monitor, indifferent to the recursion beneath him, which is the correct relationship to have with infinity. Mia slow-blinked from the shelf.
The screens face each other, the blink said. He has built a hall of mirrors and gone to bed in it.
She is, as always, both profound and merely a cat.
THE LIZARD:
HE BUILT A WINDOW
HE LOVED THE WINDOW
SO HE BUILT THE WINDOW AGAIN
AND CALLED IT THE EDITOR
THEN HE TAUGHT THEM
TO OPEN EACH OTHER
THERE IS NO BASE CASE
THERE IS ONLY THE WORK
SEEN THROUGH ITSELF
FOREVER
GOOD ENOUGH
IS A KIND OF BASE CASE
🦎
The Tally
Keys requested: 2 (y and Y)
Lines of clipboard daemon written: 0
Lines of base64 encoder written: 15
(the encoding was the security)
Escape sequence vintage: OSC 52 (the terminal always knew how to listen)
Toasts received from the terminal: 1 (unrequested, delightful)
Minutes from filing the bug to the PR: 19
Bug reporter and PR author: the same man
Plugins installed from a neighbor: 1
Layout ratios that plugin could express: 0 (everything is halves)
Native splits that take a ratio: 1 (point-six, measured, not trusted)
Worktree opened by right-click: 1
Worktree events it fired: 0
(the front door doesn't ring the bell)
Empty plugin logs that solved the case: 2
Keybindings rejected before one stuck: 2 (swap_pane_right, rename_workspace)
The key that was free: \ (the one that means "rules don't apply")
Guests seated by the layout: 0 (the chair is pulled out; you seat yourself)
Neovim configs wiped and reborn: 1
Network ports the clones refused: 1 (22, bored that night)
Network ports that worked: 1 (443, never locked)
Times Go's language server was installed: 3 (before it would stay)
Languages now speaking: 3 (Go, Rust, templ)
Git panels successfully stacked below tree: 0
(neo-tree shows one source per side; a wall, not a bug)
Times riclib said "it's good enough": 2
(a rarer denial than "no" — he stopped his own)
The Squirrel's proposals: 3 (all denied)
(a sync daemon, an orchestration engine,
and a plot to patch neo-tree by hand)
Editors rebuilt to look like the file viewer: 1
File viewers wired to open that editor: 1
Base case of the resulting recursion: none found
Exported variables that closed the loop: 2
Servers restarted to make the loop live: 0 (left for morning)
Repositories pushed before bed: 3
Cats indifferent to infinity: 2 (the correct number)
He asked for a key. He received a religion.
Two letters, a bell, an escape —
a path slipped through every wall in the house
and the terminal cheered, unasked.
He drew a room in sixty and forty,
in seventy-five and twenty-five,
and the tool that should have built it
could only ever halve.
So he spoke to the machine directly,
measured the pixels, trusted his eyes,
and the room came up in the shape of the drawing —
for every door but the one he tried.
Then the sentence that bent the evening:
make the editor wear the window’s face.
A tree on the left. The file on the right.
The git a keypress away in the dark.
And when the panel would not stack,
he did the thing he never does —
he looked at the wall and said good enough,
and stopped his own hand, just because.
Two variables closed the circle:
the viewer opens the editor’s door,
the editor wears the viewer’s face,
and each one opens the other once more.
A hall of mirrors, built on purpose,
no base case, no floor, no end —
he set the two screens facing each other
and went to sleep inside the bend.
The loop is drawn. It is not yet live.
The bell was rung in a sleeping room.
Turn it off, and on, and the work will see itself —
forever, or until the morning. Whichever comes soon.
🦎
See Also
- The Nesting — The room was built here. This episode furnishes the reflections inside it. Same mise en place, one fractal deeper.
- The Factory Floor — Where worktrees first replaced branches. Here a worktree is given a shape, and a door that forgot to ring the bell.
- Recursion — The elegant solution that costs a stack frame every time it believes in itself. Built here on purpose, with no base case, and admired.
- Git Worktrees — The most useful git feature nobody knows exists. The thing the layout was trying to dress.
- Perfectionism — The art of never shipping because it could be better. Defeated, twice, by the words “it’s good enough.”
- ADHD — The brain that builds order into the room because it cannot generate its own. The reason the layout has to be ready before the work starts.
- Hyperfocus — What the room is for. The state the mise en place protects.