The Documentation Problem

Encyclopedia Britannica stopped printing in 2010.

It survived as a subscription, smaller. The audience for English-language ground truth had been moving to Wikipedia and search for fifteen years; eventually the substrate underneath the company was no longer the substrate the world was using. The function survived: humans still ground factual claims on something. But the form changed, and the model didn’t follow.

Documentation is going through its own version of that shift now.

For most of software’s history, documentation has been a side artifact. A manual the buyer read once, a reference the engineer searched when something broke, a marketing surface the company maintained to look serious. Sometimes good, sometimes neglected, never load-bearing. The product was the product; the docs were the manual.

That has reversed.

Your documentation is the contract surface. It is the place humans land to evaluate your project. It is the place agents ground their next API call on. It is the place retrieval systems index to feed in-product help. It is the public face of your business in the same way the API itself is the public face of your code. Two different species arrive there now, both expect the contract to be true, and both behave very differently when it isn’t.

The shift is uneven. Most projects do not yet have agent traffic surpassing human traffic. But every project that ships something an agent might use, an API, a CLI, a programmable surface, is already serving a load-bearing autonomous reader. The platform they pay rent on every month was designed before that reader existed.

What changed

Three things changed in the last two years.

Stripe-tier became the baseline for human-readable documentation. Mintlify built a $10M ARR business on that single insight, and the floor for what counts as serious developer documentation went up and has not come back down. Anything that looks worse now signals an unserious project before the reader has clicked past the hero.

The cost of clearing that baseline went up too. GitBook deprecated its open-source CLI and raised prices two to four times. Mintlify Pro is $300 a month. ReadMe starts at $99. The bar to ship beautiful documentation is no longer technical; it is whether you are willing to pay rent on a static directory.

And the audience changed. The same platforms that perfected the hero animation ship llms.txt as a hand-edited afterthought or not at all. The structured index that agents actually read is shipped second-class because the business is built around selling the human-evaluator marketing surface, not the autonomous reader. The pressure to add the agent surface will not override the pressure to keep producing the marketing one, because the buyer paying $300 a month is not the agent.

The three pressures are no coincidence; they are what happens when an industry optimises hard for one audience while another audience walks in the door.

What the field shipped

Every visible platform solves part of the problem and leaves the rest paid-for or impossible.

Mintlify is beautiful, multi-source, and rented. The docs live on Mintlify’s domain, in Mintlify’s MDX dialect, behind Mintlify’s billing. There is no static export that takes Mintlify out of the chain without losing the components Mintlify renders. The contract surface lives on someone else’s terms.

Docusaurus is open source and owned. It also looks like it shipped at the same conference Mintlify’s founders raised their seed round, and then stopped evolving. Default Docusaurus reads as Meta-built because Meta built it, for projects that have spare React engineers to make it stop reading that way.

Doxygen is the inverse of Mintlify. Ugly, owned, and the only tool here that actually parses C++. The C++ ecosystem has spent twenty years concluding there is no escape from Doxygen’s output, which is wrong; “Don’t Replace Doxygen” unpacks the move they have been missing.

pkg.go.dev is excellent at what it does. What it does is be Go’s package index, not your project’s documentation site. Your project’s URL on pkg.go.dev is Go’s URL with your import path stapled to the end. “pkg.go.dev Isn’t Your Docs Site” makes the case for the owned alternative.

Swagger UI is owned, format-specific, and visually frozen in the year SmartBear took it over. The .NET 9 team dropped Swashbuckle as a default dependency in 2024, which is the closest the industry has come to a public admission that the renderer has aged out of relevance. “Stop Renting Your OpenAPI Docs” makes the broader case.

ReadMe, GitBook, and Redocly sell variants of the Mintlify trade. Different price points, same structural choice: rent the contract surface that humans and agents both ground on, in exchange for the convenience of not building it yourself.

The engineers shipping these products are not the problem. The business model is. A subscription priced for human-evaluator marketing surfaces does not produce the structured agent-readable artefacts the next reader needs, because the buyer paying $300 a month is not the agent and never will be. Britannica had the same shape of problem before it stopped printing: the subscribers paid for prestige and reference value while the people who actually used the content had moved to a different substrate entirely. The model could not follow the audience without giving up the model.

What fits

What fits 2026 is not a fifth platform built around the human evaluator and a sixth platform built around the agent. It is a single renderer that reads every source the project already has, ships static HTML, and produces both surfaces from one build.

Owned. Static HTML, deployable anywhere, no vendor between the project and the contract surface humans and agents both depend on. If the tool’s company shuts down, the docs do not shut down with it.

Beautiful. At the bar the field has set, not the bar a vendor charges for. Open source does not have to mean Docusaurus-default; that equation was the consequence of nobody bothering, not a law.

Multi-source. Reads Doxygen XML, Go packages, OpenAPI specs, MCP schemas, and hand-written Markdown from the same project, in one build. The four-tool docs chain (Doxygen + Breathe + Exhale + Sphinx) exists because docs platforms refused to read native formats; that refusal is the legacy artefact, not the multi-source build.

Dual-audience. Produces the human-readable site and the agent-readable surfaces from the same source. llms.txt, llms-full.txt, JSON search index, sitemap, structured anchors per symbol. Parallel outputs of the same render pass, not separate features bolted on. The agent gets the schema from the build that also produced the hero.

A tool that ships this is not a documentation platform. It is a renderer.

What we built

Sourcey is the renderer.

Open source. Reads every format. Ships static HTML. Free to run yourself; the hosted tier is convenience built on top of a tool that costs nothing to run.

Icey is a C++ networking library: WebRTC, signalling, TURN, and media encoding in one stack. Its Doxyfile has nothing in it most C++ projects do not already have. Its docs at 0state.com/icey/docs ship from the XML that Doxyfile produces. The modern part is the renderer, not the parser; the deeper argument is at “Don’t Replace Doxygen”.

Scafld is a Go protocol for multi-phase agent work. Its docs at 0state.com/scafld/docs ship from native Go package comments, with llms.txt written from the same build. No Markdown mirror on disk, no second source of truth. “pkg.go.dev Isn’t Your Docs Site” makes the argument.

Cheesestore is the OpenAPI showcase. A clean API-first project rendered from a single YAML spec, same renderer, no platform between the OpenAPI and the site. “Stop Renting Your OpenAPI Docs” makes the argument.

Three projects, three source formats, one renderer. The same build produces the human-facing pages and the agent-readable surfaces in every case.

What comes next

Britannica still exists as a subscription product. It is smaller, and the function it served, being the public substrate for English-language ground truth, moved elsewhere a decade ago. The model could not follow the audience.

The same shift is happening to documentation now, faster, with two audiences this time instead of one. The pressures that landed in 2026 are not landing somewhere else next year. The agents are not leaving. The price floors on the rented platforms are not coming down. The bar for human-readable docs is not going back to 2018.

Whoever owns the contract surface in 2026 owns the relationship. The platforms charging rent on it are charging rent on the most load-bearing artefact in your product, and their business model points them at the wrong reader.

Documentation belongs to the project.