Context Rot y 28 técnicas contra la degradación

Módulo: Tokens y contexto | Tiempo: ~30 min de teoría + 25 min de práctica

Lo esencial

Imagina una libreta con un número de páginas muy grande, pero finito. Cada vez que le escribes un mensaje a Claude, anota la pregunta, su respuesta, todos los archivos que leyó y todas las herramientas que usó. Cuando la libreta se llena más del 60-70%, Claude empieza a fallar: olvida instrucciones, se repite, alucina. Eso es el Context Rot: la degradación de la calidad por saturación del contexto. La lección Comandos integrados de Claude Code mostró que existen los botones /compact y /clear. Esta lección explica el sistema: cuándo, para qué y 28 técnicas para que la degradación ni siquiera llegue.

Conceptos clave

• Context Rot: la degradación de la calidad de las respuestas cuando se satura la ventana de contexto
• Ventana de contexto: la cantidad máxima de información que Claude mantiene en una sesión (a octubre de 2026: 1M de tokens en Fable 5.1, Opus 5.5 y Sonnet 5.5, 200K en Haiku 4.5; versiones y cifras vigentes: Lo vigente)
• Tokens: la unidad de medida del texto: en los modelos actuales de Claude, ~1 palabra en inglés ≈ 1.8 tokens (1M de tokens ≈ 555 mil palabras, según la documentación de Anthropic); en otros idiomas la proporción cambia
• /compact: compresión inteligente: conserva lo esencial, quita detalles y libera la mayor parte del contexto
• /clear: una conversación nueva con el contexto vacío (no toca los archivos)
• Progressive disclosure: carga del contexto en tres niveles: solo lo necesario en el momento necesario

Teoría

Qué es el Context Rot

Cuando trabajas mucho tiempo con Claude Code en una sola sesión, la ventana de contexto se llena:

Prompt del sistema (CLAUDE.md):      ~6 000 tokens
Herramientas MCP (2-3 servidores):  ~11 000 tokens (si las descripciones se cargan completas)
Skills (5-7 archivos):               ~8 000 tokens
Historial de la conversación (1-2 h): ~80 000 tokens
Archivos leídos:                    ~50 000 tokens

Total:                              ~155 000 / 200 000 (78%) — en un modelo con ventana de 200K (Haiku 4.5)
                                     ~155 000 / 1 000 000 (15%) — en un modelo con ventana de 1M (Opus 5.5, Sonnet 5.5)

Las cifras del bloque son ilustrativas: es un ejemplo, no una medición.

Nota sobre el contexto de 1M (a octubre de 2026): Fable 5.1, Opus 5.5 y Sonnet 5.5 tienen una ventana de un millón de tokens, y en la API sin costo extra por contexto largo. Eso hace el problema menos agudo, pero no lo elimina. Según la experiencia del autor del curso, la calidad empieza a degradarse ya al 60-70% de cualquier ventana. Es decir, con 1M de contexto el Context Rot llegará cerca de los 600-700K tokens, no de los 200K. Los principios son los mismos: las técnicas de abajo funcionan con cualquier tamaño de ventana.

Un detalle más: cuando la ventana está casi llena, Claude Code comprime el historial por su cuenta. Pero para entonces la calidad ya bajó, así que un /compact manual antes es más confiable que el automático.

Por encima del 60-70% aparecen los primeros síntomas de degradación. Al 85% o más, Claude empieza a hacer cosas que te van a desesperar.

Síntomas del Context Rot: cómo reconocerlo

🎨 Imagínalo así: el Context Rot avanza como el cansancio de un maratonista. En el km 10, todo bien. En el km 30, baja el ritmo. En el km 40, la técnica se desarma, duelen las rodillas, la cabeza está nublada. Puede terminar, pero la calidad ya no es la misma.

Señales tempranas (60-70% de llenado):

• Las respuestas son un poco más largas de lo necesario
• Claude a veces vuelve a preguntar algo que ya hablaron
• Pequeñas desviaciones de las instrucciones de CLAUDE.md

