Migrating from Cursor to ChatGPT: The 2026 Memory Playbook

Cursor has no native push to ChatGPT. You'll copy .cursorrules, .cursor/rules/*.mdc bodies, and Notepads into ChatGPT as either Custom GPT Instructions (per repo) or Custom Instructions plus Memory entries (global). Plan 15–25 minutes per repo. A shared MCP-based memory layer like MemoryLake lets both tools read the same source.

Three drivers in 2026:

• Multimodal and voice modes. ChatGPT covers more conversational and creative surfaces than an IDE.
• GPT Store and Custom GPT distribution. Sharing assistants with teammates or customers is easier in ChatGPT.
• Browser-first workflows. Some teams move away from IDE-bound assistants for cross-device access.

Different scopes.

Cursor memory is repo-scoped first: `.cursorrules`, *`.cursor/rules/.mdc`, Notepads, and user-level Rules for AI**.

ChatGPT memory spans Custom Instructions (global), Memory (saved facts pulled across chats), and Custom GPTs (project-like containers with their own Instructions and Knowledge).

.cursorrules and .mdc rules become Custom GPT Instructions or, for cross-repo guidance, Custom Instructions. Notepads become saved prompts in a "prompts" Custom GPT or as Conversation Starters. User-level Rules for AI become Custom Instructions.

Rules are files you copy.

1. Locate your repo's rules. Check .cursorrules and .cursor/rules/.
2. Read each `.mdc` rule's body. Note frontmatter context and capture into prose for chat consumption.
3. Export Notepads. Open Cursor's Notepads panel and copy each Notepad into a notepads.md.
4. Capture user-level Rules for AI. Settings → Rules for AI.
5. Gather repo docs. If docs/, README.md, or ARCHITECTURE.md matter, collect them.

End state: one folder per repo with the rules content, notepads.md, cursor-user-rules.txt, and reference docs.

ChatGPT lands the import across three surfaces.

1. Create a Custom GPT per repo. Open GPT Builder → Create. Paste .cursorrules plus condensed .mdc rule bodies into Instructions.
2. Upload repo docs as Knowledge. Attach README.md, ADRs, style guides, and similar reference content.
3. Add Conversation Starters. Use four common Notepads as starters; keep the rest in Instructions as referenced prompts.
4. Promote universal rules to Custom Instructions. Settings → Personalization → Custom Instructions. Paste user-level Rules for AI content.
5. Pin enduring facts to Memory. Settings → Personalization → Memory. Add anything that should apply across every chat.
6. Validate. Open the Custom GPT and run a moved Notepad to confirm context lands.

• In-IDE flow. Tab acceptance and Cmd-K live in the IDE; ChatGPT is browser-first.
• `.mdc` glob behavior. Glob-based selective application doesn't translate; you mention applicable paths in prose.
• Cursor MCP servers. Each becomes a Custom GPT Action (manual rebuild) or doesn't translate.
• Ongoing sync. New .cursorrules edits next week won't appear in your Custom GPT unless you redo the copy.

If you keep Cursor for coding and use ChatGPT for everything else, per-tool drift starts immediately. Cross-repo standards end up in two places.

MemoryLake holds those rules once and exposes them through MCP. Cursor supports MCP, and ChatGPT can read MemoryLake through a Custom GPT Action calling its REST endpoint.

• One source of truth. Update once; both tools see the change.
• Cross-repo standards. Team conventions live above any single repo.
• Drop-in for the next tool. Add Claude or Windsurf with a config change.

Step 1: Create a project and load your context

Sign in to MemoryLake, open Project Management, and click Create Project. Name it "Cursor ↔ ChatGPT shared context." Drag reference docs (PDF, Word, Excel, PowerPoint, Markdown, or images) into the Document Drive under My Space, then open the Documents Tab and click Add Documents. Paste your .cursorrules, .mdc bodies, Notepads, and user-level rules into the Memories Tab via Add Memory.

Step 2: Generate an MCP Server endpoint

Open the MCP Servers Tab inside the project, click Add MCP Server, describe it (e.g., "Cursor + ChatGPT bridge"), and click Generate. MemoryLake returns a Key ID, a Secret, and an Endpoint URL. Copy the Secret immediately — it is shown only once.

Step 3: Point both tools at the endpoint

In Cursor's MCP configuration (e.g., .cursor/mcp.json), add a MemoryLake server entry with the endpoint URL and the Secret as a Bearer token. For ChatGPT, configure a Custom GPT Action that calls the same REST endpoint with the Bearer token to fetch project memory.