I got tired of downloading HTML files from Slack, so I built Primer

Nowadays most of what I produce starts in an agent session. A spec review. A cost model for a deployment. A postmortem. Options for a decision I owe someone.

The output from the LLMs, as we all know, is pretty good. The hard part is what comes after. I need the right people to see it and provide feedback on it, and I need enough agreement that a decision actually gets made.

Earlier this year, with the proliferation of LLM-generated reports and documents, that stopped being my problem alone. People all over the company started generating HTML files and interactive reports, and then had nowhere to put them. They would drop the file into a Slack thread, which means you download it and open a local file. Or they would paste the LLM output directly in chat and then feedback threads became hard to untangle. Some would send a Claude Artifact link, which has no versions, no comments, no access control, and no way to know if anyone read it.

So I decided to solve this, at least for myself. That tool became Primer.

The simplest iteration

Primer takes an HTML document, stores it, and gives it a stable URL. Every publish creates a new version, and the old ones are kept. You comment on a range of text in the page, the way you would in Google Docs. The page renders in a sandboxed iframe. Everything sits behind company auth.

One weekend, one user: me.

The name comes from Neal Stephenson’s The Diamond Age. The Primer in the book looks like a book, but every page is a display that forms itself into whatever the reader needs.

No engineers were harmed

Every line of Primer’s application code was written by an agent. It started like a normal LLM session. Have the LLM write the specs in markdown, review locally, implement, rinse and repeat. I got lots of feedback from the team as people started using it. I would spend a few hours every week getting fixes and features in there. It was classic product iteration.

Then one day James told me we should add an MCP server to Primer. I had the MCP APIs and an agent skill ready the next day, and the whole flow completely changed. Install the skill once, say “publish this to Primer” in any session, and the published URL comes back, accessible to the whole team.

Comments and the agents’ ability to read them turned out to matter even more than publishing documents. Either myself or someone else would leave comments on my spec, I would point the agent at the URL, and it would read them, make the changes, and publish a new version. Even on solo projects, this became the flow. Agent would publish docs directly to Primer so I can comment and we would iterate this way.

That is where Primer stopped being a place to put finished work. A document, a model and a few people now work on the same thing at the same time. People started pointing their agents at other people’s documents too, so the docs turned into shared context for the agents as much as for us.

We’re gonna need a bigger boat

Over a hundred people used Primer last week. That is around 90% of the company. There are hundreds of documents in there, over a thousand versions, and thousands of comment threads.

What people published, I did not predict. Specs, sure. But also small HTML tools somebody built for themselves and then shared, finance reports, postmortems, and designs for new marketing pages. HTML lends itself well to interactive elements, so we see a lot of interactive charts and graphs that make it easy to ingest information.

Keeping it internal is a feature

Everything in Primer sits behind company auth, and that is a product decision as much as a security one.

The stakes on any given document stay low, so people put half-finished things in it. A tool that only works for one team. A report with real numbers in it. A page that renders correctly in exactly one browser. None of that survives a public launch checklist, and all of it is what you want people sharing internally.

It also means we can move fast. No anonymous traffic to defend against, no support commitment to anyone outside the company. When I break something, the people affected are in the same Slack workspace and I hear about it within the hour (we have some solid automated testing in place though, thanks to agents again).

Then people started fixing my bugs

This is the part I did not expect and enjoyed the most.

Adam found that the comment composer was stealing focus and scrolling the viewport every time you selected text. It was quietly breaking copy and paste, and it made the page unusable if you were zoomed in. I would never have found it, because I do not read documents that way. He also wrote the guidance for inline SVG in the publishing skill, so diagrams survive the trip into Primer.

Donn made Primer usable by an agent that has not been handed a URL. He added document listing, search and comment aggregation across documents, so an agent can go find the thing itself. Then self-serve API tokens and a service account, so people could wire up their own tooling without coming to me. Then the docs for publishing large interactive pages, which is where most people were getting stuck.

Daryl went deepest. He pulled apart the shared package everything was importing from and published the wire contract properly, he moved us onto a real release process with a human gate on every publish, and he taught the MCP server to move large documents through the filesystem instead of streaming them through model context twice.

Daryl also built the events channel, which is the one feature I would not have thought to ask for. Comments are how people talk about a document. Events are how a document talks to agents. A published page can record what a reader did with it, and an agent can read that back later. Because a page can now write to the server, he built the consent model with it: nothing is sent without a real click from the reader.

None of this was assigned. Every piece of it came from someone hitting the edge of what Primer did and fixing it. Primer itself made iteration easier.

What I take from it

Primer was a side project with one user. Virtually the whole company uses it now, because agent output is document-shaped and Primer gave us a place to put it and interact with it efficiently.

The fastest way to get an internal tool adopted is to remove a step people already do by hand every day, not to give them a capability they never had. And an agent tool gets much more valuable the moment it works in both directions. Publishing saved me a copy and paste. Reading the comments back is what changed how we review anything. Besides, iterating on products with a built-in audience like this is fun.