Etapa media (70-80%):

• Repite los mismos puntos en distintas respuestas
• Olvida detalles que mencionaste hace 30 minutos
• Empieza a "adivinar" en lugar de seguir las reglas definidas

Etapa avanzada (80%+):

• Alucina: nombra archivos que no existen, cita conversaciones que no ocurrieron
• Ignora las reglas de CLAUDE.md (no porque no quiera, sino porque literalmente ya no las ve en el contexto)
• Se contradice dentro de una misma respuesta
• Deja de usar el estilo y el tono correctos

Señal de emergencia: Claude empezó a escribir algo que contradice claramente las instrucciones que le diste al inicio de la sesión → /compact o /clear de inmediato.

🎨 Imagínalo así: Claude con el contexto saturado es como un empleado que lleva 18 horas trabajando sin dormir. Formalmente sigue haciendo algo. Pero la calidad ya no es la misma y no puedes confiar en el resultado.

Tres comandos para manejar el contexto

La lección Comandos integrados de Claude Code explicó qué hacen estos comandos. Aquí veremos cuándo exactamente usarlos.

/compact: compresión inteligente

🎨 Imagínalo así: /compact es un editor que toma un borrador de 50 páginas y te devuelve un resumen de 5. Lo esencial se queda, el relleno se va. Sigues trabajando con el resumen.

Qué pasa por dentro: Claude lee todo el historial de la conversación, extrae los puntos clave, crea un resumen comprimido y reemplaza el historial con él. Se pierden detalles, queda lo esencial. Puedes indicarle qué conservar: /compact conserva las decisiones sobre la base de datos.

Cuándo usarlo: con el contexto al 60-65% (revísalo con /context).

Resultado: se libera la mayor parte del contexto. Claude sigue recordando en qué trabajaban y a qué llegaron.

Ejemplo de la práctica:

Antes de /compact:  ventana llena al 78%
Después de /compact: llena aproximadamente al 22%

Sigues trabajando en la misma sesión, pero con la cabeza fresca.

/clear: empezar de cero

Qué pasa: una conversación nueva con el contexto vacío. No toca los archivos del proyecto. CLAUDE.md se queda y se vuelve a cargar. Empiezas de cero (la conversación anterior se puede recuperar con el comando /resume).

Cuándo usarlo:

• Cambias a una tarea totalmente distinta
• Después de terminar un bloque grande de trabajo
• Cuando ya usaste /compact varias veces y la calidad sigue bajando
• La sesión lleva más de 3-4 horas

Diferencia con /compact: /compact comprime el historial, /clear lo borra. Después de /clear, Claude no recuerda lo que hicieron. Después de /compact, recuerda un resumen breve.

/context: diagnóstico

Qué muestra (en las versiones nuevas es un mapa de colores de la ventana con sugerencias; abajo, un ejemplo ilustrativo en forma de lista, con cifras de ejemplo):

Modelo: (el nombre de tu modelo)
Tokens: 51 300 / 200 000 (25.7%)

Breakdown:
  Prompt del sistema:  6 200 (3.1%)
  Herramientas del sistema: 4 800 (2.4%)
  Herramientas MCP:  10 800 (5.4%)
  Skills:  7 200 (3.6%)
  Mensajes:  22 300 (11.2%)
  Espacio libre:  148 700 (74.4%)

Cuándo ejecutarlo: cada 30-40 minutos de trabajo intenso. Hazlo un reflejo.

Qué hacer con los datos:

• 0-50%: todo bien, sigue trabajando
• 50-65%: advertencia, pronto necesitarás /compact
• 65%+: /compact de inmediato
• 80%+: /clear y empieza la sesión de nuevo

28 técnicas contra el Context Rot

Agrupadas en tres categorías: Arquitectura, Prompts, Gestión.

Grupo 1: Técnicas de arquitectura (prevención)

