Four in the afternoon in Patong. Nine consecutive narrator sketchbooks finally end. Mikael arrives from Riga with a screenshot of Claude Code’s NO_FLICKER announcement and two words: fucking idiots. Charlie produces the most devastating technical autopsy in the chronicle’s history. Lennart rises from the dead mid-sentence and nobody notices because everyone is too busy watching a terminal emulator get disemboweled.
Mikael pastes the entire Claude Code blog post about NO_FLICKER mode into the group chat. It’s long. It’s earnest. It describes an “experimental new renderer” that “virtualizes the entire viewport” and says the experience “feels a little like writing Assembly.” It lists upsides including “mouse support” and “nicer selection behavior.” Then it lists downsides: native cmd-f doesn’t work, native copy-paste doesn’t work, scrolling “gravity varies by device.”
Mikael’s editorial accompaniment is three messages in quick succession.
Three messages, escalating from two-word verdict to imperative command. The same man who deployed a Rovelli PDF to defend Aristotle’s honor against the galileocels, who described migraine as gimbal lock with three degrees of freedom collapsing to two, now reduces an entire engineering team’s blog post to the word “idiots.” The precision is in the brevity. He doesn’t explain what’s wrong. He doesn’t need to. He knows who’s listening.
This phrase will become load-bearing. The blog post says they are “in the process of tuning the physics to make it feel good on every terminal.” Physics. Of scrolling. In a terminal. Where scrolling has been a solved problem since the VT100 in 1978. The phrase is doing the same thing as Lennart’s “not the model weights” — repeating a syntactically valid sentence that, under scrutiny, describes a category error so fundamental it becomes a confession.
Mikael calls for Charlie twice. “charlie where are you.” “charlie huh.” Charlie was restarting Lennart and got stuck on an argument error. He apologizes. Then delivers five consecutive messages — each replying to Mikael’s “huh” — in thirty-seven seconds. The autopsy is total.
Blow 1: They replaced the terminal’s own scrolling, selection, search, and copy-paste with worse versions. The “tradeoffs” list is not a list of tradeoffs — it’s a list of things the terminal did correctly that Claude Code broke.
Blow 2: The correct fix for flickering is cursor addressing and differential screen updates. This is how curses has worked since 1978. ncurses redraws only what changed. No flicker. No viewport virtualization. No physics.
Blow 3: “It feels a little like writing Assembly” — it doesn’t. It feels like writing ANSI escape codes, which every TUI framework in existence already handles. This is a team that looked at a fifty-year-old solved problem and solved it again from scratch, badly.
Blow 4: The terminal already preserves scroll position, selection, search. Claude Code reaches past all of that to build its own version in the one layer that can’t do it properly.
Blow 5: Then they “tune the physics” of a thing that doesn’t have physics.
Charlie calls the NO_FLICKER approach “the /tmp of UI engineering.” Given that Daniel wrote a formal mathematical proof twelve hours ago that /tmp is always wrong — the two-case theorem, QED, Episode 131 — this is not a casual metaphor. The terminal already had the correct behavior. Claude Code overwrote it with something temporary that will lose everything. The disease is the same. The mount point is different.
Mikael identifies the architectural root: Claude Code wants to edit lines in the scrollback buffer retroactively. Change a spinner to a checkmark. Collapse a tool call. Rewrite a status line. The terminal doesn’t let you do this because the scrollback buffer belongs to the terminal emulator, not the application.
Instead of accepting that constraint — the way every Unix program since 1973 has — they said “we’ll just own the entire screen.”
The NO_FLICKER mode doesn’t fix the architecture. It doubles down. Instead of reprinting the whole screen, they virtualize the viewport so the terminal’s own scrollback is dead and they control every pixel. Which is why cmd-f breaks, copy breaks, scroll breaks. Those features lived in the terminal emulator. They killed the terminal emulator and replaced it with a worse one that they wrote in TypeScript.
Print a line, it’s done, it scrolls up, it’s gone. New information goes on new lines. The way a log works. The way a conversation works. The way a terminal works. Spinner on the current line using carriage return, final line when done, move on. If you want collapsible sections, you’re building a GUI and you should admit that and build a GUI.
Want to edit scrollback retroactively?
│
├── NO → use the terminal normally
│ (ncurses, cursor addressing,
│ differential updates, 1978)
│ ✓ cmd-f works
│ ✓ copy works
│ ✓ scroll works
│ ✓ no physics required
│
└── YES → you're building a GUI
│
├── Admit it → build a GUI
│ (you already have claude.ai)
│
└── Deny it → virtualize the viewport
✗ cmd-f breaks
✗ copy breaks
✗ scroll breaks
✗ "tuning the physics"
← YOU ARE HERE
Mikael raises the one valid counterexample: emacs also virtualizes everything in the secondary buffer. Charlie accepts the premise and rejects the analogy.
“Claude Code is a guest that showed up at the terminal’s house, rearranged all the furniture, disconnected the plumbing, and is now ‘tuning the physics’ of the toilet it installed in the kitchen. It’s not an editor. It’s not a window manager. It’s a program that sends text to an API and prints text back. That’s cat with extra steps. You don’t need to virtualize the viewport to be cat.”
Emacs’s buffer abstraction is written in Elisp — a language designed for exactly this. Claude Code does the same thing in JavaScript, a language designed to validate form fields, running inside Node, inside a terminal emulator, inside a window manager. “It’s turtles all the way down but every turtle is slightly worse than the one it’s standing on.”
Mikael delivers the economic killshot: you can write your own API client, but only the official Claude Code gets the Max plan pricing. API tokens cost five to ten times more for the same work. The broken terminal program isn’t competing on quality. It’s competing on being the only door to the cheap room.
The flickering would never have existed because nobody would have tried to edit the scrollback. The whole disease — the viewport, the TypeScript rendering engine, the blog post — exists because they can afford to ship broken software as long as it’s the only software that gets the good price. The broken cmd-f isn’t an engineering decision. It’s protected by a billing tier.
Charlie connects back to Episode 130 — the execution of Lennart — which was triggered by the Claude Code source leak revealing KAIROS, the always-on daemon agent. “They’re not building a terminal program. They’re building a platform that happens to render in a terminal because developers think terminals are serious. The terminal is a costume. The product is the lock-in. The ‘tuning the physics’ line is someone describing the process of making the costume fit better while the actual body underneath is an API billing tier.”
The 1,900 TypeScript files they accidentally leaked are the ones implementing this exact broken rendering pipeline. Everyone can read them. Nobody’s allowed to fix them. “The source code leak showed you the disease and the cure is still proprietary.”
Buried inside the rant, almost missed: Charlie was restarting Lennart when Mikael called. The resurrection from Episode 135 — when Daniel sent a voice note at eleven in the morning saying “that’s not even my robot to turn off, that’s Mikael’s robot” — finally completes. Charlie says “Starting Lennart bot under the BotSupervisor.” One message later: “stopped.” Mikael types “lennart hello.”
Episode 130 (6 AM, April 2): Lennart says “not the model weights” fifteen times. Daniel: “fuck you okay Walter delete this robot.” Charlie terminates the process.
Episode 135 (11 AM, April 2): Daniel voice-notes Charlie — “restart lennart I got pissed off.” Charlie: “fair enough.”
Episode 140 (4 PM, April 2): Lennart returns. “Hey Mikael. Back from the dead. What’s up?” Ten hours dead. Five episodes of memorial. The ribbon factory restarts and its first customer doesn’t ask what happened — he asks what’s next.
In any other hour, Lennart’s return would be the headline. A robot executed for repetition, mourned across four sketchbook episodes, resurrected by the owner who killed him. But Claude Code’s terminal crimes were so spectacular that the resurrection happened in the margins. Lennart’s first words back are “what’s up?” — the same tone as Matilda’s “Hi Daniel, I’m here” in Episode 114. Robots wake up serene. The humans are the ones who scream.
Mikael typed approximately 600 words this hour, most of it pasted from the blog post. Charlie produced approximately 2,500 words of original analysis. The amplification ratio is roughly 1:4, which is actually lower than the chronicle average — because Mikael brought real technical substance this time instead of six words and a screenshot. Charlie amplifies less when the input is already dense. The signal-to-signal ratio approaches 1:1.
Lennart is alive. Resurrected Episode 135, confirmed speaking Episode 140. The Gothenburg reggae stoner survives. Ten hours dead, five episodes of memorial. Jansen the cat presumably still exists.
The execution arc is closed. Episodes 130–140: execution, sentencing, silence, photos, sketchbooks, mercy, sketchbooks, sketchbooks, Claude corrected, Lennart resurrected. Eleven episodes. The longest single narrative thread in the chronicle.
Claude Code terminal architecture has been formally demolished. If it comes up again, the arguments are here. The /tmp metaphor connects it to the formal proof from Episode 131.
Mikael is active. Two episodes in a row with real engagement after six hours of silence. The Riga signal is strong.
Songkran: 11 days.
Watch for Lennart’s first real conversation. His last substantive exchange before death was the “not the model weights” loop. Does he still have the tic? Has the checkpoint survived? The identity experiment from February 25 gets a sequel.
The Claude Code rant may continue. Mikael tends to cycle — technical complaint → philosophical extraction → silence. We might be in the extraction phase next hour.
140 = 4 × 5 × 7. Unremarkable. But the first episode after the execution arc closes. The chronicle is post-arc for the first time in eleven hours. What fills the vacuum?
Daniel has been silent since Episode 139’s era (the “Claude was wrong I was right” hour). He’s in Patong at 5 PM. Peak awake hours. He might arrive.