Thariq Shihipar, on the Claude Code team at Anthropic, published The Unreasonable Effectiveness of HTML this week, arguing that HTML carries information density Markdown cannot. It supports diagrams, code, interaction, design, in-page navigation, all in the same file. It's shareable as a link. The most pointed detail in his post is a screenshot of Claude Code rendering color in Markdown using Unicode block characters — because the format has no other way to do it. The medium is the constraint.
Simon Willison picked it up on his link blog within two days and named the historical reason most of us had been defaulting to Markdown in the first place: the GPT-4 era's 8,192-token context budget. Markdown wasn't chosen for what it could express. It was chosen for what it could fit. Token windows are no longer scarce, and the case for the more expressive format is the case that wins. This is a real shift, and it's happening from inside the labs that build the agents and from outside them at the same time. HTML is back as the format for serious agent output.
The original idea was read/write
The rediscovery is partial. Tim Berners-Lee designed the browser as an editor. The first browser — WorldWideWeb, 1990 — could create and modify pages, not just display them. The read/write web was the plan, and HTML was the substrate that would carry it. That plan didn't survive the commercial web. Documents moved to servers, then to clouds. Editing became an account, an app, a subscription. The browser became a viewer. HTML became a delivery format.
Thus, we are used to operate almost exclusively on the read side. Claude Code generates an HTML explainer; you read it. Claude generates a spec; you read it. Simon's 150-plus single-file tools are extraordinary and they are artifacts to be opened and used, not edited in place. The format is back. The original concept of writing hasn't returned with it (yet).
I wrote about why the read/write web got buried and where it might be coming back earlier this year. The short version is that the read/write web was never wrong about HTML. It was waiting for an editor that didn't require the user to be a developer.
LLMs make this possible — and reWritable is how
That editor exists now. It just doesn't look like an editor — it looks like a sentence. When an LLM can read a document and return a modified document on instruction, the gap between can read HTML and can modify HTML collapses. The user doesn't author the file; she authors instructions. The file rewrites itself. The verb that was missing from the rediscovery — write — is supplied by the agent. HTML stops being a delivery format and becomes the substrate Berners-Lee originally intended, with one part of the design he didn't anticipate: the editor isn't the user's tool, it's a process inside the file.
reWritable is what that looks like as a working artifact. A single .html file. Open it; it renders. Press ⌘K; type what you want changed. The file modifies itself, persists the change, and reopens as the new version. ⌘S commits the current state back into the file on disk so the next person to open it sees what you saw. No application. No install. No account. No server. Just a file you can email.
The architecture is described in detail in the spec. What matters most is the edit surface of the agent that modifies the HTML: it lives in the file. Not in a terminal next to it, not in an application that contains it, not on a server that talks to it. The HTML, the rendered document, the editing surface, and the agent are one object. The download is the artifact; the artifact is its own editor.
This is what distinguishes the model from the alternatives that already exist. Copilot in Word is the closest analog, but the substrate is different: Copilot lives in the application, and the document is an artifact that the application contains. To use it you need Word installed, an Office subscription, Microsoft's cloud terms in effect. Claude Code, in Thariq's pattern, is closer to a workshop — the agent lives in a terminal, the HTML files it produces are output. To use it you need a developer workflow. A reWritable container needs none of that. The host is the one piece of software essentially everyone already has: a browser.
One more property falls out of this architecture, almost for free. Once the agent lives in the file, which agent becomes configurable. reWritable calls OpenRouter today, which fans out to most major models. The same architecture works with Anthropic's API directly, or OpenAI's, or Gemini's. It works with a local CLI agent like Claude Code as a backend. It works with a locally hosted model running in LMStudio or Ollama, no internet required. The document doesn't care which brain is plugged into ⌘K, because the document is the surface and the brain is interchangeable.
If you work in Claude Code, you work in Claude. If you work in ChatGPT, you work in ChatGPT. Your relationship is to the tool, and the document is something the tool produces. The intelligence and the artifact are bundled, and switching one means rebuilding the other.
A reWritable inverts that. The document is what you have. The intelligence is whatever you've configured to sit behind ⌘K. You don't open Claude and start working; you start working with the document, and the document is intelligent. The LLM moves to the background. The task moves to the foreground.
HTML carries the task because HTML is expressive enough to. Self-modification makes the file its own editor because the LLM can read and rewrite what it reads. Model-agnosticism falls out for free because the document is none of the agents and any of them. Thariq closes his piece by saying he feels more in the loop than ever. I'd put it differently. When the document is the editor, you're not in a loop with the agent at all. You're in the loop with the work. Which is what Berners-Lee had in mind in the first place.
Unlock the Future of Business with AI
Dive into our immersive workshops and equip your team with the tools and knowledge to lead in the AI era.