Gestionar el contexto y la memoria en Claude Code: /compact, CLAUDE.md y presupuesto de tokens (2026)

Si has usado Claude Code en sesiones largas y con muchos archivos, seguramente ya te ha pasado esto: todo va bien y, de repente, Claude empieza a "olvidar" una decisión que fijaste hace 20 minutos, o la terminal avisa de que el contexto está casi lleno. En este artículo reúno las tres piezas que la mayoría de las guías mantiene separadas — el contexto dentro de la sesión, la memoria entre sesiones y el presupuesto de tokens — en un único flujo de trabajo práctico. Si eres totalmente principiante, lee primero una guía introductoria; pero si trabajas con sesiones de varios archivos todos los días, este texto es para ti.

Contexto vs. memoria en Claude Code: ¿cuál es la diferencia?

Estas dos palabras se usan como sinónimos, pero son cosas completamente distintas, y confundirlas es la raíz de la mayoría de los problemas cuando se trata de gestionar el contexto en Claude Code. El contexto (la ventana de contexto) es la memoria a corto plazo que Claude puede "ver" ahora mismo: tu pregunta, el contenido de los archivos que ha leído, el historial de la conversación, los resultados de las herramientas que ha ejecutado, además del CLAUDE.md que se cargó al inicio de la sesión. Es finita y se esfuma cuando terminas la sesión o escribes /clear.

La memoria (la memoria persistente de Claude Code) vive entre sesiones. Hay dos tipos: el CLAUDE.md — el archivo que tú escribes para informar a Claude sobre tu proyecto — y la memoria automática — donde Claude guarda lo que aprende por su cuenta. La clave: la memoria no vive dentro del contexto, se vuelve a cargar en el contexto cada vez que empieza una nueva sesión.

Aquí tienes una frase para que no vuelvas a confundirlas: el contexto es lo que Claude está pensando ahora mismo, la memoria es lo que Claude siempre sabe.

¿Por qué cada sesión de Claude Code empieza con el contexto vacío?

Mucha gente da por sentado, en silencio, que Claude "recuerda" la conversación de ayer como lo haría un compañero de trabajo. No la recuerda. En el fondo, un modelo de lenguaje no tiene memoria a largo plazo incorporada — Claude en realidad no recuerda la conversación. Cada nueva sesión es una ventana de contexto limpia y en blanco. La sensación de que "recuerda mi proyecto" en realidad viene de que Claude Code vuelve a cargar automáticamente la memoria (CLAUDE.md y memoria automática) al inicio de cada sesión, y no de que el modelo recuerde algo.

Justo por eso existe la memoria: es el puente que compensa una ventana de contexto que "pierde la memoria" después de cada reinicio. Una vez que entiendes esto, dejas de esperar que Claude recuerde por sí solo y empiezas a anotar a propósito lo que hay que recordar. Ese comportamiento de ventana de contexto nueva en cada sesión se describe en la documentación oficial de Claude Code sobre la ventana de contexto (consultado el 2026-08-20).

La consecuencia práctica: cualquier decisión que vive solo en el chat, sin escribirse en un archivo, corre el riesgo de evaporarse — cuando termina la sesión, o incluso antes si se compacta el contexto. Volveremos a esto en la sección de /compact.

Mide el contexto con /context y el estado de los tokens

No puedes gestionar lo que no puedes medir. El primer comando que debes memorizar es /context. Escríbelo durante una sesión y Claude Code listará los Memory files cargados en ese momento (qué archivos CLAUDE.md entraron en el contexto) y el porcentaje de la ventana de contexto en uso.

/context

Esta es la forma más fiable de comprobar si tu CLAUDE.md realmente entró en el contexto: no lo adivines, mira la lista de Memory files. Además, la línea de estado de tu terminal muestra el porcentaje de tokens en uso en tiempo real. Cuando el contexto alcanza un umbral alto, Claude Code compacta automáticamente (auto-compact) para que la sesión no se atasque.

El umbral del auto-compact ronda el 80-83% según la documentación oficial de Claude Code (consultado el 2026-08-20), pero ese número puede cambiar entre versiones.

