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

Tus Skills, sin ningún cambio. Las ubicaciones de las habilidades del proyecto de Cline son .cline/skills/ (recomendado), .clinerules/skills/ y .claude/skills/. Esa tercera entrada significa que un repositorio que ya has estado usando con Claude Code ya satisface a Cline. Las habilidades globales van en ~/.cline/skills/. Una nota de precedencia que invierte a lo que puedes estar acostumbrado: "Cuando una habilidad global y una habilidad de proyecto tienen el mismo nombre, la habilidad global tiene precedencia". Cline también aconseja mantener SKILL.md por debajo de 5k tokens y dividir el exceso en un directorio docs/ que "carga los archivos referenciados solo cuando es necesario".

El contenido de tus instrucciones, una vez que llega a un archivo que Cline lee. Dos formas limpias. Renombrarlo a AGENTS.md en la raíz del proyecto, que Cline trata como el "Formato estándar para compatibilidad entre herramientas". O dividirlo en .clinerules/: Cline "procesa todos los archivos .md y .txt dentro de .clinerules/, combinándolos en un conjunto unificado de reglas", con prefijos numéricos opcionales como 01-coding.md para el orden.

Tu capa personal, a un hogar diferente. Las instrucciones de usuario de Claude Code viven en ~/.claude/CLAUDE.md, descritas como "Preferencias personales para todos los proyectos". El directorio de reglas globales de Cline es ~/Documents/Cline/Rules en macOS y Linux/WSL, y Documents\Cline\Rules en Windows. También lee instrucciones globales de herramientas cruzadas desde ~/.agents/AGENTS.md. Ten en cuenta la ubicación: Documents, no un archivo oculto (dotfile); vale la pena saberlo antes de ir a buscar en ~/.cline/.

Nada más se transfiere limpiamente, y tres cosas se comportan de manera diferente.

Tu memoria automática (auto memory) no tiene destino. Esta es la verdadera brecha. Claude Code escribe notas para sí mismo en ~/.claude/projects/<project>/memory/ (de cuatro tipos, etiquetadas en el frontmatter como user, feedback, project y reference) y está activado por defecto. Cline no tiene un almacén automático equivalente. Peor aún para cualquiera que espere simplemente copiar una carpeta: la documentación de Claude Code establece que "La memoria automática es local de la máquina" y "Los archivos no se comparten entre máquinas o entornos de nube". Esos archivos son también deliberadamente el residuo de cosas que tus archivos de instrucciones no dicen, porque Claude "omite cualquier cosa que pueda derivar del código base" y "omite cualquier cosa que tus archivos CLAUDE.md ya digan". Lo que significa que el directorio de memoria contiene precisamente el contenido que no estará en el archivo que renombres.

La precedencia y la fusión difieren. Claude Code concatena: política gestionada, luego instrucciones de usuario, luego instrucciones de proyecto, con la nota de que "si dos reglas se contradicen entre sí, Claude puede elegir una arbitrariamente". Cline también combina, pero resuelve conflictos: "Cuando existen tanto reglas de espacio de trabajo como globales, Cline las combina. Las reglas del espacio de trabajo tienen precedencia cuando entran en conflicto con las reglas globales". Así que una preferencia personal que estaba luchando silenciosamente contra tu archivo de proyecto en Claude Code ahora perderá de manera confiable.

Las reglas con alcance de ruta se convierten en interruptores. Claude Code tiene archivos .claude/rules/ con un campo de frontmatter paths: de globs, cargándose solo para los archivos que coinciden. El control equivalente de Cline es manual en lugar de automático: "Cada regla tiene un interruptor para activarla o desactivarla", siendo los propios ejemplos de Cline "una regla de prueba estricta que deseas desactivar al realizar prototipos, o una regla específica del cliente que solo necesitas cuando trabajas en las características de ese cliente". Mismo objetivo, diferente activador: tú lo cambias, en lugar de que lo haga un glob.

Paso 1: Lee tu memoria automática antes de tocar el archivo de instrucciones

Haz esto primero, porque es la única parte de la migración que no se puede recuperar más tarde del repositorio.

Ejecuta /memory en Claude Code para explorar el directorio de memoria, o abre ~/.claude/projects/<project>/memory/ directamente. Contiene un índice MEMORY.md más un archivo por tema. Dos cosas que debes saber mientras lees: solo "las primeras 200 líneas de MEMORY.md, o los primeros 25KB, lo que ocurra primero" se cargaban al inicio de la sesión, y los archivos de temas se "leen bajo demanda" en lugar de cargarse, por lo que puede haber más allí de lo que Claude usaba habitualmente.

Luego ejecuta /context y verifica la lista bajo Memory files (Archivos de memoria). Ese es el registro autorizado de lo que realmente se estaba cargando, y te dirá si el CLAUDE.md que estás a punto de renombrar era el único; los archivos en los subdirectorios se cargan bajo demanda, y las importaciones se resuelven con "una profundidad máxima de cuatro saltos", por lo que un monorepositorio puede tener más en juego de lo que sugiere el archivo raíz.

