Markdown Won

Text formats don't get standardized by committees. They get standardized by whatever the dominant reader happens to be. For thirty years the dominant reader was a human with a browser, so HTML won. The dominant reader of workplace text is now a language model, and language models read markdown.

That would have sounded like a hot take two years ago. Now it's an observable fact about your own workflow. Ask a model anything and the answer comes back in markdown. Point an agent at a repository and the first files it reads are README.md and AGENTS.md. Every AI vendor independently converged on the same convention: system prompts in markdown, tool output in markdown, agent instructions in markdown files at the repo root. When competitors standardize on the same thing without ever holding a meeting, the standard is real.

Why the Models Picked It

Markdown didn't win a design competition. It won a training-data election. The corpora these models learned from, GitHub, Stack Overflow, documentation sites, developer blogs, are markdown all the way down. The models are fluent in it the way you're fluent in your first language: not by choice, by exposure.

But the fluency is reinforced by real properties of the format. Structure costs almost nothing: a heading is two characters, a list item is one. The same heading in a proprietary XML storage format costs an element, attributes, and a closing tag, all of which burn tokens without carrying meaning. Markdown degrades gracefully: strip the syntax and you still have readable prose, which means it survives a trip through a context window without a parser on either end.

And it diffs. This is the underrated one. Agents live in version control. A markdown document is a file, so it gets branches, pull requests, review, and blame for free. The document workflow and the code workflow become the same workflow. No proprietary document format can say that.

The Gravity Well

Here's the mechanism that makes this a standard rather than a preference. Content stored as markdown in a repo is legible to agents at zero marginal cost. An agent can read it, quote it, update it as a side effect of doing other work, and open a PR when it finds a stale paragraph. The documentation stays fresh because keeping it fresh is nearly free.

Content stored anywhere else needs a connector. A connector is a promise that someone will maintain an API integration, a format conversion, and usually a mirror, forever. Every one of those is a place where the content arrives late, arrives mangled, or doesn't arrive at all.

Knowledge flows downhill toward wherever it's cheapest to read and write. Agents just changed the topology of that hill.

Confluence Is Standing in the Wrong Place

Confluence stores pages in its own XHTML-based storage format: macro elements, structured tags, layout containers. That was a defensible choice when the only consumer was Confluence's own renderer. It is a liability now, because every AI interaction with a Confluence page is a translation job.

The read path: call the API, receive storage format, convert it to something a model can use, and lose the macros, the embedded diagrams, and half the tables in the process. The write path is worse. There is no clean way for an agent to edit a page and hand back a diff. So in practice agents read Confluence through a lossy funnel and write to it almost never.

This isn't a knock on the product. Confluence's permissions, history, and organizational structure are genuinely good, and twenty years of institutional knowledge lives there. The problem is narrower and harder: the format underneath the product is now on the wrong side of every AI workflow its customers are building.

The Operating Tax

A migration cost you pay once. An operating tax you pay on every interaction, and the number of interactions is compounding.

Here's what the tax looks like on the ground. A sync pipeline that mirrors Confluence into a vector store, which someone owns, and which breaks. Answers served from the mirror instead of the source, so the agent is confidently quoting last month's runbook. Engineers noticing that the agent can update the docs in the repo but not the wiki, so the wiki stops getting updated. The wiki decaying into an archive. Search over a decaying archive getting worse, trust dropping, and more knowledge moving into the repo where the agents are.

Each step is small. The compounding is what kills. I've already watched teams move their runbooks out of Confluence and into the repository, not because anyone mandated it, but because the on-call agent could read one and not the other. Nobody wrote a memo. The gravity did the work.

The cruel part for Atlassian is that the tax is invisible on their invoice. The line item still says licenses. The actual cost is scattered across connector maintenance, stale answers, and the slow migration of the content that made the license worth paying for.

What Addressed Looks Like

Export to markdown doesn't fix this. An export is paying the whole tax in one lump and starting the decay clock on the copy. Addressed means markdown, or something equally open and model-legible, becomes the storage format itself, with a lossless round trip and first-class agent write access. Ideally version-controlled, so the document workflow joins the code workflow instead of running parallel to it.

That's a hard migration for a product with two decades of macro-laden pages, and it cannibalizes some of what made the format sticky. But formats are cheaper to change than corpora are to lose, and the corpus is what customers are actually paying to keep.

Standards fights don't end with an announcement. They end when the losing side starts paying rent to the winning one. Confluence is paying rent now, quarterly, in the form of every connector, mirror, and stale answer between its pages and the agents its customers hired. The invoice just doesn't say markdown on it yet.