SkillDocs & md2rich: the collaboration layer and the publish layer

The pitch sits at a moment that was already building. Your AI agents run on plain text: instruction files, skills, specs, and runbooks are all just Markdown in a repository, and an agent reads and edits those files natively. But the humans who review that Markdown — the product folks, the designers, the non-git-native collaborators — kept losing their tools. The wiki became a codebase, and with it went comments, threads, presence, and the ability to shape a document without first learning a diff. SkillDocs is the answer that takes the good parts of HackMD, Figma, and Google Docs and points them at the files that actually teach your agents how to work.

What SkillDocs actually is

SkillDocs describes itself as "a collaboration layer for the markdown your agents run on," built explicitly in the lineage of the tools that got this right: HackMD's markdown-first writing, Figma's presence, and Google Docs' comment threads. Three properties define how it behaves:

1. Markdown you don't have to squint at. One surface, not a split screen. Headings, lists, tables, and diagrams render live, and the raw Markdown appears just-in-time around your cursor so you always know what you are actually editing — the asterisks around a bold phrase fade in only where you are working. Mermaid diagrams draw themselves in place as you type. Yet the file on disk stays plain Markdown, character for character.
2. A document that is a CRDT. Concurrent edits merge character-by-character. There is no save button, no conflict dialog, and no way for two people to overwrite each other. You see their cursor, their selection, and their name, can follow anyone's view like a screen share, and can share your own view to the whole document.
3. Comments that stay attached. Select any text and comment; the thread anchors to the words, not to line numbers, so it travels as the document changes underneath it. Threads are highlighted in place and resolvable in a rail — and you can export the document and its threads together as one Markdown blob and hand it straight to an agent, which reads the feedback with its quoted context attached.

The multi-cursor and rendering details are where the "Figma for Markdown" marketing earns its keep: ⌘D and ⌥-click and column selection for multi-cursor edits, fold by heading to collapse a section and keep the shape, and follow mode that rides along with someone else's folds, not just their scroll position. It is the authoring experience of a modern collaborative tool applied to the plainest of formats.

The agent loop is the interesting part

The closer is the SkillDocs MCP server. The whole point is that the conversation does not stop when a human closes the tab. An agent pushes a local skill up, a team edits and comments on it in the browser, and the agent reads back the diff and the threads, replies to them, and writes the result back over the local file:

you > push a skill to SkillDocs (skilldocs_open)
     → skilldocs.dev/?doc=release-notes-writer

— the team edits and comments in SkillDocs —

you > read the diff and comments, apply, reply (skilldocs_*)
     → skilldocs_diff    → 2 sections rewritten since the baseline
     → skilldocs_comments→ 2 open threads from Maya and Sam
     → skilldocs_reply   → answered both, applied the checklist reorder
     → skilldocs_pull    → wrote the doc back over the local file

Setup is one command and an API token, and the tools are scoped to your workspace. That closes a real loop: instead of an agent editing a skill blind and the human discovering the changes later, the review happens in a live document with real cursors, and the agent operates the same loop as a human reviewer — read the diff, read the comments, reply, pull. The document, its threads, and the argument about it all export as one structured Markdown blob in three shapes: the clean document, the document with threads appended and anchored, or just the feedback.

Why this is a different job from md2rich

Where SkillDocs begins to end, md2rich begins. SkillDocs keeps the Markdown source healthy and agreed-upon — the collaborate-and-refine half, aimed at the files that teach agents and teams how to work. Then the moment that document is finished, the job changes: turning it into a formatted post on the 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 share the same philosophy, which is why they pair cleanly rather than compete. Both assume the plain-text file, not the platform and not the chat window, is the durable asset; both are privacy-first and can run without shipping your words to a third-party server. The difference is directional. SkillDocs pulls humans and agents together around a living document to shape it; md2rich pushes a finished document out to an audience, in the format a platform expects. Concretely, a reviewed block of Markdown like this:

## Publishing the agreed skill

- Keep the source in plain Markdown where review happens.
- Once the doc and its threads are settled, convert 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 an X Article — no raw Markdown left in the paste box, no formatting lost.

SkillDocs and md2rich side by side

They do not overlap. SkillDocs makes the agent-facing Markdown reviewable by both humans and agents; md2rich makes the approved Markdown publishable to an external audience. You could realistically use both on the same file — SkillDocs to shape and agree the skill or spec in real time, md2rich to turn the finished Markdown into a public post without moving the source anywhere.

When each one is the right tool

SkillDocs earns its place the moment a Markdown document lives where several people and an agent have to agree on it — a shared skill, an instruction file, a runbook, or a spec that an agent reads. Its value is presence and anchored feedback: real cursors, comment threads bound to the words, and an MCP loop that hands the whole conversation back to the agent. It is brand new (Show HN August 20, 2026), so treat it as a fast-moving early tool rather than a settled platform, but the collaboration-layer idea is exactly what the agent-Markdown world has been missing.

md2rich earns its place the moment the document's destination is a rich-text platform. Your agreed Markdown is ready to publish; md2rich converts it in the browser with nothing uploaded, so a private skill, spec, or draft never needs to leave your machine to become a LinkedIn post or an X Article. 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 SkillDocs facts are sourced from the project's official site (skilldocs.dev) and its Show HN launch on August 20, 2026, and md2rich is referenced only for the conversion step.