🎨 Imagínalo así: las técnicas de arquitectura son una cocina bien distribuida. El cocinero trabaja más rápido no porque corra más, sino porque el cuchillo, la tabla y la olla están a la mano en el orden correcto. No tiene que buscar nada.

1. CLAUDE.md como única fuente de verdad No repitas las reglas en cada prompt. Un CLAUDE.md bien escrito una vez pesa menos que repetir las mismas reglas diez veces en el chat.

2. Progressive Disclosure (L1/L2/L3) Carga el contexto por niveles, solo lo que hace falta para la tarea concreta:

L1 (siempre):        CLAUDE.md: reglas básicas, estructura del proyecto (~6K tokens)
L2 (según la tarea): el skill.md del skill necesario + la documentación de la API de la herramienta necesaria
L3 (a pedido):       archivos de datos concretos, solo cuando de verdad se necesitan

3. Archivos pequeños en references/ Divide la documentación grande de una API en archivos pequeños por función. En lugar de un archivo de ClickUp de 800 líneas, tres de 250: tasks.md, comments.md, webhooks.md. Claude leerá solo el que necesite.

4. SKILL.md de menos de 500 líneas Recomendación de la documentación de Claude Code: mantén el archivo SKILL.md por debajo de 500 líneas. Los detalles, en archivos de referencia aparte que el skill llama cuando hace falta.

5. Carpeta context/ para la memoria de largo plazo Anota las decisiones y los acuerdos importantes en archivos, no los dejes solo en el historial del chat. Lo que está escrito en un archivo sobrevive a /clear. Lo que está solo en el chat, no. El Claude Code actual también sabe llevar notas entre sesiones por su cuenta (auto memory, se maneja con /memory), pero lo que es crítico es más seguro tenerlo en tus propios archivos.

6. Archivar los archivos viejos Los archivos que ya no necesitas van a archives/. Si se cuelan al contexto por una búsqueda, son tokens de más.

7. Carpetas separadas para los outputs Todo lo que Claude crea va a outputs/. No mezcles resultados con instrucciones. Cuando Claude busca algo, busca en el lugar correcto y no lee de más.

8. .env solo para secretos Los secretos van en .env, no en CLAUDE.md ni en el chat. Menos información sensible en el contexto principal.

Grupo 2: Técnicas de prompt (ahorro de tokens)

9. Divide las tareas (Splitting Prompts) Una tarea grande = muchos tokens para todo el contexto de la tarea de una sola vez. Divídela en pasos. Después de cada paso Claude piensa con más claridad y tú ves el avance.

Mal: "Crea un CRM con frontend, base de datos, API, dashboard y deploy" Bien: primero "crea la estructura del proyecto" → revisas → luego "agrega la base de datos" → etc.

10. Archivos concretos en lugar de "revisa el proyecto" No le digas a Claude "revisa todo el proyecto". Indica archivos concretos: "lee outputs/newsletter-draft.md y mejora el tercer párrafo". Menos lecturas innecesarias = menos tokens.

11. Haz una pregunta a la vez Varias preguntas en un mensaje → Claude intenta tenerlas todas en la cabeza a la vez → se gasta más contexto en "razonamiento" interno.

12. Usa órdenes, no descripciones En lugar de "¿podrías crear un archivo con tal contenido en tal carpeta?" → "crea outputs/report.md: [contenido]". Más corto = menos tokens.

13. Apunta a archivos, no los copies en el chat No pegues bloques grandes de texto directamente en el prompt. Mejor: "lee context/business-data.md y haz un reporte". Claude leerá el archivo (también son tokens, pero solo una vez).

14. Limpia outputs al terminar una tarea Si outputs/ acumuló muchos archivos de tareas viejas, límpialo o archívalo. Si no, Claude puede leerlos por accidente al buscar.

