Notula vs md2rich: who owns the Markdown your AI agents read

The pitch behind Notula starts with a problem almost every technical team has already felt. Your Specs, PRDs, RFCs, and runbooks moved out of the wiki and landed next to the code, because the Markdown source of truth lives where your engineers review changes and where your AI agents can read and edit plain .md natively. That was the right call. But the people who are not fluent in git and code editors lost their tools: no comments, no threads, no way to browse, no way to edit a paragraph without first learning a diff and a rebase. Notula's answer is a desktop app that gives those documents the Google Docs experience — comment, reply, resolve, browse a tree — on files that never leave the repository.

What Notula actually is

Notula ships for macOS (Apple Silicon and Intel) and Windows (x64 and arm64), with Linux not built yet, and it is deliberately free — "no account, no server." The app drives the git already installed on your machine, so the SSH key or credential helper you already use is the one it uses, and it never asks you for a password or stores a token of its own. Three properties define how it behaves:

1. WYSIWYG, not live preview. There is no raw pane and no Markdown syntax on screen — no hashes in front of headings, no asterisks around bold, no pipes in tables, not even on the line your cursor is on. What lands on disk is still ordinary Markdown. Notula reports a byte-identical round trip on 6,000 real documents, with 96.4% of blocks surviving an edit untouched, and it writes back only what changed so a one-character edit stays a one-character diff.
2. Threads that live in the repository. A comment is anchored by the quoted passage and its context, following the W3C Web Annotation model, and the thread is committed next to the document as an append-only log with a union merge driver. Two people commenting at once cannot conflict. The conversation arrives with the clone and outlives every account, and it is never written into the Markdown itself.
3. Git safety by construction. Notula is a guest in someone else's worktree. Every git command carries an explicit pathspec, so it never stages the whole worktree, never stashes, and never rewrites history. It commits to the branch you are on, never creates or switches one, and says so if it is protected. Nobody on the team is ever shown a rebase, a stash, or the words "detached HEAD."

The AI-agent angle is the interesting part

The headline of the Show HN post — "where humans edit the Markdown your AI agents read" — is not marketing. Notula's whole reason to exist is that your AI agents already read and write plain .md natively, and the docs live next to the code precisely so agents and engineers can review the same files. Notula extends that to the humans who were left out, and it builds a bridge from the agent back to the human reviewer.

It writes a briefing file, notula-agents.md, that describes the document types, the fields, the layout, and the commands, then borrows three lines of your existing CLAUDE.md to point Claude Code at it:

<!-- notula:begin -->
This repository is edited with Notula.
What it keeps here: @notula-agents.md
<!-- notula:end -->

It never overwrites what you wrote in CLAUDE.md, and it carries the conventions that are invisible once broken — for example, renaming a document is notula docs move, because the comment log is filed under the document's path and a plain mv orphans every thread on it. There is also a command line behind the app that exposes documents, types, fields, and status with --json, so an agent can operate the workspace instead of guessing at files. And when an agent rewrites a document you have open, the change lands in front of you instead of being clobbered.

Why this is a different job from md2rich

Where Notula ends, md2rich begins. Notula keeps the Markdown source healthy inside the repository — the collaborate-and-review half. Once your document is finished and approved, the remaining job is turning it into a formatted post on a rich-text platform where your audience actually reads it. That is the publish half, and it is what md2rich does best: client-side Markdown to rich text for LinkedIn, X Articles, Medium, or Notion, with nothing uploaded.

The two tools actually share the same philosophy, which is why they pair cleanly rather than competing. Both assume the plain-text file, not the platform and not the chat window, is the durable asset. Both are privacy-first and run on your machine. The difference is directional: Notula pulls collaborators and agents into the repository around a living document; md2rich pushes the finished document out to an audience in the format a platform wants. Concretely, a finished Markdown block from a reviewed doc like this:

## Publishing the reviewed doc

- Keep the source in the repo where review happens.
- Convert the finished Markdown to rich text only when you ship.
- Nothing is uploaded; the source stays the source.

becomes, through md2rich, rich text with real headings, bold, and bullet lists ready to paste into LinkedIn or X Articles — no raw Markdown left in the paste box, no formatting lost.

Notula and md2rich side by side

They do not overlap: Notula makes the source reviewable by humans and agents, and md2rich makes the approved source publishable. You could realistically use both on the same repository — Notula to keep the documentation accurate and agent-readable, md2rich to turn a finished doc into a public post without moving the source anywhere.

When each one is the right tool

Notula earns its place when the document's life is a repository: multiple people have to comment and review, AI agents read and edit the same files, and you want the conversation to live with the clone and outlive every account. It is early — the builds are not signed yet (macOS needs a one-time quarantine command, Windows shows a SmartScreen prompt), the source is private, and Linux is not built — so treat it as a promising, fast-moving tool rather than a settled platform.

md2rich earns its place the moment the document's destination is a rich-text platform. Your reviewer-approved Markdown is ready to publish; md2rich converts it in the browser with nothing uploaded, so private Specs and RFCs never need to leave your machine to become a LinkedIn or X post. For a solo writer or a content team, the conversion step is the one you hit on every single publish, and that is the job md2rich is built for.

FAQ

Published by md2rich. This article is for informational purposes; the Notula facts are sourced from the project's official site (notula.org) and its Show HN launch on August 19, 2026, and md2rich is referenced only for the conversion step.