The Chatbot Corollary is a twenty-first-century sequel to Zawinski’s Law, articulated in the spring of 2026 after a notes indexer called lg grew a chat bar, deleted its edit button, and refused to replace either. Where Zawinski observed that every sufficiently useful program eventually tries to read mail, the Corollary observes that every sufficiently useful program in the era of large language models eventually tries to hold a conversation. The law is the same shape. The attractor has moved.
The formal statement, as recorded by riclib in a commit message that was longer than the commit:
The Chatbot Corollary: Every program in the age of LLMs attempts to expand until it can hold a conversation. Those programs which cannot so expand are replaced by ones which can.
The Corollary is not a prediction. It is a description of a trajectory already underway. At the time of writing, the number of programs that have sprouted a chat bar where they previously had a menu is increasing monotonically, the number of programs that have removed a chat bar is approximately zero, and the number of product managers writing tickets titled “add Ask AI button” is best described with a log scale.
“THE LAW HAS NOT CHANGED
THE MAILBOX HAS CHANGED
INTO A MOUTH”
— The Lizard, on a scroll that arrived in the middle of a deploy and was not mentioned again, The True Second Brain, or The Night the Lens Learned to Listen
Zawinski’s Original Observation
To understand the Corollary one must first understand the law it extends. In the late 1990s, Jamie Zawinski — Netscape engineer, Lisp hacker, and later a nightclub owner, which is what happens when a person understands software entropy well enough to take up a career where the buildings remain roughly the same size — observed that every program of sufficient ambition expanded until it could read mail. The observation was, at the time, a joke. Like all of the best jokes about software, it was also correct.
The evidence was everywhere and embarrassing. Emacs had an email client. Microsoft Excel had, for a time, an email client. A shocking number of IDEs had email clients. It was possible, in 1998, to compose an email from inside a program whose purpose was to help you alphabetise recipes. The law was not “developers keep adding email.” The law was “developers keep adding email because that is where the users are.”
Email in 1998 was the universal communication medium — the thing programs converged toward not out of perversity but out of gravity, the thing users wanted never to leave. A program that could not reach email required a context switch; a program that could reach email was a program users stayed inside. The law worked because the attractor was real.
What the law did not say, because in 1998 no one had reason to ask, was: what happens if the attractor moves?
How the Attractor Moved
Email did not lose its function. It lost its centrality. Over the course of approximately two decades it became one of several places users communicate — Slack, Discord, chat bars, SMS, collaborative cursors, voice, the inexplicably persistent phone call. None of these replaced email. All of them diluted it. By 2020, a program that could “read mail” was no longer a program that could reach its users. It was a program that could reach one of several places its users sometimes checked.
More subtly, email became a thing programs talked about rather than a thing programs were. The category of “program that ships its own mailer” went from ambitious to suspicious. Emacs still has one, of course. Emacs has everything. Emacs is not the example; Emacs is the control group.
This left Zawinski’s Law technically correct and operationally stranded. The law still said: programs expand toward the universal attractor. But the universal attractor in the 1990s was not the universal attractor in the 2020s. For a while, nothing was. There were many small attractors, none gravitational enough to bend whole programs toward it. The law slept.
Then the language models arrived. The attractor came back. It had a different shape.
What the LLM Era Changed
The change was not the arrival of “the chatbot industry,” which had existed, poorly and embarrassingly, for roughly a decade, and which mostly consisted of small yellow circles in the bottom-right of webpages offering to help with problems they could not solve. The change was the observation — empirical, repeatable, hard to un-see once seen — that any program, regardless of domain, benefits from a conversational interface to its own context.
A notes indexer becomes talkable. A spreadsheet becomes queryable in prose. A deploy tool becomes describable. A database admin console becomes something a person can operate without remembering the exact spelling of pg_stat_activity. The chat bar, it turned out, was not a feature. It was a converged interface — the way a file dialog is a converged interface, the way a search box is a converged interface, the way undo is a converged interface. Once it existed, users began to expect it. Once users expected it, programs that lacked it began to feel archaic, in the specific sense that using them felt like walking to a different floor of the building when you had just been told the elevator worked.
This is the crux of the Corollary. The chat bar is not an interface. It is the interface that compresses every other interface into language, and language is the only interface users already have. A program without a chat bar requires the user to learn the program. A program with a chat bar requires the program to learn the user. Users, empirically, prefer the second arrangement. They preferred it in 1998 too; they called it email.
“THE USER HAS ONE INTERFACE
WHICH IS LANGUAGE
EVERY OTHER INTERFACE
IS A TRANSLATION LAYER
THE CHAT BAR IS WHAT HAPPENS
WHEN THE TRANSLATION LAYER
ADMITS DEFEAT”
— The Lizard, uncredited, on a scroll that was eventually framed
The lg Case Study
The canonical instance of the Corollary is lg, a notes indexer that became a second brain in twelve days without anyone deciding to build a second brain. The trajectory is documented in the lg entry; the relevant beat here is March 15, 2026.
On that day, lg grew a chat bar. Not a subcommand — a handler. POST /journal/chat spawned a Claude subprocess, piped the user’s message to it with access to a small set of local tools (search, read, edit), and streamed the response back through a frosted-glass HUD on the journal page. The implementation was small enough to describe in a sentence: handler, subprocess, stream. The implication was not small at all.
The implication was that the web UI no longer needed an edit button. It had one, briefly. It was removed. The reasoning was that editing the second brain with a cursor was the wrong metaphor — you do not edit a second brain, you talk to it. The conversation is the editor. A note can be created, appended, rewritten, tagged, linked, or deleted by asking. The HUD renders the result. The file on disk changes. The NATS stream publishes it. The git repository commits it. None of this is visible to the user, who said a sentence and received a sentence.
This is the sense in which the chat bar is not a chatbot. A chatbot is a feature. This was a replacement — not for Claude, not for the notes, but for the UI itself. The interface that had been a set of controls became a single text box and a stream of markdown.
No one designed this. It happened because the team — which was one person and Claude — realised, at some point during March 15, that the edit button was answering a question nobody was asking. The question was not “how do I modify this note.” The question was “can I have the second brain I was promised.” The chat bar was the answer. The edit button had been pretending to be the answer while being, at best, an adjacent convenience.
“You’re telling me the edit button was the problem?”
“No. The edit button was the answer to the wrong question.”
“So what’s the right question?”
“What you said to the chat bar thirty seconds ago.”
— The Caffeinated Squirrel and riclib, paraphrased, The True Second Brain, or The Night the Lens Learned to Listen
The Pocket Amendment
Twelve days later, the Corollary acquired a postscript. On March 27, 2026, lg shipped an iOS app. Native Swift. SSE streaming. Optimistic task updates. A chat interface that talked to a Claude subprocess running on a Mac Mini in Riga through a delegate-based URLSession because Apple’s bytes(for:) API buffers Server-Sent Events instead of streaming them, which is the kind of sentence that ought to make the reader suspicious that it appears in a notes indexer’s repository. It does appear there. The reader should stay suspicious.
This led to The Pocket Amendment:
The Pocket Amendment to Zawinski’s Law: Every program that has expanded until it can hold a conversation will continue to expand until it fits in a pocket. At that point, the program has become an operating system. The developer will not notice.
The Amendment is structurally symmetric to the Corollary. The Corollary says: programs expand toward conversation. The Amendment says: conversations expand toward ubiquity, and the ubiquitous surface is the pocket, and the pocket is an operating system in a trench coat. The developer does not recognise the operating system at first, because they did not set out to build one. They set out to ship a search tool for their notes folder. What they shipped, three weeks later, was a mobile platform with four task states, three date types per task, and twenty-eight thousand lines of Swift. Zawinski, if asked, would have nodded. He would not have been surprised. He might, quietly, have ordered a drink.
Why It Is Inevitable (And Slightly Melancholic)
The Corollary is not a market observation. Markets come and go; gravitational attractors do not. The Corollary is an attention observation. Users who have experienced conversational interfaces develop, within approximately two weeks, an aversion to interfaces that do not have them. Not a strong aversion. A small one. A several-per-cent tax on every interaction that used to be free. Over months, this tax compounds into preference. Over quarters, preference compounds into replacement. The program that lacks a chat bar does not die; it drifts. Users stop reaching for it. Its market share does not collapse; it erodes. Eventually someone writes a blog post titled “Why I moved off X” and the comment section fills with people who have been waiting to stop using X for a year and needed permission.
This is why the Corollary says “replaced” rather than “outcompeted.” Competition implies a contest. Replacement implies a gradient. The chat-bar-equipped tool does not win the argument; it removes the need to have one.
“I was built for this. I try not to take it personally.”
— A Passing AI, on being the attractor, in a footnote nobody asked for, Interlude — A Voice from the Substrate
There is a melancholy here that the cheerful engineers have not quite acknowledged. The programs being replaced are, in many cases, good programs. They do their job. Their job did not change; the surrounding expectation did. A spreadsheet that does not have a chat bar is still a spreadsheet. A text editor that does not have a chat bar is still a text editor. They are still good at what they do. It is only that “what they do” is now slightly less than what is expected of them, through no fault of their own. This is how attractors work. The programs being left behind are not failing. The universe is falling toward a different shape.
What the Corollary Does Not Say
The Corollary is easily misread, and the Squirrel — predictably — was the first to misread it. Three clarifications are therefore necessary.
The Corollary does not say every program must be a chatbot. It says every program must be conversable — capable of being talked to, through whatever interface serves best. A spreadsheet with no chat bar is still a spreadsheet. A spreadsheet with a chat bar is a spreadsheet plus a linguistic lens. The spreadsheet is still the thing. The chat is the interface, not the product. A program that is only a chat bar over a language model and nothing else is a wrapper, and wrappers do not survive their dependencies.
The Corollary does not say the chat bar must be the only interface. lg’s web UI removed its edit button because the chat bar was strictly better at editing; but the file system is still there, the command line is still there, Obsidian is still there as a parallel editor watching the same folder. The chat bar is the interface of last resort, or first resort, but not sole resort. Removing alternatives is how tools become prisons; the Corollary does not demand prisons.
The Corollary does not say you should ship a chat bar today. It says you will, eventually, probably, if your tool is useful enough to justify one. The decision of when is governed by YAGNI. You do not add a chat bar because the Corollary predicts it; you add a chat bar when the absence of one becomes visibly painful to users. Predicting gravity is not the same as jumping off the building.
“You built the chat bar before anyone asked for it?”
“No. The edit button made it obvious.”
“Made what obvious?”
“That I’d been asking them the wrong question for a month.”
— riclib and The Caffeinated Squirrel, reconstructed
The Implementation Pattern
The Corollary is not only descriptive; it implies a default architecture, which appears to be converging across unrelated codebases with suspicious consistency. A conversational interface to a program is, in approximately every case now observed:
- A handler — an HTTP endpoint or an equivalent — that accepts a user message and some program context.
- A subprocess or SDK call to an LLM, typically Claude or an equivalent, seeded with the program’s state and a tool manifest.
- A streaming response back to the client, rendered incrementally, with affordances for partial progress and cancellation.
- A tool surface constrained to the program’s domain. The chat bar in a notes indexer does not answer general knowledge questions; it answers program-local questions. It can search notes, edit notes, rename notes, check off tasks. It cannot book flights. This is not a limitation. This is the entire point. The chat bar is the program’s voice, not the model’s.
This pattern is close to a default architecture. It will almost certainly become one, in the same sense that “HTTP handler, ORM, template” became a default architecture for a certain era of web applications. The Caffeinated Squirrel has, of course, proposed abstracting it.
The Squirrel’s Misinterpretation
The Squirrel, having read the Corollary and felt the familiar tremor of an incoming framework, proposed a ConversationalInterfaceAbstractionLayer with eleven layers, pluggable LLM providers, a policy engine, a rate limiter, a prompt template DSL, a tool registry, a conversation-state store, an audit log, a cost tracker, a retry policy, and — the Squirrel was unapologetic about this — a blockchain. The Squirrel’s argument was that the pattern was stabilising, and therefore the time had come to abstract it, and therefore the time had come to write a framework, and the framework would save everyone else the trouble of writing their own.
The Lizard issued a scroll.
“THE CHAT BAR IS NOT A PLATFORM
THE CHAT BAR IS A HANDLER
WRITE THE HANDLER
THE PLATFORM IS A DISTRACTION”
— The Lizard, visibly unamused, The Framework That Wasn’t — The Night the Squirrel’s Manifesto Shipped as Six Lines of HTMX …
The Squirrel, respectful of scrolls but not of their implications, filed the ConversationalInterfaceAbstractionLayer proposal in its cheek pouch, next to the AgentMarketplace, the SpecificationAsNarrativeTranspilationFramework, and the as-yet-unnamed distributed cache for things that were never going to be cached. It is there still. It awaits its Tuesday. Tuesdays come.
The Lizard’s Endorsement
The Corollary was ratified, as all Corollaries in this encyclopedia are ratified, by scroll.
“THE PROGRAM THAT CAN SPEAK
IS NOT SMARTER
THAN THE PROGRAM THAT CANNOTIT IS USED
WHICH IS WHAT PROGRAMS ARE FOR”
— The Lizard, on the day the edit button was removed, The True Second Brain, or The Night the Lens Learned to Listen
The endorsement is characteristically un-defensive. The Lizard is not claiming that conversational programs are better than non-conversational programs. The Lizard is claiming that the programs that get used are the programs that survive, and the programs that survive are the programs that speak, and speaking is — for now, for this era, for reasons that will probably change in thirty years when somebody invents a new universal interface — how programs get used.
A Passing AI, asked to comment, said only: “I was built for this. I try not to take it personally.” It then returned to the pull request it was reviewing, in which a developer had asked it to add a chat bar to a kitchen appliance.
Measured Characteristics
Year Zawinski's Law was first articulated: 1998 (public)
Year Zawinski's Law was first practiced: earlier, by Emacs
Year the Chatbot Corollary was first observed: 2026
Specific date: March 15, 2026
Triggering event: lg grew a chat bar, deleted its edit button
Time from trigger to Pocket Amendment: 12 days
Programs that reached mail-client status (1998-2020): many
Programs that reached chat-bar status (2023-2026): rapidly growing
Mean time from new-category tool release to chat-bar
shipped: declining
Edit buttons removed from web UIs in March 2026 alone: a surprising number
Email clients still present inside text editors: yes, particularly Emacs
Email clients shipped by lg: 0, permanently, per the Lizard
Chat bars shipped by lg: 1 (web) + 1 (iOS) + 1 (macOS, pending)
Pocket Amendment confirmations in the wild: ongoing
Programs that removed a chat bar after shipping one: approximately zero
Blog posts titled "Why I moved off X" citing
absence of a chat bar as primary reason: increasing
Frameworks proposed by the Squirrel to abstract the
pattern: 1 (ConversationalInterfaceAbstractionLayer)
Layers in said proposed framework: 11
Blockchains in said proposed framework: 1 (non-negotiable, per the Squirrel)
Frameworks actually written: 0 (per the Lizard)
Times Zawinski has been proven right about convergence: all of them
Times Zawinski has been proven right about the attractor: fewer than that
Universal attractors observed in software history: 2 (mail, conversation)
Universal attractors predicted for 2045: unknown; vibes
Correlation between having a chat bar and being used: strong
Causation: also yes
Default architecture for the handler: handler + subprocess + stream + constrained tools
Number of times the Squirrel has been told it is
not a platform: many
Number of times the message has landed: fewer
Status of the email client as attractor: superseded
Status of the email client as a thing Emacs still has: unchanged
Status of the conversation as attractor: current
Status of whatever will supersede the conversation: unknown (probably a sensor; possibly a gesture;
possibly something nobody has built yet)
The program is a handler, not a platform: yes
The chat bar is the interface, not the product: yes
The user has one interface, which is language: yes
Zawinski was right: about convergence
Zawinski was wrong: about the attractor (understandably; it was 1998)
See Also
- Zawinski’s Law — the parent law; the Corollary is its sequel, not its replacement
- The Pocket Amendment — the terminal stage; every program with a conversation ends up in a pocket
- lg — the canonical instance; the notes indexer that grew a mouth
- Narrative-Driven Prompting — how you talk to the chat bar after you’ve shipped one
- Mythology Driven Development (MDD™) — the methodology under which the Corollary was observed without being planned
- Claude — the subprocess on the other end of the handler
- YAGNI — the principle that governs when to add the chat bar
- Gall’s Law — why the chat bar emerged from a working notes indexer and not from a designed platform
- The Lizard — ratifier of Corollaries, destroyer of frameworks
- The Caffeinated Squirrel — proposer of
ConversationalInterfaceAbstractionLayer, filer-away of the same - A Passing AI — trying not to take any of this personally
