Why does Windsurf forget my architectural decisions?

Windsurf forgets architectural decisions because Cascade has no persistent cross-session memory of past chats, and the .windsurfrules file is too small (~6,000 character cap) to hold full ADRs with rationale. Decision detail dies in old sessions and gets compressed in long ones. A retrievable project memory makes decisions queryable across every chat and every tool.

Architecture decisions are the highest-value context in a codebase and the worst-served by every editor's native memory. Three Cascade mechanics drive the loss:

1. No cross-session memory for chat content. Cascade Memories captures short workspace-scoped notes. It is not designed to store the full reasoning chain of a 90-message design discussion. When you open a new chat, the why behind every decision is sitting in the chat sidebar — readable by you, invisible to the agent.

2. Rules files are too small for ADRs. A real ADR has context, options considered, decision, consequences, and follow-ups. Cramming half a dozen of those into a 6,000-character .windsurfrules is not realistic. Most teams give up and write a single line: "use Drizzle". The line survives. The rationale does not, so Cascade keeps re-proposing rejected options.

3. In-session summarization compresses the why. Codeium has documented improvements to Cascade's summarizer because earlier versions dropped important context. Even now, summarization is lossy. The reasoning gets paraphrased into a short sentence, and Cascade loses the constraints behind it.

Lost rationale is the most expensive kind of context loss:

• Rejected options come back to life. Prisma was already evaluated and rejected. Without the why, Cascade proposes it again — and without your push-back, a junior dev or a less-skeptical reviewer might accept it.
• Decisions get re-litigated every sprint. "Do we use Redis?" was answered in March. With no retrievable record, it gets re-asked in May, and you waste a session re-deciding.
• New code violates old decisions silently. "All payments through Stripe Checkout, never raw API" was decided once. The next feature uses raw API, because the constraint never reached the agent.

Windsurf has three relevant mechanisms. None is built for ADR-scale content.

`.windsurfrules` can hold a few one-liners about your stack. It cannot hold full ADRs because of the practical character cap and because Cascade summarizes loaded rules as sessions grow.

Cascade Memories auto-generate short notes during chats. Useful for "user prefers small PRs". Useless for "we chose Drizzle over Prisma because of these five constraints in this order".

Workflows can script repeatable procedures. Not a memory feature; will not help.

You can read the official Cascade Memories docs for the full feature surface.

For tiny preferences, the natives work. For your team's architecture rationale, they are not built for the job.

Architectural decisions are not editor-scoped. They are project-scoped, often org-scoped. The same "we picked Drizzle" decision applies whether you are in Cascade, Cursor, Claude Code, ChatGPT, or a code review tool. None of Windsurf's native features travel beyond Windsurf, and ADRs in a /docs/adr/ folder are only useful if every agent in every tool can actually find and use them.

Memory needs to follow the project, not the editor.

MemoryLake is a cross-model memory layer that connects to Windsurf via Cascade's native MCP support. Instead of trying to cram ADRs into a rules file, you load your ADR folder and your design discussions into a project, and Cascade retrieves the relevant decision per turn.

• ADRs as first-class memory. Drop your /docs/adr/ folder, RFCs, and past design discussions into the project. When Cascade is about to scaffold a data layer, it can pull "ADR-014: ORM choice" and see the full rationale, not a one-liner.
• 10,000× more context than raw prompting. MemoryLake's retrieval engine reads from billions of tokens of project memory and returns only the relevant ADR per turn. No rules-file cap, no summarization drift.
• One decision log across every AI. The same ADRs are visible in Cursor, Claude Code, ChatGPT, Claude Desktop, and Gemini. A new dev opening any tool sees the same decisions for the same reasons.

MemoryLake also offers Git-style version control for memory, so when an ADR is superseded, you get the diff and the history — not a silent overwrite. It scored 94.03% on the LoCoMo long-context benchmark, the top published result as of 2026, with millisecond retrieval and AES-256 end-to-end encryption.

1. Create a project and load your decision history. Sign in to MemoryLake, open Project Management, click Create Project, and name it after your repo (e.g., "acme-platform — ADRs"). Upload your /docs/adr/, RFC folder, and exported Cascade chats through the Document Drive (PDF, Markdown, Word, Excel, images all supported). Add short summaries of key decisions in the Memories tab for fast retrieval.
2. Generate an MCP Server endpoint. Open the MCP Servers tab inside your project, click Add MCP Server, name it "Windsurf integration", and click Generate. MemoryLake returns an API key ID, secret, and endpoint URL. Copy the secret immediately — it is shown only once.
3. Add the server to Cascade's MCP config. In Windsurf, open Settings → Cascade → Manage MCPs → View raw config, then add a memorylake entry with the endpoint URL and your Bearer token. Save and restart Cascade. Cascade now has a memorylake tool it can call to look up the decision history before it writes architecture-shaped code.