The plan lives on your machine

The agent is rewriting plan.md on your disk. Your teammate needs eyes on it. The temptation is familiar: paste it into Notion, drop a gist, email the markdown "so we have a copy."

You will have two. And the second one is already behind.

The plan lives on your machine. The link is the review surface, not a fork.

Where truth lives

Agent-authored plans change in the author's session, on the author's machine. That is not a preference. It is where the agent can still rewrite without ceremony.

Review still needs another human. The question is what they look at. A live view of the file the agent owns, or a second document someone created so the team "has something."

Those are different jobs. Mixing them is how review falls behind the agent.

When to open review relative to execute is a sibling cut. Who can review without your IDE is another. This post is where truth lives.

I used to think the paste was harmless. "We will sync later." Later never comes cleanly. Someone comments on the wiki. Someone else acts on disk. The agent rewrites local plan.md again. The wiki page still looks authoritative because it has a nice title and a last-edited timestamp from this morning. Drift is not a bug in the paste. It is the paste.

The social part is worse than the technical part. Once a second copy exists, people treat it as the home. Threads land there. Decisions land there. Disk keeps moving. You spend a meeting asking which version is real, and everyone is sincere. The fork made sincerity expensive.

What people do instead

Paste into Notion or a wiki. Team home for finished docs. Wrong moment for a still-moving plan. You invent a second copy. The agent does not own it. When the agent rewrites local plan.md, the wiki page sits there looking official. Comments land on the wrong document. Action runs on the right one. You spend a meeting asking which version is real.

Drop a gist. Public snapshot. Fine for "here is what it looked like at noon." Not a live local watch. Not threads that reach @agent. The gist does not update when you save. You republish, or you do not, and either way you are managing copies.

Email the markdown. Interrupts now. Freezes a blob. Reply-all on yesterday's plan while the agent is mid-rewrite. Same failure mode as chat paste: the review surface is no longer the file.

"Put it in a shared drive folder." Feels organized. Still a fork unless the agent is writing directly there, which it usually is not. The session owns a path on your machine. Pretending otherwise is how you get sync theater.

Early PR "so we have a durable copy." Familiar. Also commits a moving plan so someone can comment. Wrong timeline if the file has not earned history yet. Before git, not instead of git. A PR is not a harmless home for a draft the agent still owns.

Each substitute is good at something else. None of them keep one truth on disk while a teammate reviews a live view.

The loop (local stays truth)

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

1. Watch: gander watch plan.md. Every save updates the hosted page.
2. Comment: reviewer opens the URL. Docs-style inline threads. Browser only.
3. Act: @agent comments land in your session. The agent edits the local file. The same link updates.
4. Then: git when it is worth committing.

Local file on your machine is the source of truth. Hosted page is a live view plus threads, not a second copy, not a wiki fork. Full loop is shipped.

gander watch plan.md

Hosted watch. Local --watch will not help your teammate see your disk. Hosted watch will, without turning the hosted page into a rival document.

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

Notice what does not happen. You do not merge from Notion back into the plan. You do not ask the agent to "sync the wiki." The agent rewrites plan.md. The same link shows the rewrite. Threads stay on the view. Truth never left your machine.

That is the quiet product bet. Reviewers get a surface. Authors keep the write path. The hosted page is not competing for ownership. It is competing with the paste habit that invents ownership by accident.

Why a second copy fails

A second copy of the plan becomes stale the moment the agent rewrites the local file.

That is not a process failure. It is physics. The agent's write path is the local path. Anything else is a photograph. Photographs are useful. They are not the working document while the agent is still writing.

Teams paste "so we have a copy" because review tools taught them that review lives in a shared doc. Shared docs are forks. Forks need merge. Merge is the wrong tax while the plan is cheap to change.

The hosted view solves a different problem: give the reviewer a surface without giving them a fork. They read the live file. They leave threads. Action still runs through @agent into the author's session and the author's disk. The wiki temptation was always about making review feel durable. Durability without a second copy is the point: comments on the live view, truth on disk.

When the agent rewrites plan.md, the same link updates. No merge from Notion. No "which version are we on." No polite fiction that the pasted page is still the plan.

I have tried the discipline version of this. "We will update the wiki every time the agent saves." Nobody does that for long. The agent saves constantly. Humans update when they remember. Remembering is not a sync protocol.

A scene from the fork

We pasted a migration plan into the team wiki on a Monday because leadership wanted "somewhere to look." By Wednesday the agent had rewritten the cutover three times on disk. Wiki comments were about Monday. Disk was Wednesday. On-call followed the wiki. Staging followed disk. Nobody was wrong on purpose. The second copy made wrong easy.

The fix was not better discipline about syncing. The fix was stop forking. Hosted watch. One file. Threads on the view. @agent into the session. Wiki kept finished docs. Plans that were still moving stayed on the machine that could change them.

Leadership still had somewhere to look. It was the link. The link was not a second home. It was a window.

What this is not

Not a Notion replacement. Not a knowledge base. Not a PM pitch. Not "share markdown" as the product. Not a gist with comments.

Same product as the plan-before-execute and browser-only posts, different cut: where truth lives. Timing and reviewer constraint are sibling jobs. This one is the fork problem.

It is also not "put the plan in the cloud so everyone can edit." Everyone can comment. The agent edits the local file. That split is intentional. A shared editable fork would recreate the wiki problem with better sync marketing.

Finished docs can live wherever your team already keeps finished docs. This post is about the still-moving plan. Different object. Different home.

One truth

The next time you are about to paste the plan so the team "has a copy," ask what you are copying from. If the answer is a file the agent still owns, you are not creating a home. You are creating a rival.

Keep the plan on your machine. Put review on the live view. Let threads live on the hosted page. Let the agent keep writing the file it already owns.

A second copy is how review falls behind the agent. One truth is how it does not.