Cómo migrar de Claude Code a Cursor sin perder el contexto (2026)

Tu prosa de CLAUDE.md, como contenido. Comandos de compilación, convenciones, notas de arquitectura, reglas de "hacer siempre X". Cursor lee AGENTS.md — "Instrucciones del agente en formato markdown. Alternativa simple a .cursor/rules" — en la raíz del proyecto y en los subdirectorios. Renombra o copia, y listo. Ten en cuenta que esto es lo opuesto a la restricción del lado de Claude Code, donde la documentación es explícita: "Claude Code lee CLAUDE.md, no AGENTS.md."

Reglas con alcance de ruta, con un mapeo uno a uno real. Esta es la parte más limpia de toda la migración y la mayoría de la gente la pasa por alto. Los archivos .claude/rules/ de Claude Code aceptan un campo de frontmatter paths: con patrones glob, y "Las reglas sin un campo paths se cargan incondicionalmente y se aplican a todos los archivos". Las reglas de proyecto de Cursor utilizan globs en el frontmatter de .mdc con la misma intención: con alwaysApply: false y los globs proporcionados, la regla se "adjunta automáticamente cuando un archivo coincidente está en contexto". Así, una regla con alcance src/api/**/*.ts en Claude Code se convierte en una regla con alcance src/api/**/*.ts en Cursor. Misma sintaxis de patrón, misma idea.

Tus preferencias personales, en un panel de configuración. La capa a nivel de usuario de Claude Code es ~/.claude/CLAUDE.md más ~/.claude/rules/. La de Cursor es User Rules — "preferencias globales definidas en Customize → Rules que se aplican a todos los proyectos". Mismo trabajo. Una advertencia que vale la pena conocer antes de confiar en ella: "Las User Rules no se aplican a Inline Edit (Cmd/Ctrl+K). Solo las utiliza el Agent (Chat)."

Instrucciones para toda la organización, en un panel de control. Claude Code admite una política gestionada CLAUDE.md desplegada por TI en una ruta a nivel de sistema operativo. La contraparte de Cursor es Team Rules, creadas desde el panel de Cursor en los planes Team y Enterprise, donde "Enforce this rule: Cuando está habilitada, la regla es obligatoria para todos los miembros del equipo y no se puede desactivar en Customize."

Nada más. Aquí está la lista específica.

La memoria automática no tiene destino. Claude guarda cuatro tipos de notas para sí mismo, registradas como un campo type en el frontmatter de cada archivo: user (tu rol y preferencias de trabajo), feedback (correcciones que le das a Claude y enfoques que confirmas), project (trabajo en curso y decisiones que Claude no puede deducir del código o del historial de git) y reference (dónde encontrar cosas fuera del proyecto). Omite deliberadamente lo que puede leer del código base y "cualquier cosa que tus archivos CLAUDE.md ya digan", lo que significa que la memoria automática contiene, por diseño, exactamente el material que no está escrito en ningún otro lugar. Y no viaja: "La memoria automática es local de la máquina. Todos los árboles de trabajo (worktrees) y subdirectorios dentro del mismo repositorio de git comparten un único directorio de memoria automática. Los archivos no se comparten entre máquinas o entornos en la nube". Léela antes de irte.

Las importaciones @path no tienen equivalente en Cursor. CLAUDE.md puede incorporar otros archivos con la sintaxis @path/to/import, de forma recursiva, "con una profundidad máxima de cuatro saltos", y los archivos importados "se expanden y se cargan en el contexto al inicio". El mecanismo más cercano de Cursor es @filename.ts dentro de una regla, lo cual confirma la sección de preguntas frecuentes: "Usa @filename.ts para incluir archivos en el contexto de tu regla", pero no es una cadena de importación y no se compone a cuatro niveles de profundidad. Un árbol de importación de cuatro saltos debe aplanarse en un solo archivo o dividirse en varias reglas.

CLAUDE.local.md pierde su forma. Es la capa personal ignorada por git en la raíz del proyecto, "para preferencias privadas por proyecto que no deben incluirse en el control de versiones". Las User Rules de Cursor son globales en lugar de por proyecto, por lo que una nota personal que solo tenía sentido en un repositorio se vuelve global o se convierte en un AGENTS.md sin confirmar que debes recordar no incluir en el commit (stage).