/compact: compactar el contexto de la forma correcta

Este es el comando más importante del artículo. /compact lee toda la conversación actual, produce un resumen condensado y luego reemplaza la conversación antigua por ese resumen. El resultado: libera la mayor parte de los tokens manteniendo intacto el hilo del trabajo — Claude sigue sabiendo qué estás haciendo, solo que de forma comprimida.

# automatic compaction
/compact

# compact with instructions on what to keep
/compact keep the DB schema decisions and the files I edited, drop the debug logs

¿Cuándo deberías compactar? Mi regla práctica: sé proactiva alrededor del 60%, no esperes al 90%. Compactar pronto, mientras la conversación todavía está "limpia", produce un resumen mucho mejor que forzar una compactación cuando el contexto ya está saturado — en ese punto Claude tiene que descartar muchas cosas y el resumen tiende a perder detalles. Usar /compact <instructions> para especificar qué conservar mejora mucho la calidad.

⚠️ Nota importante sobre los límites: la compactación tiene pérdidas. Todo lo que vive solo en la conversación y no se ha escrito en un archivo puede perderse para siempre tras una compactación. Este es un fallo real que hace que la gente "pierda" decisiones a mitad de tarea. La tabla siguiente muestra qué sobrevive y qué no:

La conclusión, en resumen: antes de compactar, pídele a Claude que "escriba las decisiones importantes en el CLAUDE.md" y luego ejecuta /compact. Lo que está en el disco está a salvo.

/clear vs. /compact: ¿cuál deberías usar?

Estos dos comandos son fáciles de confundir, pero sirven para situaciones muy distintas. Versión corta: /compact cuando continúas el mismo trabajo, /clear cuando cambias a otra cosa.

Lo que hay que recordar: tanto con /clear como con /compact, la memoria entre sesiones (CLAUDE.md y memoria automática) se sigue recargando — así que no pierdes el "conocimiento de base" de tu proyecto, solo la conversación temporal. Cuando cambies de tarea, no dudes en usar /clear: aferrarte a una conversación antigua sin relación solo quema tokens y distrae a Claude.

CLAUDE.md: la memoria a largo plazo que tú misma escribes

El CLAUDE.md es la herramienta de memoria más potente que controlas directamente. Se carga automáticamente en el contexto en cada sesión, en orden del ámbito más amplio al más estrecho. Claude Code lee varios niveles de CLAUDE.md y los combina:

El orden de carga de lo amplio a lo específico significa que los niveles más estrechos (proyecto, local) pueden añadir a los más amplios. La forma más rápida de empezar: ejecuta /init — Claude Code escaneará tu código y montará un CLAUDE.md inicial para el proyecto.

/init

Cómo escribir un CLAUDE.md eficaz: mantenlo corto — por debajo de unas 200 líneas. Un archivo más largo no solo cuesta contexto en cada sesión, sino que además reduce el cumplimiento (a Claude le cuesta priorizar cuando hay demasiadas instrucciones). Hay un análisis con mediciones sobre por qué los archivos de contexto inflados cuestan un 20% más. Escribe cosas específicas y verificables: "usa sangría de 2 espacios" es mejor que "formatéalo bonito". Para contenido largo, usa @path para importar otros archivos, y pon las convenciones específicas de contexto en .claude/rules/ con ámbito de ruta (se cargan solo cuando abres un archivo que coincide con el glob) para ahorrar contexto. Para profundizar en cómo estructurar este archivo, consulta la guía sobre escribir un archivo CLAUDE.md como es debido — ese artículo se encarga de los detalles, así que no los repetiré aquí.

Un ejemplo rápido de regla con ámbito de ruta: un archivo en .claude/rules/api-conventions.md con un frontmatter YAML que limita cuándo se carga:

---
paths:
  - "src/api/**/*.ts"
---
Use camelCase for function names; always validate input with Zod.

Una regla sin el campo paths: (sin ámbito) se carga en cada sesión con la misma prioridad que el CLAUDE.md raíz; una regla con ámbito solo se carga cuando abres un archivo que coincide con el glob — por eso ahorra más contexto que meterlo todo en el CLAUDE.md. Para la configuración completa de .claude/rules/ (estructura de carpetas, reglas a nivel de usuario, prioridad de carga), consulta la guía del CLAUDE.md.