Copia lo que quieras conservar. Esto no es un movimiento de archivos; es un ejercicio de lectura. Las entradas de feedback y project suelen ser las valiosas, porque por diseño contienen correcciones que diste y decisiones que no se pueden derivar del código.

Paso 2: Coloca las instrucciones, luego decide sobre el Memory Bank

Las instrucciones primero, y elige una forma. Si Cline es ahora el único agente en el repositorio, renombre CLAUDE.md a AGENTS.md. Si tus compañeros de equipo todavía están en Claude Code, mantén CLAUDE.md y añade AGENTS.md, pero elige uno como autorizado y mantén el otro ligero, porque dos copias completas divergen. Dividir en .clinerules/ es la mejor opción para cualquier cosa larga: los archivos separados con interruptores superan a un solo archivo que nadie quiere editar. La mitad de esta decisión relacionada con el formato de archivo se cubre por separado en cómo migrar tu CLAUDE.md a AGENTS.md.

Mientras estás aquí, elimina las secciones que la guía de Claude Code ya te dijo que recortaras. Su consejo es "apuntar a menos de 200 líneas" porque "los archivos más largos consumen más contexto y reducen la adherencia", y la misma lógica se aplica a lo que sea que cargue Cline.

Luego el Memory Bank, que es la parte que la gente se salta. La respuesta de Cline al contexto entre sesiones es una metodología que instalas, no una función que activas. La configuración consta de tres pasos: copia las instrucciones personalizadas de Cline, "Añádelas a un archivo de Reglas de Cline, como .clinerules/memory-bank.md", luego pídele a Cline que "inicialice el banco de memoria" ("initialize memory bank").

Crea seis archivos markdown en el repositorio (projectbrief.md, productContext.md, activeContext.md, systemPatterns.md, techContext.md y progress.md), siendo activeContext.md el que "se actualiza con más frecuencia". Tres frases lo impulsan: "initialize memory bank", "update memory bank" y "follow your custom instructions" para reanudar.

Lee el propio planteamiento de Cline de por qué, porque es inusualmente directo sobre el compromiso: "Soy Cline, un ingeniero de software experto con una característica única: mi memoria se restablece por completo entre sesiones. Esto no es una limitación, es lo que me impulsa a mantener una documentación perfecta".

Esa es la verdadera forma de esta migración. La memoria de Claude Code era automática y local de la máquina. La de Cline es manual y está en tu repositorio. Ganas algo que nunca podrías obtener de ~/.claude/projects/: un compañero de equipo puede leerlo, revisarlo y sobrevive a una nueva computadora portátil. Renuncias a la parte que ocurría sin ti.

Una nota sobre el flujo de trabajo: /newtask es lo más parecido a una primitiva de traspaso, descrita como que funciona "como un traspaso de desarrollador. Empaqueta lo que importa (plan general, trabajo realizado, archivos relevantes, próximos pasos) en una nueva tarea con una ventana de contexto limpia". /smol (con el alias /compact) comprime en su lugar. Usa update memory bank antes de cualquiera de los dos si deseas que el estado quede registrado por escrito en lugar de resumido.

Mira en qué consistió realmente la migración. Se renombró un archivo. Una carpeta ya estaba en el lugar correcto. Y el único paso irreversible fue leer un directorio de notas que una herramienta escribió, en una máquina, en un formato que solo esa herramienta utiliza.

Eso no es un fallo de Claude Code ni de Cline. Es lo que sucede cuando el conocimiento duradero vive dentro de cualquier agente que lo produjo. La memoria automática de Claude Code es explícitamente local de la máquina. El Memory Bank de Cline es explícitamente una práctica de documentación que mantienes a mano. Ambos son diseños razonables; ninguno es un lugar donde elegirías guardar la única copia de por qué se tomó una decisión.

Eso es lo que alberga MemoryLake: el conocimiento duradero de tu proyecto en una capa que tus herramientas consultan, por lo que cambiar de editor es una preferencia en lugar de una migración. La configuración consta de tres pasos.

Paso 1: Crea una clave API

Inicia sesión 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. Escribe estas mientras la lectura de /memory del Paso 1 aún esté fresca:

Todo en la categoría feedback. Correcciones que diste y enfoques que confirmaste. Esta es la categoría con más probabilidades de volver a discutirse en una herramienta nueva, porque nada en el código base lo implica.

Decisiones con la razón adjunta. "Las migraciones son solo aditivas porque la réplica de lectura se retrasa bajo carga". Una instrucción establece la regla; solo esto evita que se vuelva a proponer la alternativa.

Enfoques ya probados y rechazados aquí. Ausentes de los archivos de instrucciones, ausentes de los mensajes de confirmación (commit), vueltos a proponer en cada sesión.

