The complaint is everywhere. Open any thread about Cursor, Windsurf, Cline, Copilot, or Claude Code and the top reply is the same: "It forgot what we were doing."
For months I assumed this was a context-window problem. The model runs out of tokens, the conversation history gets truncated, and the agent loses the plot. The fix seemed obvious: bigger context windows, better summarization, smarter retrieval.
Then I saw a post on r/SideProject by a developer who took the time to actually check what six different AI coding tools write to the filesystem during a session. The results reframed the problem entirely.
Half the tools write nothing
The test was simple: give each tool a multi-step task, then check what files it created or modified on disk — not in the chat, not in its internal memory, but on the actual filesystem.
Three of the six tools wrote zero files. They kept the entire plan, the context, the "memory" of what they were doing inside the conversation context. When that context filled up or the session reset, the plan vanished.
The other three tools wrote to disk. They created spec files, todo lists, progress markers — artifacts that persisted beyond the context window. Those tools didn't forget.
The filesystem is the real context
This shouldn't be surprising. The filesystem is the only durable, inspectable, shareable memory a developer has. Git works because commits are files. Make works because timestamps are on files. Every build system, every CI pipeline, every deployment tool relies on the filesystem as the source of truth.
An AI coding tool that doesn't write its plan to disk is treating the filesystem as a write-only target — it edits code but never records why or what's next. That's not an agent. That's a very fancy autocomplete with a chat sidebar.
What the writing tools actually write
The three tools that persisted state wrote different things:
- Spec/plan files — a markdown file describing the task, the approach, the acceptance criteria
- Todo lists — checkbox-style progress trackers that update as work completes
- Context summaries — periodic checkpoints summarizing what was done, what's blocked, what's next
None of this requires a new file format. It's markdown. It's plain text. The only requirement is that the tool chooses to write it and reads it at the start of each turn.
Why this matters for MCP and agent infrastructure
If you're building on MCP (Model Context Protocol), this insight changes how you design servers and clients.
An MCP server that exposes a "workspace memory" resource — a simple file the agent reads on initialization and writes before each tool call — solves the forgetting problem at the protocol level. The agent doesn't need a bigger context window. It needs a durable scratchpad.
This is also why the MCP filesystem server is one of the most important primitives in the ecosystem. It's not just "file access." It's shared durable memory between the human, the agent, and any other tool in the loop.
The practical takeaway
If you're evaluating AI coding tools today, don't ask about context window size. Ask:
- Does it write a plan to disk before it starts coding?
- Does it update that plan as it works?
- Can I read that plan myself, edit it, hand it to another tool?
If the answer is no, the tool will forget. Not because the model is limited, but because the architecture treats memory as ephemeral chat history instead of durable filesystem state.
The fix isn't more tokens. It's fs.writeFile.
Everything the lab builds in public stays in public. The source is on GitHub, and the current build is a live AI quoting engine for home service contractors.