Any two is a feature

Live preview is a feature. The loop is the product.

If you are evaluating tools that "share markdown" or "live preview," that sentence is the whole argument. A pretty render of a still-moving plan is useful. It is not agent-plan review. Agent-plan review needs three pieces: a live hosted watch, Docs-style inline threads, and a path for the agent to act. Miss one and you are back to sharing.

What "done" means

The agent is still writing plan.md. You need another human on it now, not after you invent a commit so GitHub will show a diff, not after you paste a blob into chat that is already stale.

Done, for that job, is not "they can see the markdown." Done is:

1. A live link that updates when the file saves.
2. Inline threads the reviewer can leave without an IDE.
3. A way for a comment to reach the agent session so the agent edits the same file, and the same link updates.

That is watch + threads + @agent round-trip. Then git, when the file is worth committing. Before git, not instead of git.

Sibling cuts already covered when to review relative to execute and who can review without your IDE. This post is the product definition: which pieces have to be present.

I keep meeting demos that end on a beautiful live render and call that "review." Eyes on a page is not review. Review closes a loop. If the agent cannot hear the comment without a human pasting into a prompt, you stopped one step short.

That last step is where people get polite. "We will tell the agent." "I will paste it later." Later is how the loop dies. The three pieces exist so later is optional.

What people buy instead

Local or hosted markdown preview. Live render. Often beautiful. Usually missing: Docs-style threads that survive on the live doc, and @agent into the coding-agent inbox. You get eyes on the page. You do not get review that can close the loop. Local --watch sits in this bucket when people confuse it with hosted gander watch.

Gist / static share. A link. Fine for a snapshot. Usually missing: live watch of the local file, and any agent round-trip. You republish, or you do not. Either way the review surface is a copy, not the file the agent owns.

Notion comments. Real threads. Familiar. Usually missing: local-file truth and a coding-agent inbox. The wiki is a second document. Comments there do not summon the agent that is rewriting plan.md on disk.

Early PR. Familiar review UI. Usually missing: pre-commit live file + agent loop. You pay commit noise so someone can comment on text the agent is still allowed to rewrite. After-commit review is a different job. Hand off to the PR when the file is ready. Do not use PR review as a pre-git plan surface.

Chat paste plus "I will tell the agent." Human middleware. Works until you are tired. Then it does not.

Each substitute is good at something else. Map them honestly: they often have one or two of the three pieces. The missing piece is what drops you into the wrong category.

I am not trying to dunk on preview tools. I use preview. Preview is piece one when it is hosted and live against the local file. Calling preview "review" is the category error.

The three pieces

Gander is live review for markdown an agent is still writing.

1. Watch: gander watch plan.md. Every save updates the hosted page. Live hosted watch, not a frozen paste.
2. Comment: reviewer opens the URL. Docs-style inline threads. Browser only. Author installs; reviewer does not.
3. Act: comments starting with @agent reach the agent session. The agent edits the local file. The same link updates.
4. Then: git when it is worth committing.

Full loop is shipped. Local file stays source of truth; hosted page is live view plus threads. Human-only threads are useful. They are not the agent round-trip. Only @agent is.

gander watch plan.md

That is piece one in a command. Pieces two and three live on the page that command publishes. Local --watch is not a substitute for piece one when someone else needs the URL.

gander watch plan.md → comment → @agent → same link updates → then git.

Install MCP once so the session hears the summons (gander mcp install), or fall back to gander comments. The reviewer still needs nothing but the browser. The three pieces are not three installs for three people. Ceremony stays with the author. Participation stays cheap.

Any two is a feature

Treat this as product framing, not a market survey.

Watch + threads, no @agent. You have a live share tool with comments. The reviewer can leave notes. Someone still has to paste those notes into the agent prompt. That is not the round-trip. If the agent cannot act on the comment, it is not the round-trip.

Watch + @agent, no durable inline threads. You can summon the agent somehow, but the review surface is not Docs-style on the live doc. You lose the place where humans leave anchored feedback while the file is still moving.

Threads + @agent, no live hosted watch. Comments and action without a live view of the file the agent is still writing. You are back to arguing about a snapshot, or a wiki fork, while disk moves underneath.

Any two is a feature. All three is the product. Shipping live preview alone re-enters the old "share markdown" category, the category the homepage and docs already left. Preview is a piece. The product is the loop.

Local file as source of truth is a sibling spine: hosted is view + threads, not a fork. Survive-the-rewrite is another: comments should survive on the same link when the agent rewrites the page. This post does not rewrite those spines. It says why you need the full set before you call the category.

I like the bluntness of "any two is a feature" because it keeps demos honest. Beautiful render? Feature. Threads without a summons? Feature. Summons without a live link? Feature. Say the word product when the third piece shows up and the same link updates after the edit.

A checklist you can run in a demo

Next time a tool demo ends on a live render, count out loud.

One: does the link update when the local file saves, without republishing by hand?

Two: can a reviewer leave inline threads in a browser without cloning or installing?

Three: can a comment reach the coding-agent session so the agent edits the same file and the same link updates, without a human pasting into the prompt?

If you only have one, you have preview. If you have two, you have a feature. If you have three, you can talk about agent-plan review without lying to yourself. Then git, when the file earns it.

Run the checklist on your own loop too. Plenty of teams invent three tools for three pieces and call that a workflow. The question is whether the pieces meet on one live file. If the answer is "Slack plus gist plus I paste into Cursor," you have three features and a tired author.

What this is not

Not a feature laundry list. Not a competitive teardown chart. Not "only tool that…" Not invented category leadership. Not traction. Not "share markdown" as the lead. Not replace GitHub or Notion.

Same beachhead as the rest of the week: engineer author, browser reviewer, plan still changing. Same product as plan-before-execute and browser-only, different cut: product definition against preview/share substitutes.

It is also not a demand that every afternoon use all three pieces. Solo local preview is fine when you are alone with the buffer. The category claim starts when another human has to review a still-moving agent plan. Then the three pieces are the definition of done.

Do not buy a share tool and call it agent-plan review

The next time a tool demo ends on a live render and calls that "review," count the pieces. Live watch? Inline threads? Can the agent act on the comment without a human pasting into the session?

If you only have preview, you have a share tool. Useful. Wrong category for agent-plan review.

Watch + threads + @agent. Miss one and you are back to sharing. All three, then git.