Memoria automática: cuando Claude recuerda entre sesiones por su cuenta

Esta es una función relativamente nueva (2026) que muchas guías antiguas se saltan. Además del CLAUDE.md que tú escribes, Claude Code puede por sí mismo guardar lo que aprende mientras trabaja en una carpeta de memoria específica del proyecto: ~/.claude/projects/<project>/memory/.

Ahí dentro, el MEMORY.md actúa como índice: las primeras 200 líneas o los primeros 25KB del archivo — lo que ocurra primero — se cargan en cada sesión; los demás archivos de temas se cargan bajo demanda, solo cuando hacen falta. Esta función viene activada por defecto; la gestionas con el comando /memory (se alterna con la opción autoMemoryEnabled), y verás avisos como "Saved N memories" / "Recalled N memories" cuando Claude escribe o recuerda aprendizajes.

/memory

Para dejar clara la distinción: el CLAUDE.md es lo que tú escribes (instrucciones — cómo quieres que Claude trabaje), mientras que la memoria automática es lo que Claude escribe (aprendizajes — lo que ha captado). Los dos se complementan. El mecanismo de la memoria automática y sus límites de carga se detallan en la documentación oficial de memoria de Claude Code (consultado el 2026-08-20).

Presupuesto de tokens: trabajar de forma más barata y sostenible

Esta es la parte que la competencia deja casi totalmente en blanco. Los modelos más nuevos son conscientes del contexto: llevan la cuenta de cuántos tokens quedan y pasan automáticamente a responder de forma más concisa, usando las herramientas con más mesura a medida que el contexto se agota. Pero no lo dejes al azar — las seis reglas siguientes mantienen tus sesiones baratas y estables a la vez:

La regla 3 merece énfasis: cuando necesites que Claude lea un directorio grande o un log largo, entrégaselo a un subagent en vez de leerlo directamente en la sesión principal. El subagent trabaja en un contexto separado y devuelve solo su conclusión — tu contexto principal se mantiene ligero. Esta manera de organizar el trabajo se cubre en detalle en el artículo sobre usar subagents para aislar el contexto. En cuanto a los comentarios de la regla 6, las notas humanas en el CLAUDE.md envueltas en <!-- --> nunca llegan al contexto de Claude, así que puedes anotar a tu gusto sin gastar tokens.

El flujo de gestión de contexto y memoria (lista de comprobación práctica)

Reúnelo todo en una rutina de seis pasos que puedes ejecutar cada día:

1. Genera el CLAUDE.md: ejecuta /init para generar un archivo inicial a partir del código.
2. Recorta el CLAUDE.md: mantenlo por debajo de 200 líneas, específico y verificable; mueve las convenciones específicas de contexto a .claude/rules/.
3. Monitorea: escribe /context de forma periódica durante las sesiones largas y vigila el % de tokens en la línea de estado.
4. Compacta pronto: /compact alrededor del 60%, con instrucciones sobre qué conservar (por ejemplo, conservar decisiones + archivos editados).
5. Reinicia al cambiar de tarea: usa /clear cuando pases a una tarea sin relación.
6. Fija las decisiones: pídele a Claude que "actualice el CLAUDE.md con esta decisión" antes de compactar o terminar la sesión, para que nada se pierda en la compactación.

Gana velocidad con un kit ya hecho (AgentKit)

Escribir un CLAUDE.md, un .claude/rules/ y la configuración de subagents decentes para cada proyecto lleva su tiempo. Si quieres ir más rápido, algunos kits ya hechos como el bundle de AgentKit — ahora 149 USD (antes 198 USD) vienen con CLAUDE.md/rules de ejemplo, además de subagents que tienen su propio contexto — lo que encaja justo con los principios de presupuesto de tokens de arriba. Le echo un vistazo más de cerca a qué es AgentKit y si merece la pena por si quieres sopesarlo; pero, para la gestión del contexto, los comandos /context, /compact y /clear de arriba siguen siendo la base, uses un kit o no.

