Your AI just rewrote your Markdown. Here is how to read the diff it left you.

If you have handed a document to an AI assistant in the past year, you know the feeling at the end. The agent says it tightened your copy, added a subheading, or cut two redundant paragraphs. You want to trust it, but the file is a wall of text again and the only record you have of what changed is the agent's own summary. For a professional writer that is a trust problem, not a convenience problem — a summary is a claim, and a claim is not the same as seeing the words that actually moved.

A new Mac app called MRDown was posted to Show HN on September 4, 2026 with a one-line pitch that names the problem exactly: "a Mac Markdown app that diffs what your AI just rewrote." The author started it as a viewer for the .md files that Claude Code generates, and only in version 0.1 realized what was actually needed: to read the diff of what the agent rewrote, rather than trust a summary of it. The project is open source at MR-TABATA/MRDown, licensed MIT, and free.

What MRDown does

The mental model is simple and different from every other Markdown editor. Most editors show you the file as it is now. MRDown's core feature is that it quietly keeps a timestamped version on every save — and on every rewrite that happens from outside the app, including an agent editing a file you have open. Its History panel then puts any two versions side by side so you can read what changed. Only the words that actually differ are marked; long unchanged runs are folded away so you are not re-reading whole pages to find one altered sentence.

• Versioned history on every save. Nothing to configure — each save and each outside rewrite is snapshotted automatically.
• Side-by-side diff of any two versions. Read what the agent changed, not what it claims it changed.
• Git-aware when you want it. If the file is inside a Git repo, HEAD joins the same list, so the diff against what is committed is right there. Git is optional.
• Conflict-safe concurrent edits. If something rewrites the file on disk while you have unsaved edits, MRDown neither overwrites you silently nor reloads over you — it snapshots the disk state and shows three columns: last save, what is on disk, and your edits, marking only the lines both of you changed differently as conflicts.
• Auto-reload. The file refreshes when it changes on disk, which is exactly when a coding agent is mid-rewrite.
• Clean Tech stack. Built with Tauri (Rust + TypeScript), not Electron — the download is roughly 7 MB, and on the first run there is none of Electron's per-app baggage.

MRDown opens .md, .markdown, and .txt files, plus whole folders for browsing a file tree, and it renders Mermaid diagrams, KaTeX math, and syntax-highlighted code in the preview. It can also open two .docx files and diff them against each other after converting them locally — nothing uploaded. The current build is v1.14.0 (released September 2, 2026), signed and notarized, with separate Apple Silicon and Intel downloads from the GitHub Releases page. macOS 13 or newer is the stated floor from the author on the HN thread.

Why the diff is the real feature, not the editor

The distinguishing detail is that MRDown makes no AI API calls of its own. It does not need to know which tool rewrote the file. It diffs whatever changed on disk, whether the writer behind the edit was Claude Code, ChatGPT, a text-expansion utility, or you on a second machine. That design is what makes it trustworthy: the diff is ground truth about the file, not a summary produced by the same model that made the change. AI explain-diff and project search features are explicitly planned as paid add-ons in a separate repository, so the core review loop stays in the MIT code.

For writers who publish, this closes a quiet hole in the modern writing stack. The Markdown-to-rich-text direction we have written about for LinkedIn and X Articles assumes a clean final draft. But when the final draft was partly produced by an AI rewrite, "clean" depends on a human having actually reviewed what changed. MRDown is that review step, sitting right before the publish step.

The workflow: review the diff in MRDown, publish the clean draft with md2rich

Here is the write-once pipeline with MRDown at the review gate. You keep a post draft as a Markdown file, hand it to an assistant, and then MRDown is where you decide whether the rewrite ships. First, the Markdown draft as an agent might return it to you:

# Why plain text outlives every app

The takeaway: write once, publish anywhere.

- Draft in Markdown, keep the file yours
- Review what your AI changed in MRDown
- Convert the clean draft to rich text
- Paste into LinkedIn or Medium, ready to go

Suppose the agent quietly rewrote the opening line to "Plain text lives longer than any app you name." Instead of trusting that summary, you open MRDown's History panel, pick the pre-rewrite save and the current file side by side, and see that one sentence change highlighted while every other line stays folded. You decide it is an improvement, keep it, and move on. Now convert that accepted draft through md2rich:

# Shipping faster with plain text

**The takeaway:** write once, format anywhere.

- Keep the file in Markdown, outlive the app
- Review AI rewrites as diffs in MRDown
- Convert locally — nothing is uploaded
- Paste rich text into LinkedIn or Medium

md2rich turns that into a bold headline, an emphasized lead line, and a clean bullet list that LinkedIn and Medium render natively — all in your browser with no upload and no account. The two tools do not overlap: MRDown is the editorial-control gate at the front of the pipeline, and md2rich is the formatting gate at the end.

MRDown vs md2rich vs your Git workflow

If you already live in Git, you might wonder why you need MRDown at all — git diff exists. The honest answer is that Git diffs are great for developers and awkward for writers mid-draft. MRDown gives you versioned history without committing, a GUI diff that folds unchanged lines, three-way conflict handling when an agent edits a file you have open, and no requirement that the file ever touch a repo. For someone who is not a developer first, that is a materially lower barrier. For a writer who is also technical, MRDown complements Git rather than replacing it — the Git HEAD join means the two views agree.

• MRDown — best at reviewing and diffing AI/agent rewrites of Markdown on the Mac, with automatic version history and no setup. Free, MIT, macOS.
• Git diff — best when the file is already a committed repo and you want branch-level or commit-level history. Powerful, but it assumes a developer workflow.
• md2rich — best at the final conversion, turning clean Markdown into rich text for LinkedIn, X Articles, Medium, and Notion. Client-side, no upload, no account.

Honest caveats

MRDown is a young, single-author project. It has 1 star and 0 forks on GitHub as of writing, and the Show HN thread is essentially the author explaining the tool to a handful of commenters. The Mac-only distribution means it is not a choice for Windows or Linux writers today, and the planned AI-summarize features are paid and separate, so the "explain this diff to me" assist is not in the free MIT code yet. If you adopt it for anything you cannot lose, the same advice as any early tool applies: keep the source file somewhere it is backed up, because the app is a review surface, not a place to store your only copy.

For writers, though, the direction it points at matters more than the star count. The next few years of writing tools will be defined by who keeps control of the words when AI touches the file. MRDown's bet — a diff you can actually read, as ground truth — is one of the more honest answers to that question.

FAQ