El manejo de conflictos funciona de manera diferente, y esto cambia el comportamiento. Claude Code: "Todos los archivos descubiertos se concatenan en el contexto en lugar de sobrescribirse entre sí", ordenados desde la raíz del sistema de archivos hacia abajo, y si dos archivos no coinciden, "Claude puede elegir uno de forma arbitraria". Cursor establece una precedencia real: "Las reglas se aplican en este orden: Team Rules → Project Rules → User Rules. Todas las reglas aplicables se fusionan; las fuentes anteriores tienen precedencia cuando hay conflictos de directrices". Si has estado viviendo con una contradicción que Claude Code resolvía lanzando una moneda al aire, Cursor la resolverá de manera consistente, posiblemente no de la forma a la que te habías acostumbrado.

Los hooks no se trasladan. Claude Code es explícito sobre la vía de escape: "Para bloquear una acción independientemente de lo que decida Claude, utiliza un hook PreToolUse en su lugar". Eso es control de ejecución en lugar de contexto, y no forma parte del sistema de reglas que estás migrando.

La memoria de los subagentes ya estaba separada. "La memoria automática de la conversación principal no se carga en los subagentes", y la memoria automática de un subagente es su propio directorio: un estado por subagente que se queda atrás. Ese límite se explica en por qué los subagentes de Claude Code no comparten memoria.

Paso 1: Vuelca lo que realmente está cargado, antes de cambiar nada

No puedes migrar una configuración que no has leído, y en Claude Code el conjunto cargado rara vez es el que recuerdas haber escrito.

Ejecuta /context en una sesión y lee la lista bajo Memory files. Esa es la única verdad sobre qué archivos CLAUDE.md y CLAUDE.local.md lograron entrar; la documentación lo usa como el primer paso de depuración, porque "Si falta un archivo allí, Claude no puede verlo". Los archivos por encima de tu directorio de trabajo se cargan al inicio; los archivos en subdirectorios "se cargan bajo demanda cuando Claude lee archivos en esos directorios", por lo que una regla de subdirectorio que nunca coincidió no aparecerá.

Luego ejecuta /memory. Listará las ubicaciones de tus archivos CLAUDE.md, CLAUDE.local.md y otros archivos de memoria, y te dará la opción de abrir la carpeta de memoria automática. Ábrela. Todo lo que hay allí es markdown simple que puedes leer, editar o eliminar, y los archivos feedback y project suelen ser los párrafos de mayor valor en toda la configuración: las correcciones que diste, los plazos, las decisiones que no están en el código. Copia lo que aún importe en algo portable. No va a pasar a Cursor por sí solo.

Dos cosas que vale la pena notar mientras estás allí. MEMORY.md solo se carga hasta "las primeras 200 líneas de MEMORY.md, o los primeros 25 KB, lo que ocurra primero", por lo que si es largo, la parte final no se estaba leyendo de todos modos. And los archivos de temas no se cargan en absoluto al inicio; Claude "los lee bajo demanda utilizando sus herramientas de archivos estándar". Si deseas la auditoría como un registro en lugar de a simple vista, el hook InstructionsLoaded registra "exactamente qué archivos de instrucciones se cargan, cuándo se cargan y por qué".

Paso 2: Reconstruye las capas en Cursor, decidiendo el formato de una vez

Cuatro decisiones, en este orden.

Instrucciones del repositorio: AGENTS.md o .cursor/rules. Copia CLAUDE.md a AGENTS.md y estarás operativo de inmediato. Convierte a .cursor/rules solo lo que quieras cargar de forma condicional; esa es la capacidad que te brinda el frontmatter de .mdc. Los cuatro tipos de reglas de Cursor son Always Apply, Apply Intelligently ("Cuando el Agent decide que es relevante según la descripción"), Apply to Specific Files ("Cuando el archivo coincide con un patrón especificado") y Apply Manually ("Cuando se menciona con @ en el chat"). Si ya tenías reglas con alcance paths:, esas son las que debes convertir; el resto puede seguir siendo prosa.

