Why does Cursor forget my house conventions?

Cursor forgets your house conventions because conventions live as tacit team knowledge that Rules files cannot fully capture, Memories are auto-generated per workspace and not shared with teammates, and the model falls back to internet-average defaults whenever convention guidance loses prompt weight. The fix is a shared, queryable convention memory that every teammate's Cursor reads from.

Cursor's Project Rules and Memories try to capture per-team norms. The mechanics still miss the unwritten half.

1. Conventions are tacit. Most of what makes house style "house" is not written down. It lives in code review comments, Slack threads, and the implicit choices senior engineers make. Rules files capture the explicit fraction; the rest only shows up when a senior reviewer catches it in PR.

2. Memories are per workspace, per developer. Cursor's Memories feature is workspace-scoped and built from chat history. The conventions you taught Cursor on your machine are not the conventions Cursor sees on your teammate's machine. New hires get a Cursor that has learned nothing about your team yet.

3. Internet defaults are loud. When in-prompt convention guidance loses weight, the model falls back to the dominant patterns it saw in training, which are the patterns of every public React/Node repo on the internet. Your house style does not stand a chance against that signal unless it is actively retrieved.

The result: Cursor mirrors the internet on cold tasks and your team only when it has recently been reminded.

Every house-style miss costs you review cycles, and the loss compounds across hires and teammates:

• New hires get average code. Your Cursor knows your conventions; your new hire's Cursor does not, so their first PRs look like internet React instead of your codebase.
• Code review re-teaches the same lessons. "Wrap fetches in our useApi hook, not raw SWR" becomes a comment you leave four times a week instead of a rule the AI enforces.
• Style drift compounds. Each generated file that misses a small convention adds a small inconsistency, and after a quarter the codebase has measurably drifted toward the model's defaults.

The fix is not "write a longer style guide." It is to make the team's conventions queryable memory that every teammate's Cursor reads from automatically.

Cursor has shipped real features here. Each helps. None of them close the gap.

*Project Rules (`.cursor/rules/.mdc)** capture explicit conventions per project, with frontmatter, globs, and alwaysApply` for scoping. They are good at the rules you have already articulated. They are weak at the tacit ones nobody has written down yet, and they share prompt budget with code.

Memories auto-generate short rules from chat history and scope them to the project. They are useful as a baseline but are summaries of what Cursor inferred you wanted, not a shared team contract, and they live per workspace on one machine.

Native MCP support lets Cursor connect to external memory through .cursor/mcp.json or the Settings UI. This is the cleanest path for shared, team-wide conventions, because MCP returns context on demand from a single source of truth.

You can read Cursor's own breakdown of Rules and Memories in the official Cursor docs.

For solo projects, the natives are fine. For teams, they fragment.

The deeper issue is that house conventions are a team artifact, not an individual one. They evolve in code review, they get clarified in retrospectives, and they need to apply to every teammate's editor consistently. A .cursor/rules/*.mdc file in the repo helps, but it cannot capture decisions made yesterday in a PR comment, and it cannot be read by Claude Code, Cline, or Windsurf if a teammate uses one of those instead of Cursor.

That is what a cross-tool memory layer fixes: one team convention store, fed by reviews and decisions, retrieved on demand by every AI editor on the team.

MemoryLake is a cross-model memory layer that sits between you and every AI you use. Instead of relying on Rules and Memories that live per workspace, your team puts conventions in a shared MemoryLake Project, and every teammate's Cursor reads from that Project through MCP.

• Shared team memory. Conventions are stored once and accessible to every teammate's editor, so a rule clarified in a PR is enforced in the next AI-generated file on someone else's machine.
• Tacit knowledge made explicit. Capture review feedback ("we wrap fetches in useApi, not raw SWR") as structured Memories the moment it comes up, and have it enforced from then on.
• Portable to every other AI coding tool. The same convention memory works in Claude Code, Cline, Windsurf, and any MCP-aware editor. New hires get the team's conventions on day one regardless of which tool they use.

MemoryLake 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 team project and load your conventions. Sign in to MemoryLake, open Project Management, click Create Project, and name it after the repo and team (for example, "Cursor - web-team house style"). Drop your style guide, ADRs, and a few canonical reference files into the Document Drive. Capture tacit conventions ("we use useApi, not raw SWR", "migrations live in db/migrations/<YYYYMMDD>/") in the Memories tab so they are retrievable by topic.
2. Generate an MCP Server endpoint. Open the MCP Servers tab inside your project, click Add MCP Server, name it "Cursor integration", and click Generate. MemoryLake returns an API key ID, secret, and endpoint URL. Copy the secret immediately, since it is shown only once. Share the endpoint with the team; each teammate uses their own Bearer token.
3. Connect Cursor. Cursor has had native MCP support since 2025, which makes this the cleanest path. Each teammate adds a MemoryLake server entry to .cursor/mcp.json at the repo root (or wires it through Cursor Settings > Features > MCP) with their endpoint and Bearer token, then reloads Cursor. House conventions now load on demand in every teammate's editor.