Errores comunes y cómo evitarlos

Con sinceridad, estos son los puntos en los que yo — y mucha gente — más tropiezo:

• Perder decisiones tras /compact: porque solo se dijeron en el chat, nunca se escribieron en un archivo -> escribe siempre las decisiones importantes en el CLAUDE.md antes de compactar.
• Un CLAUDE.md inflado: un archivo demasiado largo desperdicia tokens y reduce el cumplimiento -> separa las cosas en .claude/rules/ con ámbito de ruta.
• Reglas / CLAUDE.md anidado que no se recargan solos tras compactar: las reglas con ámbito de ruta y el CLAUDE.md de subcarpeta no se recargan por sí solos -> vuelve a abrir el archivo que coincide con el glob para reactivarlos.
• Instrucciones en conflicto entre varios archivos CLAUDE.md: cuando los niveles se contradicen, Claude puede elegir de una forma que no pretendías -> revisa la consistencia entre usuario/proyecto/local.

Si te topas con otros líos, mira el resumen sobre cómo corregir los errores comunes de Claude Code. Y, para entender el panorama general de cómo Claude Code encaja sus piezas, echa un vistazo al artículo sobre la diferencia entre skills, subagents, hooks y MCP.

Preguntas frecuentes (FAQ)

¿En qué se diferencia /compact de /clear?

/compact comprime la conversación en un resumen condensado y mantiene el hilo del trabajo — úsalo cuando continúas la misma tarea pero el contexto está lleno. /clear borra la conversación por completo y empieza un contexto vacío — úsalo cuando cambias a una tarea distinta. Ambos siguen recargando el CLAUDE.md y la memoria automática.

¿A qué % se activa el auto-compact?

Según la documentación oficial, el auto-compact se activa cuando el uso del contexto ronda el 80-83%. Aun así, conviene que uses /compact de forma proactiva antes, en torno al 60%, para un resumen de más calidad y con menos pérdida. El umbral exacto puede cambiar entre versiones.

¿El CLAUDE.md sobrevive al /compact?

Sí. El CLAUDE.md de la raíz de tu proyecto se reinyecta desde el disco, así que siempre está ahí después de una compactación. Pero el CLAUDE.md anidado en subcarpetas y las reglas con ámbito de ruta no se recargan solos — necesitas volver a abrir el archivo correspondiente para reactivarlos.

¿Cuándo debería usar /compact?

De forma proactiva, cuando el uso del contexto ronda el 60% — no esperes al 90%. Compactar pronto, mientras la conversación todavía está "limpia", da un mejor resumen. Añade también instrucciones, por ejemplo /compact keep the schema decisions and edited files, para que Claude conserve exactamente lo que necesitas.

¿Dónde se guarda la memoria automática?

Claude Code guarda los aprendizajes en una carpeta de memoria específica del proyecto (~/.claude/projects/<project>/memory/), con el MEMORY.md como índice: sus primeras 200 líneas o 25KB, lo que ocurra primero, se cargan en cada sesión. Viene activada por defecto; actívala e inspecciónala con el comando /memory. Verifica la ruta exacta en vivo según la versión.

¿Cómo reduzco los tokens en Claude Code?

Compacta pronto con /compact al ~60%, mantén el CLAUDE.md ligero (< 200 líneas), delega las lecturas pesadas a un subagent para que no se coma el contexto principal, divide las tareas en fases y usa /clear cuando cambies de trabajo. Esas son las palancas de presupuesto de tokens más eficaces.

Conclusión + próximos pasos

Todo el flujo en una línea: mide con /context -> compacta pronto con /compact al ~60% -> usa /clear al cambiar de tarea -> fija las decisiones en el CLAUDE.md, y deja que la memoria automática se encargue de los aprendizajes. Domina las tres piezas — contexto, memoria y presupuesto de tokens — y tus sesiones largas dejarán de "olvidar" y se volverán claramente más baratas. Siguiente paso: aprende a escribir un archivo CLAUDE.md como es debido para que tu memoria de verdad valga la pena, y profundiza en qué es la ingeniería de contexto cuando quieras optimizar a nivel arquitectónico.