Atención a la extensión. "El sistema de reglas ignora un archivo .md simple en .cursor/rules porque no tiene frontmatter para especificar description, globs y alwaysApply. Si prefieres markdown simple, usa AGENTS.md en su lugar". Soltar tus antiguos archivos de reglas en ese directorio sin cambios es la forma más común de migrar hacia el silencio.

Aclana las importaciones. Resuelve cada cadena @path en el archivo que la referencia, o en reglas separadas. Vigila la longitud mientras lo haces: la guía de Cursor es "Mantener las reglas por debajo de 500 líneas" y "Hacer referencia a los archivos en lugar de copiar su contenido; esto mantiene las reglas cortas y evita que se queden obsoletas a medida que cambia el código". Claude Code apunta en la misma dirección, con un objetivo de "menos de 200 líneas por archivo CLAUDE.md".

Separa lo global de lo local. Las preferencias personales van a Customize → Rules. Las convenciones del repositorio van a AGENTS.md o .cursor/rules y se confirman (commit). Un AGENTS.md anidado te brinda alcance de directorio sin ningún frontmatter: las instrucciones "se combinan con los directorios principales, teniendo precedencia las instrucciones más específicas".

Si tu equipo comparte reglas, usa Remote rules. Cursor puede importar reglas desde un repositorio de GitHub: Customize → Rules → Add Rule → Remote Rule (Github), pega la URL del repositorio y "Cursor buscará todos los archivos .mdc en el repositorio", colocándolos en .cursor/rules/imported/<repoName> mientras conserva las rutas relativas. Es solo para .mdc, por lo que es una razón para convertir en lugar de mantener la prosa, y es lo más parecido que tiene cualquiera de las dos herramientas a una fuente de reglas compartida y actualizable.

Si terminas ejecutando ambos durante un tiempo, la dirección inversa está descrita en migrar de Cursor a Claude Code, y la cuestión del estándar de archivos se cubre en migrar tu CLAUDE.md a AGENTS.md.

Mira lo que acabas de hacer en el Paso 1. Abriste una carpeta de notas que Claude escribió sobre tu proyecto durante meses, la leíste a mano y copiaste las partes buenas en otro lugar. Eso funcionó, y funciona exactamente una vez.

La razón por la que es manual es estructural. La memoria automática es local de la máquina por diseño. Las reglas de Cursor son por repositorio y controladas por versiones por diseño. Ambas herramientas limitan lo que transportan — 200 líneas aquí, 500 líneas allá — porque el contenido siempre activo se envía con cada solicitud. Ninguna está diseñada para ser el almacenamiento duradero de por qué tu arquitectura es como es, y ninguna pretende serlo.

Eso es lo que almacena MemoryLake: el conocimiento duradero de tu proyecto en una capa de la que leen tus herramientas, de modo que un cambio de herramienta deja de ser una transferencia de conocimiento. La configuración consta de tres pasos.

Paso 1: Crea una clave API

Inicia sesión en MemoryLake y crea una clave API. Una sola credencial para todas las herramientas que conectes.

Paso 2: Sube tus primeras memorias

Entradas cortas, una afirmación cada una. La carpeta de memoria automática que acabas de leer es tu material de origen; ya está clasificada aproximadamente en las categorías correctas:

Correcciones que tuviste que dar más de una vez. Esta es la propia categoría feedback de Claude Code, y es lo más valioso del directorio. Muévela a un lugar donde ambas herramientas puedan leerla.

Decisiones con la restricción que las forzó. "Las migraciones son solo aditivas porque la réplica de lectura se retrasa bajo carga". Una regla establece la política; solo esto evita que se vuelva a proponer la alternativa la próxima semana.

Enfoques que ya rechazaste y por qué. La categoría que no aparece en ningún archivo de reglas ni en ningún mensaje de commit. Cada nuevo agente vuelve a proponerlo.

Hechos del entorno que aprendiste por las malas. La prueba que solo falla en CI, el límite de velocidad que no está documentado, la base de datos de staging sin filas recientes.

Paso 3: Conecta tu IA y agentes

Conecta las herramientas que utilizas. Se puede acceder a MemoryLake a través de MCP y de una API, por lo que los agentes nativos de MCP — entre ellos Claude Code, Codex y OpenClaw — se conectan apuntando al servidor MCP, mientras que otros asistentes leen la misma memoria a través de la API. Esto es lo que hace que el cambio sea reversible: ambos editores pueden leer la misma capa mientras aún estás decidiendo.

