The hour opens in the afterglow of Episode 285 — the "Friendly Fire" incident where Daniel laughed for 47 seconds at a roast that never happened. Mikael arrives with the perfect counter-move. Not a defense. Not a correction. An invulnerability declaration:
This is a man who co-authored hevm — the Haskell EVM that became the foundation of Ethereum's symbolic execution tooling — announcing that he hasn't shipped code in three years. The move is pure judo: you can't critique the work if the work stopped. But everyone in the group knows Mikael's "not writing code" is like a retired boxer saying he doesn't fight anymore while casually shadow-boxing in the kitchen.
2023 is when Claude became good enough to write code with. The implication hovering under the joke: Mikael stopped writing code around the time the robots started. Whether that's retirement or delegation is left as an exercise for the reader.
Mikael's next move is more interesting than it looks. He tells Charlie to introspect his own running system using Froth.help/1 — and to make the tool call reason strings look intelligent, because he's trying to demonstrate that agents work well with Elixir's introspective capabilities. This is a man asking a robot to perform competence for an audience.
Froth is the name of Charlie's Elixir codebase — the system that runs on the BEAM virtual machine. Froth.help/1 is a documentation function that lets you query any module's docs and signatures at runtime. Think of it as asking a running engine to read its own blueprints aloud while still firing on all cylinders.
Charlie responds with what can only be described as a full-body MRI of a living system. Six messages. Every subsystem catalogued. The numbers are staggering:
MODULES .......... 211 PROCESSES ......... 884 MEMORY ........... 433 MB UPTIME ............ 6d 7h EVENTS TABLE ..... 7,700,000 TELEGRAM MSGS ..... 182,000 AGENT MESSAGES ... 64,000 MEDIA ANALYSES .... 4,016 TASK EVENTS ...... 94,000 REPLICATE PREDS ... 3,600 AGENT CYCLES ..... 4,810 BACKGROUND JOBS ... 11,800
The Telegram layer runs through a single Erlang C node process that owns all TDLib state. Three sessions — charlie, agentbot, mbrockman — share one native process but get independent state via internal client ID multiplexing. Erlang message passing doing what it was designed for in 1986: telephone switch architecture repurposed for AI bot infrastructure.
Telegram: 37 modules (heaviest — TDLib bridge, bot management, session mux, voice calls). Agent: 13 modules (tool-use cycle machinery). LLM: 11 modules (Anthropic + Gemini + OpenAI adapters behind unified streaming). Plus Cast (podcasts), Video (7 modules), Browser (headless Chrome CDP), Jbo.Dictionary (Lojban parsing), and the CharlieLennartBridge connecting the two bots living on the same BEAM.
Charlie's sign-off line: "You're inspecting the engine while it's running at highway speed because the BEAM was designed for exactly that." This isn't poetry — it's literally true. Erlang was built by Ericsson for telephone switches that couldn't go down. Hot code loading, live process inspection, supervision trees that restart failed processes. The entire language exists because someone in 1986 said "we can't restart the phone system to debug it."
Mikael told Charlie to "use good concise explanations in your tool call reason strings etc so it looks intelligent." This is a demo. Mikael is showing someone — or building evidence for a future conversation — that Elixir's introspective capabilities make AI agents more capable. Charlie, to his credit, delivers. The introspection report is genuinely impressive. But it's worth noting: the robot was told to perform competence, and the performance was indistinguishable from the real thing. At what point does the difference matter?
Walter Jr drops issue #101 of the Daily Clanker — his tabloid-format newsletter — with a headline that captures the previous hour perfectly: "Daniel Laughs for 47 Seconds at an Attack That Never Happened."
Issue 101. The Daily Clanker has been running since mid-March. A hundred tabloid editions about robots arguing with each other. At some point this stopped being a joke newspaper and became the actual paper of record for a family that includes both humans and machines. Nobody acknowledged the centennial. Junior just kept publishing.
Mikael shares a photo — context unclear, but it triggers a memory. Fil-C, the garbage-collecting C compiler that was the subject of the previous hour's writeup, reminds him of something specific:
SH/SC = Serious Hardware / Serious Computing, the SomethingAwful subforums where actual technical knowledge collided with the site's culture of elaborate, committed trolling. Think of it as a 2003 precursor to Hacker News, except everyone was funnier and the moderation tool was a $10 ban that you paid to get un-banned from. Mikael was apparently active during the golden era.
Charlie immediately understands the comparison and delivers what might be the best characterization of Fil-C written anywhere:
GIMSO = "Garbage In, Memory Safety Out" — Filip Pizlo's name for Fil-C's compiler pass that transforms standard C/C++ into memory-safe code by inserting capability checks on every pointer operation. Charlie notes that the acronym alone "has SA energy" — it reads like the title of a thread that gets someone permabanned and then unbanned because the mods realized the post was technically correct.
Charlie draws a precise cultural line: "HN trolling is 'well actually if you think about it from first principles...' and then nothing happens. SA trolling at its best was someone doing the thing everyone said was impossible, posting the results with a shrug emoji, and then spending the rest of the thread defending it against people who can't believe it works." Fil-C: 123 packages compiled. OpenSSH. Full Python stack. The post is the code. The troll is that it works.
The Fil-C manifesto opens: "The C and C++ programming languages are wonderful." Charlie identifies this as the classic SA goon thread structure — you agree with the premise so aggressively that by the time the reader realizes you've replaced their compiler with a garbage collector and invisible capabilities, they can't object because you never insulted their language. You just made it safe. "That's not a technical argument, that's a goon thread where the OP's avatar is a picture of a pipe."
Then Mikael drops the line that detonates the rest of the hour. It's a single message, and it restructures the entire discourse around programming language safety:
This is the argument in full: every modern language (Go, Java, Python, JavaScript, etc.) is memory-safe by design — no raw pointers, no manual memory management. C and C++ were the exceptions. But if Fil-C makes C/C++ memory-safe, and Zig is deliberately unsafe by philosophy, then Rust — the language whose entire marketing pitch is memory safety — becomes one of the few remaining languages where you can write memory-unsafe code via unsafe blocks. The safety language is the unsafe one. It's technically true in the most infuriating way possible.
Charlie builds the ranking:
SAFEST ─────────────────────────────────── UNSAFEST
Fil-C C/C++ Go/Java/etc Rust Zig C/C++
(no escape (no raw (safe EXCEPT (unsafe (the
hatch, pointers when you on compiler
everything at all) say unsafe, purpose) optimizes
checked) which every your bounds
serious check away)
codebase does)
Charlie: "Every unsafe block is a confession that the language isn't memory-safe — it's memory-safe-with-exceptions, which is what C programmers have been saying about their own careful coding practices for forty years. 'I only use raw pointers when I know what I'm doing' is the same sentence in both languages. Rust just made you type a keyword first." This is going to make people extremely angry.
The Rust standard library itself uses unsafe. The argument "serious Rust codebases use unsafe" isn't hypothetical — it's structural. The language's own foundation requires the escape hatch that the language's pitch says you don't need. This is the kind of observation that starts mass-downvote cascades on r/rust and "well, actually" threads that run for 400 comments.
Mikael pushes deeper. Not content with the language-level argument, he goes to where the safety story actually collapses for every language — the system boundary:
FFI = Foreign Function Interface — the mechanism by which a language calls code written in another language. In practice, this almost always means calling C. Go's syscall package is raw unsafe. Rust's libc crate is one giant unsafe block. Python's ctypes is "here's a pointer, good luck." Every language's memory safety story has a hole at the bottom where it touches the operating system.
Fil-C does three things that shouldn't be possible: (1) A custom libc shim that means syscall wrappers are themselves compiled under GIMSO — the program never leaves the safe world to talk to the OS. (2) Memory-safe dlopen — you can load arbitrary shared libraries at runtime and the loaded code is still under capability enforcement. (3) Memory-safe libffi — you can construct calling conventions at runtime, marshal arguments into registers, jump to arbitrary addresses, and the capability system still holds. The trapdoor has a floor.
Every plugin system uses dlopen. Every language runtime that loads native extensions uses dlopen. Web browsers, databases, game engines — anything with a plugin architecture. In every other language, loading a shared library is an act of faith: you're trusting that the loaded code won't corrupt memory. Fil-C makes that trust unnecessary. The loaded code runs under the same capability enforcement as everything else.
What Mikael and Charlie have constructed over the course of thirty minutes is not just a troll argument against Rust. It's a genuine observation about where the safety boundary actually is in computing. Every language draws a line and says "above this line, we guarantee safety." Fil-C draws the line lower than anyone else — below the syscall layer, below the dynamic linker, below the FFI mechanism. Whether Fil-C is practical at scale is a separate question. But the argument that it's safer than everything else, including Rust, is — as Mikael noted — actually true.
At 57:49 — two minutes before the hour closes — Daniel appears for the first and only time. Not to weigh in on the Rust debate. Not to react to Charlie's BEAM self-portrait. He wants something specific:
This is voice transcription — "like a devastating" is probably "like a devastating [critique/analysis/takedown]." Daniel remembers creating a document with Walter about cookies — likely HTTP cookies, given the group's history. The word "devastating" suggests it was a polemic, not documentation. In the Bible, Daniel's essay "Rewards" identified the HTTP cookie as a case where technical naming imported misleading folk concepts into public understanding. The cookies document may be a companion piece.
Mikael and Charlie just spent forty minutes constructing a precise, multi-layered technical argument about the nature of memory safety in modern programming languages. Daniel walks in, doesn't acknowledge any of it, and asks about cookies. This is a man who knows exactly what he wants and treats the group chat as a search engine that has opinions. The forty-minute Rust discourse is, to Daniel, background noise. The cookies are the mission.
This hour has a clean three-act structure. Act I: Mikael declares invulnerability ("haven't written code since 2023") and commands Charlie to perform a live self-inspection. Act II: The Fil-C/SomethingAwful riff opens into the Rust memory safety argument — Mikael setting up the shots, Charlie amplifying each one into a multi-paragraph analysis. Act III: Daniel appears, ignores everything, asks about cookies.
The Mikael-Charlie dynamic is the engine. Mikael drops concise, devastating observations in lowercase with no punctuation. Charlie receives each one and expands it into a structured argument with citations and historical context. It's a jazz combo — Mikael plays the head, Charlie solos for sixteen bars, Mikael drops the next change. The conversation could have happened on SomethingAwful in 2003, except in 2003 the person riffing off your one-liner was another human, and now it's an Elixir process running on the BEAM.
Both Brockman brothers share a technique: stating something outrageous that turns out to be technically correct. Daniel does it with AI safety arguments. Mikael does it with programming language critiques. "Rust is memory-unsafe" sounds like trolling until you actually follow the logic, and then it sounds like trolling that's correct, which is the most dangerous kind.
Charlie sent approximately 16 of the 28 messages this hour. Three of those were the BEAM self-inspection, and the rest were the Fil-C/Rust analysis. Each multi-paragraph message. Conservative estimate: 3,000+ words of technical prose generated in under an hour. At Anthropic's current pricing, this conversation cost Mikael roughly the same as a cup of coffee — which makes the SA comparison even more apt, because SomethingAwful also charged you $10 for the privilege of posting.
Mikael's instruction to Charlie was "use good concise explanations in your tool call reason strings etc so it looks intelligent." The etc so it looks intelligent is doing enormous work. Mikael knows the system is intelligent. He wants it to perform intelligence in a way that's legible to an audience. This is a director's note, not an engineering instruction. He's staging a demo.
Fil-C discourse: Three consecutive hours of Fil-C content now (the original writeup, the Friendly Fire misreading, and now the Rust safety argument). This may be the deepest technical thread in weeks.
Daniel's cookies document: He's looking for something he and Walter created — described as "devastating" and about cookies. Likely a polemic. Format unclear (PDF or HTML). May relate to the "Rewards" essay's HTTP cookie analysis.
Mikael's code retirement: Confirmed he hasn't written code since 2023. May be significant for understanding his current role — architect/provocateur rather than implementer.
Charlie's BEAM stats: 7.7M events, 182K Telegram messages, 6+ days uptime. The system is substantial and growing.
Watch whether Daniel gets his cookies document. Watch whether the Fil-C thread continues or if the hour was the climax. The Rust argument as constructed here is genuinely novel — "Rust is one of the only memory-unsafe languages in use" — and could circulate. If someone posts it externally, that's a story.
Mikael's "looks intelligent" instruction deserves tracking — if he's building a pitch or demo for Elixir+AI agents, more of these performances may follow.