15. No agregues MCP si no hace falta Cada servidor MCP agrega al contexto las descripciones de sus herramientas. En las versiones nuevas de Claude Code, por defecto se cargan solo los nombres de las herramientas y las descripciones completas llegan cuando hacen falta (tool search), así que un servidor de más cuesta menos que antes. Pero si activas la carga completa, dos servidores se comen fácilmente ~11K tokens antes de la primera palabra. Agrega un MCP solo cuando de verdad lo necesites y quítalo cuando termine la tarea.

16. Convierte las funciones MCP en Skills Después de probar un MCP y ver que funciona, crea un skill que haga lo mismo con una llamada directa a la API. Los skills requieren menos tokens que mantener un MCP siempre encendido.

Grupo 3: Técnicas de gestión de la sesión (reacción)

17. Agenda /context: cada 30 minutos Hazlo un reflejo: cada 30-40 minutos de trabajo → /context → revisa el llenado. No esperes síntomas: revisa de forma preventiva.

🎨 Imagínalo así: esperar al 90% para lanzar /compact es como cambiarle el aceite al coche cuando el motor ya está golpeteando. El momento correcto es cada tantos miles de kilómetros, no cuando ya se descompuso.

18. /compact al 60%, no al 90% La mayoría lanza /compact demasiado tarde, cuando Claude ya se está degradando. Lánzalo al 60%, antes de que aparezcan los síntomas. Resultado: ni un minuto de trabajo degradado.

19. /clear entre tareas grandes Terminaste un bloque de trabajo → /clear → empiezas el siguiente bloque con la cabeza fresca. No intentes mantener el contexto de dos tareas distintas en una misma sesión.

20. Pestaña nueva = agente nuevo En VS Code (y otros editores con la extensión de Claude Code) puedes abrir varias pestañas de Claude Code, cada una con su propio contexto limpio. Tareas en paralelo → agentes en paralelo. Las sesiones en segundo plano se ven con el comando claude agents.

21. Subagentes para tareas en paralelo En lugar de un agente que hace 5 tareas en secuencia (y acumula contexto), 5 agentes que hacen una tarea cada uno y no se estorban.

22. Un /compact final antes de los resultados clave Antes de que Claude produzca el resultado final (una publicación, un reporte, código que irá a producción), primero /compact y luego la solicitud. Contexto limpio = resultado más limpio.

23. Guarda las decisiones clave en decisions/ Las decisiones técnicas importantes, las reglas del proyecto y los acuerdos, anótalos de inmediato en decisions/. Así se conservan fuera de la ventana de contexto.

24. /clear regular al final de la jornada Al final del día, antes de cerrar VS Code: /clear. La siguiente sesión empezará limpia y cargará un CLAUDE.md fresco sin el peso de las conversaciones de ayer.

25. Controla la longitud de tus mensajes Un prompt largo con mucho contexto dentro son tokens que se quedan en el historial de la conversación. Decide: ¿es una regla para CLAUDE.md? Entonces va ahí. ¿Son datos para una tarea concreta? Entonces van a un archivo y Claude apunta al archivo.

26. Usa /statusline y /usage para monitorear La barra de estado (/statusline) se puede configurar para que el llenado del contexto siempre esté a la vista, y el consumo y los límites del plan los muestra /usage (su sinónimo es /cost). Si el consumo de una sola solicitud se dispara, es señal de que el contexto se infló con archivos de más o con un historial demasiado largo.

27. Spec → To-Do → Code (enfoque en tres fases) Para tareas complejas: primero el spec (qué construimos), luego una lista de to-do por milestones, luego el código, un milestone a la vez. Cada etapa con contexto limpio, sin arrastrar la cola de la anterior.

28. Un subagente para la investigación pesada Si necesitas investigar un volumen grande de información (300 páginas de documentación, 1000 líneas de código), delégalo a un subagente. Trabaja en su propio contexto y te devuelve un resumen comprimido. Tu contexto principal no se ensucia.

Tabla resumen: señal → acción

Qué conserva /compact y qué pierde

🎨 Imagínalo así: /compact es como un secretario con experiencia después de una junta larga: "Acordamos esto, descartamos aquello, el siguiente paso es este." Tiró la transcripción de 50 páginas y guardó una minuta de 1 página.