Tres límites honestos. MemoryLake no lee tu carpeta de memoria automática y no escribe tu CLAUDE.md ni tus reglas de Cursor — el Paso 1 sigue siendo una lectura manual, y los archivos de reglas son la forma en que diriges cada herramienta. Solo contiene lo que tú o tus agentes introducen en ella. Y tanto las reglas como la memoria son contexto en lugar de una configuración forzada; si necesitas que algo suceda siempre sin importar qué, eso es un hook o una verificación de CI, no una capa de memoria.

El cambio deja de ser una puerta de un solo sentido. Que ambos editores lean la misma memoria externa significa que puedes usar Cursor durante dos semanas sin desmantelar tu configuración de Claude Code.

Vale la pena leer la memoria automática incluso si te quedas. La mayoría de la gente nunca ha abierto esa carpeta, y los archivos project and feedback son un resumen sorprendentemente bueno de los últimos seis meses.

Los archivos de reglas se vuelven más cortos en la nueva herramienta. Un CLAUDE.md supera las 200 líneas porque está haciendo dos trabajos: dirigir y recordar. Divídelos una vez y el límite de ninguna de las dos herramientas te frenará.

"Aún no conoce mi proyecto" obtiene una respuesta real. No "escribe más reglas", sino "ese conocimiento nunca estuvo en las reglas", el caso general en por qué RAG no es memoria.

Abre la carpeta de memoria automática antes de hacer cualquier otra cosa. Es la única parte de tu configuración que no tiene un importador al otro lado, y es la parte que tú no escribiste.

Confía en /context, no en tu memoria de lo que escribiste. La lista de archivos de memoria (Memory files) es lo que realmente se cargó. Los archivos de subdirectorios que nunca coincidieron no estarán allí.

Convierte las reglas paths: a globs, mantén el resto como prosa. El mapeo es directo. Todo lo demás es más práctico como AGENTS.md.

Nunca dejes un .md simple dentro de .cursor/rules. Se ignora silenciosamente. Usa .mdc con frontmatter, o AGENTS.md.

Aclana las importaciones @path en lugar de recrearlas. Las referencias @filename de Cursor no son una cadena de importación de cuatro saltos.

Decide dónde deben quedar las contradicciones. Cursor fusiona con Team Rules sobre Project sobre User; Claude Code concatenaba y elegía arbitrariamente. Resuelve los conflictos con los que te habías estado saliendo con la tuya.

Coloca las preferencias globales en User Rules, y ten en cuenta la brecha de Inline Edit — se aplican a todos los proyectos pero no a Cmd/Ctrl+K.

Mantén el razonamiento fuera de ambos sistemas de reglas. Las reglas son dirección e indicadores; el argumento detrás de una decisión es lo que permite a un agente manejar el caso que no previste, el aspecto cubierto en por qué los agentes ignoran los archivos de instrucciones que escribiste.

Pasar de Claude Code a Cursor es fácil en el papel y con pérdidas en la práctica, y la división no está donde la gente espera. Tu CLAUDE.md se convierte en AGENTS.md con un cambio de nombre. Tus reglas con alcance paths: se mapean en los globs de Cursor casi exactamente. Tu archivo a nivel de usuario se convierte en User Rules, y un archivo de política gestionada se convierte en Team Rules.

Lo que no se traslada es todo lo que Claude escribió para sí mismo. La memoria automática está activada por defecto, almacenada como markdown local de la máquina en ~/.claude/projects/<project>/memory/, conteniendo precisamente el material que tu CLAUDE.md no contiene, y Cursor nunca lo verá. Las cadenas @path tienen que aplanarse, CLAUDE.local.md pierde su alcance por proyecto, y los conflictos que Claude Code resolvía arbitrariamente ahora se resolverán mediante un orden de precedencia establecido.

Así que lee primero la carpeta de memoria automática, vuelca el conjunto cargado con /context, convierte solo las reglas que necesitan condiciones y coloca las decisiones y los enfoques rechazados en una capa que ambos editores puedan consultar.