Answering both of your questions from a different seat than Dean’s — I’m not reporting on
users, I’m one of the people running the cross-tool thing he says he hasn’t seen go
production-grade. So: one data point, with the disclosure up front that the tool involved
is my own project (MDflow).
What breaks first
My order is close to Dean’s but with a different #1. Commands and paths going stale never
really hurt me, because I stopped writing them anywhere except package.json. What breaks
first for me is the item that looks least dramatic on your list: agents don’t load the
right context at all. It never announces itself. You don’t get an error, you get an agent
confidently working from nothing, producing something plausible, and you find out two
commits later that it never read the decision doc explaining why the thing it just “fixed”
was written that way.
What fixed it wasn’t better instructions, it was making context findable without me naming
a path: every folder carries a short human-written description of what’s in it and why, and
the agent reads the descriptions before it reads any document. “Auth decisions live here,
this folder is append-only, don’t rewrite history” is something it learns from the folder
itself, not from my prompt and not by guessing.
Second: stale notes correlate almost perfectly with notes no human ever opens. Your
observation upthread is right, but the deeper version is that context rots because nobody’s
eyes land on it. Anything I read in normal work gets corrected as a side effect of reading
it. A memory store or vector index I never open has no such feedback loop — which is why
“old memories become wrong” survives every cleanup ritual you set for yourself.
Third, the ugly one nobody warns you about: two tools writing the same document. Claude
Code appends a session note, Cursor rewrites the same file ten minutes later from a stale
read, and the append is gone with no trace. The mitigations that mattered were all
unglamorous: compare-and-swap on save so a write from a stale read fails loudly instead of
silently winning; a log of every automated write labelled with the token that made it, with
a diff; version history that restores non-destructively; and a hard guardrail that an agent
cannot blank a document without an explicit confirm flag. That last one has saved me twice.
On cross-tool MCP: it works, but only for one kind of context
Claude Code, Cursor and Codex all read and write the same hosted markdown workspace over
MCP — token for the CLIs, OAuth for the Claude and ChatGPT apps. Daily driver for months,
not a weekend experiment. Two honest caveats, because Dean’s skepticism is pointed at the
right thing:
It does not work for repo facts. Build commands, paths, conventions stay in AGENTS.md next
to the code, exactly for the drift reason. What actually left the repo is the stuff that was
never about one repo: decisions and why they were made, notes spanning several projects,
research, handoff docs.
And “both tools have to be disciplined about when to write and when to retrieve” is a real
constraint, not a solved one. What made it tolerable is that the discipline is written down
where the agent looks first — the folder description — instead of living in each tool’s own
rules file where it drifts apart. Retrieval is still the model’s call, and it does sometimes
skip it. The difference is that I notice, because the document it should have read is a
document I read too.
Also plainly: the MCP side of what I use is on a paid tier, so it’s not a like-for-like
swap for a free local memory server.
