Athens

Why Markdown is the Perfect Format for AI-Native Writing Tools

- Moritz Wallawitsch

Every major AI model - GPT, Claude, Gemini, Llama - thinks in markdown. When you ask an AI to write something, it outputs markdown. When you feed it a document to edit, it processes it as text with markdown formatting. Headers are ##, emphasis is **bold**, lists are - items.

This isn't a coincidence. Markdown is the lingua franca of the modern web. It's what models were trained on - billions of GitHub READMEs, Stack Overflow posts, documentation sites, and blog posts. Markdown is to LLMs what sheet music is to musicians: the native notation.

So why do most writing tools store your work in proprietary formats that AI can't directly read or write?

The Translation Tax

When you use ChatGPT to edit a Google Doc, here's what actually happens:

  1. You copy text from your doc (losing formatting)
  2. ChatGPT receives plain text (no structure)
  3. It outputs markdown (because that's what it knows)
  4. You paste back into Google Docs (losing markdown formatting)
  5. You manually re-apply bold, headers, lists

Every round trip between your editor and the AI involves a lossy translation. Rich text to plain text to markdown to rich text. Information gets lost at every step. This is the fundamental friction of the copy-paste workflow.

The same problem exists with Notion, Word, and every other rich-text editor. Their internal formats - Notion's block-based JSON, Word's XML, Google Docs' proprietary representation - are opaque to AI models. The AI can't read them, can't write them, and can't diff them.

Markdown Solves This

A markdown-based editor eliminates the translation entirely. What the human sees (formatted text) and what the AI sees (markdown source) are the same document. There's no conversion step, no information loss, no re-formatting.

When an AI edits your document, the operation is a simple text replacement. Find the original text, replace it with the new version. No DOM manipulation, no block IDs, no format-preserving transforms. Just text in, text out.

This is exactly how code editors like Cursor work with AI. Your code is plain text. The AI reads it, suggests changes as text diffs, and you accept or reject each one. The reason Cursor's AI editing feels so natural is that code is already a plain-text format.

Markdown gives you the same advantage for prose.

WYSIWYG Without the Overhead

But markdown is ugly," you might say. "I don't want to look at ## and ** while I'm writing.

Fair. That's why modern editors like Tiptap (built on ProseMirror) render markdown as rich text in real-time. You see formatted headings, bold text, bullet lists, and images. You type naturally - no markdown syntax required. But under the hood, the document is stored as markdown.

This gives you both worlds:

  • For the human: A clean, formatted writing surface
  • For the AI: Direct access to the document in its native format

When you ask the AI to "make this section more concise," it reads the markdown, outputs a modified version, and the editor applies the diff. The user sees highlighted changes in the formatted view. The AI works with plain text. Nobody has to translate anything.

Why This Matters for AI Editing

The real power of markdown-as-storage shows up when AI edits get granular. Consider what happens when you ask an AI to "improve the opening paragraph" in different systems:

Chat-based AI (ChatGPT, Claude): The AI rewrites the entire paragraph and gives it back to you. You have to manually compare the old and new versions, decide what changed, and paste the result. If you like some changes but not others, you have to manually merge them.

Rich-text editor with AI (Notion, Google Docs): The AI has to understand the editor's internal format, generate valid block mutations, and handle edge cases around formatting boundaries. This is complex, error-prone, and usually means the AI can only do coarse operations like "rewrite this block."

Markdown editor with AI: The AI sees the exact text, produces a targeted replacement, and the editor shows you a precise diff - green for additions, red for deletions. You accept or reject each individual change. If the AI rewrote five sentences but you only like three of them, you accept those three and reject the other two.

This is the Cursor model applied to writing. And it only works cleanly when the document format is something the AI can directly manipulate.

The Broader Trend

We're seeing a convergence. The best AI-augmented tools all share a common trait: they store content in formats that AI models can natively process.

  • Cursor / VS Code: Plain text (code)
  • Obsidian: Markdown files
  • Linear: Markdown descriptions
  • GitHub: Markdown everywhere

The tools that struggle with AI integration are the ones built on opaque, proprietary formats. Google Docs, Notion, and Word are retrofitting AI onto systems that were designed before LLMs existed. They can bolt on a chat sidebar, but they can't give the AI the same fluent access to the document that a markdown-based system provides.

The next generation of writing tools won't treat AI as an add-on. They'll be built from the ground up around a simple insight: your document should be in a format that both humans and AI can read and write fluently. And right now, that format is markdown.

Athens is a markdown-based WYSIWYG editor with AI that can edit your documents directly, showing you exactly what changed.