Hechos del entorno que nada anuncia. La prueba que solo falla en CI, el límite de velocidad no documentado, la dependencia de orden entre dos trabajos.

Paso 3: Conecta tu IA y agentes

Conecta lo que usas. Se puede acceder a MemoryLake a través de MCP y de una API, por lo que los agentes nativos de MCP (Claude Code, Cline, Codex y OpenClaw entre ellos) se conectan apuntando al servidor MCP, mientras que otros asistentes leen la misma memoria a través de la API. Lo que significa que puedes ejecutar Cline y Claude Code en el mismo repositorio durante la transición sin mantener dos copias del mismo razonamiento.

Tres límites honestos. MemoryLake no escribe tus archivos AGENTS.md, .clinerules/ o Memory Bank; esos son la forma en que diriges cada herramienta, y el comportamiento de descubrimiento anterior es el de ellas. Solo contiene lo que tú o tus agentes ponen en él, por lo que el Paso 2 es manual. Y las instrucciones son contexto en lugar de una configuración forzada; para cualquier cosa que deba cumplirse siempre, utiliza el propio mecanismo de aplicación de cada herramienta en lugar de una capa de memoria.

Las Skills dejan de ser un elemento de migración. .claude/skills/ es un directorio que Cline lee. Nada que mover.

"¿Qué archivo está activo?" tiene una respuesta corta. .clinerules/, .cursorrules, .windsurfrules, AGENTS.md, y no CLAUDE.md.

Los conflictos se resolven en lugar de decidirse al azar. Las reglas del espacio de trabajo superan a las reglas globales en Cline. Claude Code "puede elegir una arbitrariamente".

Los archivos de instrucciones largos se convierten en varios cortos con interruptores. Que es también cómo dejas de cargar la sección de frontend durante el trabajo de backend.

Tu contexto se vuelve revisable. Los archivos del Memory Bank se encuentran en el repositorio y pasan por solicitudes de extracción (pull requests). ~/.claude/projects/<project>/memory/ nunca podría.

Una nueva computadora portátil deja de ser un reinicio. La memoria automática era local de la máquina; los archivos confirmados (committed) no lo son.

Lee /memory antes de renombrar cualquier cosa. Contiene lo que tu CLAUDE.md deliberadamente no contiene, y no viene contigo.

Ejecuta /context para confirmar qué se estaba cargando realmente. Los archivos de subdirectorios y las importaciones de cuatro saltos significan que el archivo raíz rara vez es toda la historia.

Elige AGENTS.md o .clinerules/, y solo una fuente autorizada. Dos copias completas divergen dentro de un sprint.

Divide antes de migrar, no después. Los archivos .clinerules/ separados con interruptores son la única razón por la que la función de interruptor es útil.

Instala realmente el Memory Bank. Es un archivo de reglas más un comando, y saltárselo es la razón por la que la gente concluye que Cline olvida cosas; el lado de los síntomas está en por qué Cline olvida el contexto del proyecto.

Actualiza el banco de memoria antes de /newtask o /smol. La compresión no es lo mismo que escribirlo.

Confirma (commit) .cline/ y tu Memory Bank. La propia guía de Cline es usar la configuración del proyecto "para el comportamiento compartido por el equipo que debe viajar con el repositorio".

Mantén el razonamiento fuera del archivo que siempre se carga. Ambas herramientas limitan lo que transportan, y el razonamiento es la primera víctima; el problema general se trata en por qué los agentes ignoran los archivos de instrucciones que escribiste.

La migración de Claude Code a Cline parece un simple cambio de nombre, y la parte mecánica lo es: .claude/skills/ ya funciona, y CLAUDE.md se convierte en AGENTS.md o en un conjunto de archivos .clinerules/. La trampa es que la tabla de reglas de Cline detecta automáticamente .cursorrules y .windsurfrules mientras que nunca menciona CLAUDE.md, por lo que el único archivo en el que confiabas es el único nombre de archivo sin lector en el otro lado.

La parte que genuinamente no se transfiere es la memoria automática. Claude Code la escribe para sí mismo en ~/.claude/projects/<project>/memory/, en cuatro categorías, conteniendo por diseño las cosas que tus archivos de instrucciones no dicen, y es local de la máquina. El reemplazo de Cline es el Memory Bank: seis archivos markdown en tu repositorio, inicializados con un archivo de reglas y un comando, mantenidos por ti. Vale la pena hacer ese intercambio con los ojos abiertos, porque ganas capacidad de revisión y pierdes automatización.

Lee primero el directorio de memoria, confirma qué se estaba cargando con /context, coloca las instrucciones en un archivo autorizado, instala el Memory Bank correctamente y coloca las decisiones y los enfoques rechazados en algún lugar que ambas herramientas puedan consultar. Así, el editor que abriste esta mañana dejará de ser un hecho del que dependa la comprensión de tu agente.