Every AI tool outputs markdown. ChatGPT, Claude, Gemini, Copilot, Perplexity, Mistral, Llama. All of them. Open source models, closed source models, local models, cloud models. If it generates text with any kind of formatting, it writes markdown.
This is not a coincidence. It is not a design choice that any one company made. It is a technical inevitability, baked into how large language models work at every level, from training data to token economics to streaming architecture. Understanding why this happens is the key to understanding one of the most persistent friction points in the modern AI workflow.
Reason 1: Token efficiency
Large language models generate text as a sequence of tokens. Each token costs compute. At the scale these companies operate (billions of API calls per day), every unnecessary token adds up.
Markdown is dramatically more efficient than the alternative, HTML:
Markdown: ## Project Status (3 tokens)
HTML: <h2>Project Status</h2> (7 tokens)
Markdown: **deadline is Friday** (5 tokens)
HTML: <strong>deadline is Friday</strong> (8 tokens)
Markdown: - First item (3 tokens)
HTML: <li>First item</li> (6 tokens)
Across an entire formatted document, markdown uses roughly 40% fewer tokens than equivalent HTML. For a model like GPT-4o or Claude Sonnet, where output tokens cost $15 to $60 per million, that savings is enormous at scale. For individual users on paid API plans, fewer output tokens means lower bills. For companies running these models, it means serving more users per GPU.
This efficiency advantage is structural. Any formatting language that uses inline symbols (**, ##, -) will always be more compact than one that requires opening and closing tags (<strong>...</strong>, <h2>...</h2>). Markdown was designed for brevity, and that design choice aligns perfectly with the economics of token generation.
Reason 2: Training data
LLMs learn to write by reading. And they have read an extraordinary amount of markdown.
The training corpora for models like GPT-4, Claude, Gemini, and Llama include billions of markdown documents: GitHub READMEs, documentation sites (which are almost universally written in markdown), technical wikis, developer blogs, Stack Overflow posts, and academic papers converted to markdown for web publishing.
Markdown is the dominant text format of the technical internet. Every GitHub repository has a README.md. Every documentation site (from React to Kubernetes to Python) is authored in markdown. Every static site generator (Jekyll, Hugo, Gatsby, Astro, Next.js) uses markdown as its content format.
The result: markdown is the "first language" of large language models. They produce cleaner, more consistent, more structurally sound markdown than they produce in any other format. Ask an LLM to output HTML and you will get functional but often messy results, with inconsistent indentation, unnecessary wrappers, and styling artifacts. Ask it to output markdown and the result is almost always clean, well-structured, and syntactically correct.
This is not something that can be retrained away. The fundamental distribution of formatted text on the internet is heavily weighted toward markdown, and that distribution shapes the model's natural output tendencies.
Reason 3: Streaming compatibility
When you use ChatGPT or Claude, the response appears token by token. This streaming behavior is central to the user experience. It makes the model feel responsive, even when generating long answers.
Markdown works beautifully with streaming because its formatting is inline and self-contained. When the model outputs **bold text**, the formatting intent is complete in a single contiguous sequence. A renderer can detect the opening **, buffer until the closing **, and render the bold text as soon as it arrives.
HTML is fundamentally harder to stream correctly. When the model outputs <strong>, the renderer does not know when the content will end. It has to hold state, waiting for the matching </strong> tag. If the model outputs a nested structure like <div><h2><strong>Title</strong></h2><p>Content...</p></div>, the renderer needs to track multiple open tags and handle them in the correct order. Malformed HTML (a common LLM failure mode) becomes much harder to recover from in a streaming context.
This is why every AI chat interface renders markdown in real time but would struggle to stream raw HTML. The format choice is driven by the delivery mechanism.
Reason 4: Human readability
AI tools are not just generating content for other software to process. They are generating content that humans read directly in chat interfaces. Often, the user reads the response as it generates, scanning for the key information they need.
Markdown is uniquely readable in its raw form. You can glance at ## Project Status and understand immediately that it is a heading labeled "Project Status." You can see - First item and know it is a list item. **important** is obviously emphasis.
HTML is not readable this way. <h2>Project Status</h2> is parseable by a developer, but it is noisy. <li>First item</li> requires more cognitive effort to extract the content from the syntax. For non-technical users, HTML is essentially unreadable.
This matters because AI chat is an interactive reading experience. The raw text needs to be scannable, not just after rendering, but during generation. Markdown serves both purposes. HTML would serve only one.
Reason 5: Universality
Because every AI tool independently arrived at markdown for the same structural reasons, the ecosystem enjoys a rare benefit: universal format consistency.
Whether your content comes from ChatGPT, Claude, Gemini, Copilot, Perplexity, or an open source model running locally, the output format is the same. A heading is ##. Bold is **. Tables use pipe characters. Code blocks use triple backticks.
This means any tool that solves the markdown problem solves it for every AI tool simultaneously. There is no ChatGPT format and Claude format and Gemini format. There is one format: markdown. The solution space is unified.
The problem: great for AI, difficult for humans
Everything above explains why markdown is the right choice for AI output. Token efficient, training aligned, streaming compatible, human readable during generation, and universal across tools. From the AI's perspective, markdown is optimal.
The problem is on the other side of the workflow. The places where humans actually use AI-generated content do not speak markdown.
Google Docs has minimal markdown detection. It will sometimes catch bold (double asterisks) and italic (single asterisks), but headings, tables, code blocks, links, and lists are pasted as raw syntax characters. ## Project Status becomes literal text with hash marks.
Microsoft Word has zero markdown support. Everything pastes as plain text with visible formatting symbols.
Slack uses its own format called mrkdwn (yes, without the "a"), which looks similar to markdown but is syntactically different. Bold is *text* in Slack, not **text**. Links use <url|text> instead of [text](url). Pasting standard markdown into Slack produces a mess of misinterpreted symbols.
Email clients (Gmail, Outlook, Apple Mail) expect inline-styled HTML. Markdown characters display as literal text. Tables show as pipe characters. Headings show as hash marks.
OneNote treats pasted content as plain text by default, stripping any formatting inference.
The gap is structural and permanent
This is not a temporary problem waiting for Google Docs or Word to add markdown support. The gap exists because the two sides of the workflow have fundamentally different requirements.
AI tools output markdown because it is optimal for generation: compact, streamable, training-aligned. Destination apps use rich text because it is optimal for consumption: visually formatted, semantically structured in native elements, compatible with printing, sharing, and collaboration.
These two requirements will not converge. AI tools will not switch to outputting app-specific rich text (it would be more expensive, less reliable, and would require per-app formatting logic inside the model). Destination apps will not add full markdown parsing (each app has its own rendering engine, and markdown compatibility is not a priority for any of them).
The gap between generation format and consumption format is a permanent feature of the AI workflow.
What to do about it
The solution is a publishing layer between AI output and your destination apps. A tool that accepts markdown as input and produces destination-specific formatted output.
This is exactly what Unmarkdown™ does.
Paste markdown from any AI tool and convert it to the format your destination app actually understands:
- Google Docs gets rich text with proper headings, formatted tables, and styled code blocks
- Word gets native heading styles, bordered tables, and document structure
- Slack gets mrkdwn with the correct syntax for Slack's rendering engine
- OneNote gets HTML with all 6 heading levels and formatted elements
- Email gets inline-styled HTML that renders correctly across Gmail, Outlook, and Apple Mail
- Plain Text gets clean text with all formatting symbols removed
The conversion is not generic. Each destination gets output specifically optimized for its capabilities and limitations. Google Docs formatted text is different from Word formatted text is different from Slack formatted text. They have to be, because each app handles formatting differently.
Closing the gap inside the AI workflow
For users who work with Claude, there is an even more direct path. Unmarkdown™ integrates as an MCP (Model Context Protocol) server, which means Claude can use it as a tool during conversation. Instead of copying markdown, opening a converter, and pasting the result, Claude can convert and publish documents directly.
The entire copy-paste-convert workflow collapses into a single step inside the AI tool itself. See the integration setup guide for details on connecting Unmarkdown™ to Claude, ChatGPT, and other AI tools.
The bottom line
Every AI tool writes markdown because it is the technically optimal output format for large language models. That will not change. The apps where you use AI-generated content expect rich text. That will not change either. The gap between these two worlds is permanent, and the tools that bridge it are becoming as essential as the AI tools themselves.
Related reading
- What Is Markdown and Why Does Every AI Tool Use It?
- 5 Things That Break When You Paste AI Output (And How to Fix Each One)
- The Complete Guide to Formatting AI Output for Business Documents
- The AI Formatting Problem Nobody Talks About (And How to Fix It)
- Why Developers Write in Markdown (And Everyone Else Should Too)