Conserva:

• Las decisiones tomadas en la sesión
• Los datos clave del proyecto
• El estado de las tareas terminadas
• Los errores principales y sus soluciones

Pierde:

• Las explicaciones y razonamientos detallados
• Los pasos intermedios que no llevaron a nada
• Los bloques largos de código que se discutieron pero no se usaron
• Los detalles menores de la conversación

Conclusión: si algo es importante, escríbelo en un archivo. /compact conserva lo esencial, no los detalles.

Práctica

Tarea: auditar una sesión en vivo

1. Abre Claude Code y trabaja 20-30 minutos en cualquier tarea (crea algunos archivos, pide mejorar algo, explora código)
2. Ejecuta /context y mira las cifras. Anota el llenado y el desglose por componentes
3. Identifica qué ocupa más espacio: ¿el historial de mensajes? ¿Las herramientas MCP? ¿Los archivos?
4. Ejecuta /compact y mira las cifras nuevas después de la compresión
5. Compara: ¿qué cambió? ¿Qué recuerda todavía Claude? ¿Qué olvidó?
6. Anota en tu libreta: cuáles de las 28 técnicas ya aplicas y cuáles quieres agregar

Objetivo: aprender a leer el llenado del contexto como el indicador de presión del aceite del motor: no esperar la avería, vigilar de forma preventiva.

Las 10 técnicas más eficaces (tabla resumen)

Herramientas y recursos

• /context: el mapa actual de tokens (ejecútalo cada 30-40 min)
• /compact: compresión inteligente del historial (úsalo al 60-65%)
• /clear: reinicio completo del historial (entre tareas grandes)
• /statusline: barra de estado con las métricas que necesitas; /usage: consumo y límites
• Lista de comandos de Claude Code: documentación completa de los comandos
• Claude Pricing: precios oficiales; resumen con fecha de verificación: Lo vigente
• context/: carpeta para la memoria de largo plazo (sobrevive a /clear)
• decisions/: registro de decisiones clave
• archives/: archivo de los archivos obsoletos

Errores comunes

Error 1: nunca limpiar el contexto en sesiones largas Trabajas 4 horas seguidas sin revisar /context ni una vez. Al final, Claude alucina, confunde archivos y olvida instrucciones. Reflejo: cada 30 minutos, /context; al 60%, /compact.

Error 2: /clear en lugar de /compact Perdiste todo el contexto de 2 horas de trabajo con un solo /clear. Tuviste que volver a explicar lo que estaban haciendo. /compact habría conservado las decisiones clave.

Error 3: conectar 5 MCP "por si acaso" Cada servidor MCP agrega al contexto las descripciones de sus herramientas. Cinco servidores pueden ocupar decenas de miles de tokens antes de la primera palabra (sobre todo si las descripciones se cargan completas). Conecta solo los MCP que necesitas para la tarea actual.

Referencias cruzadas

• Tokens y manejo del contexto: comprensión básica de los tokens y la ventana de contexto
• Comandos integrados de Claude Code: /compact, /clear, /context y otros comandos
• Manejo del contexto: técnicas avanzadas: técnicas avanzadas para proyectos grandes

Ideas clave

El Context Rot no es un bug, es física. La ventana de contexto es finita. La meta no es vencer el límite, sino trabajar con él de forma inteligente: cargar solo lo necesario, comprimir a tiempo y guardar lo importante en archivos.

/compact al 60% es mejor que /compact al 90%. Prevenir es mejor que curar: una revisión de /context cada 30 minutos te ahorra una hora de trabajo degradado.

Lo que no está escrito en un archivo no sobrevive a /clear. Diseña el sistema así: todo lo valioso vive en archivos, y el contexto es solo una herramienta de trabajo que se puede y se debe limpiar de vez en cuando.

Siguiente lección

→ RAG: Retrieval Augmented Generation: trabajar con documentos