Módulo 4: El workflow agentic: Explore → Plan → Code

Context Window y Compaction: Gestionar la Memoria de Claude Code

Descripción

El context window es la memoria de trabajo de Claude Code. Todo lo que dices, todo lo que Claude responde, cada archivo que lee, cada comando que ejecuta — todo ocupa espacio en esa ventana. Con Opus 5 y Sonnet 5 tienes hasta 1M de tokens, pero eso no significa que sea infinito ni que debas ignorar cómo lo gestionas.

Un context window mal gestionado es como un escritorio lleno de papeles: técnicamente todo está ahí, pero encontrar lo relevante se vuelve cada vez más difícil. Cuando el contexto se llena, Claude empieza a "olvidar" detalles de los primeros mensajes, las respuestas pierden precisión, y el rendimiento se degrada. La compaction es la herramienta que te permite limpiar ese escritorio sin perder la dirección de tu trabajo.

En esta cápsula aprenderás qué es el context window, cómo monitorearlo, qué es la compaction y cuándo usarla, qué se preserva y qué se pierde, y las estrategias para mantener conversaciones productivas incluso en proyectos grandes con sesiones largas.

Qué Es el Context Window

Definición técnica

El context window es la cantidad total de texto (medida en tokens) que Claude puede procesar en un momento dado. Incluye:

System prompt (instrucciones internas de Claude Code)
CLAUDE.md y archivos de memoria
Tu conversación completa (todos tus mensajes + todas las respuestas de Claude)
Contenido de archivos leídos por Claude
Output de comandos ejecutados (terminal output)
Tool calls y resultados (operaciones internas)

┌─────────────────────────────────────────────┐
│              CONTEXT WINDOW                 │
│                                             │
│  ┌─────────────────────────────────────┐    │
│  │ System prompt + CLAUDE.md           │    │
│  │ (~fijo, se carga al inicio)        │    │
│  └─────────────────────────────────────┘    │
│  ┌─────────────────────────────────────┐    │
│  │ Mensaje 1: "Analiza este proyecto"  │    │
│  │ Respuesta 1: [análisis + archivos]  │    │
│  └─────────────────────────────────────┘    │
│  ┌─────────────────────────────────────┐    │
│  │ Mensaje 2: "Crea endpoint..."       │    │
│  │ Respuesta 2: [código generado]      │    │
│  └─────────────────────────────────────┘    │
│  ┌─────────────────────────────────────┐    │
│  │ Mensaje 3: ...                      │    │
│  │ Respuesta 3: ...                    │    │
│  └─────────────────────────────────────┘    │
│  ┌─────────────────────────────────────┐    │
│  │         ↓ sigue creciendo ↓         │    │
│  └─────────────────────────────────────┘    │
│                                             │
│  ═══════════════════════════════════════    │
│  Espacio restante para la próxima respuesta │
│                                             │
└─────────────────────────────────────────────┘

Capacidades actuales (Feb 2026)

Modelo	Context window	Output máximo	Notas
Opus 5	1M tokens	128K tokens	Extended thinking, adaptive reasoning
Sonnet 5	1M tokens	64K tokens	Balance velocidad/inteligencia
Haiku 4.5	200K tokens	64K tokens	El más rápido

1M de tokens ≈ ~750,000 palabras ≈ ~3,000 páginas de texto. Suena enorme, pero se llena más rápido de lo que crees.

Qué consume más tokens

No todo ocupa lo mismo. Algunos elementos consumen mucho más que otros:

Elemento	Consumo típico	Ejemplo
Tu mensaje	Bajo (~100-500 tokens)	"Crea un endpoint GET /users"
Respuesta de Claude	Medio-Alto (~500-5,000 tokens)	Código generado + explicación
Archivo leído por Claude	Alto (~1,000-50,000 tokens)	Un archivo de 500 líneas ≈ 5,000 tokens
Output de terminal	Variable	`npm test` output puede ser enorme
CLAUDE.md	Fijo (~500-2,000 tokens)	Se carga una vez y persiste

El consumidor #1 de contexto no son tus mensajes — son los archivos que Claude lee y el output de comandos. Un solo cat package-lock.json puede consumir 100K+ tokens.

Cómo Monitorear el Contexto

El indicador de Claude Code

Claude Code muestra el uso de contexto en la interfaz. El indicador te dice qué porcentaje del context window está ocupado.

# Indicador en la barra de estado de Claude Code:
# Se muestra como porcentaje o barra visual

Context: ████████░░ 78%

Señales de que el contexto se está llenando

No siempre vas a mirar el indicador. Estas señales te avisan:

1. Respuestas más lentas

Claude tarda más en responder porque tiene que procesar más contexto antes de generar. Si una respuesta que debería tomar 5 segundos toma 20, tu contexto probablemente está alto.

2. "Olvidos" de instrucciones anteriores

# Hace 15 mensajes dijiste:
"Usa camelCase para variables"

# Pero ahora Claude genera:
const user_name = "..."  // snake_case

# Claude no te está ignorando — simplemente los mensajes 
# antiguos pierden "peso" cuando el contexto está saturado

3. Respuestas más genéricas

Cuando el contexto está lleno, Claude tiende a dar respuestas más seguras y genéricas en vez de específicas al proyecto. Si notas que Claude "olvidó" las convenciones de tu proyecto (que no están en CLAUDE.md), es señal.

4. Repetición de preguntas

Si Claude te pregunta algo que ya le respondiste, el contexto está degradado.

5. Auto-compaction

Claude Code puede ejecutar auto-compaction cuando detecta que el contexto está muy lleno. Si ves un mensaje del sistema indicando compaction automática, es señal de que estuviste trabajando con contexto saturado.

Hooks de compaction (`PreCompact` / `PostCompact`)

Claude Code expone dos hooks de ciclo de vida para la compaction:

PreCompact — se dispara ANTES de que ocurra la compaction. Útil para guardar estado crítico (ej: hacer commit de trabajo en progreso, exportar decisiones importantes a un archivo)
PostCompact — se dispara DESPUÉS de completar la compaction. Útil para loggear qué se resumió o notificar al equipo

{
  "hooks": {
    "PreCompact": [
      { "hooks": [{ "type": "command", "command": "./scripts/save-checkpoint.sh" }] }
    ],
    "PostCompact": [
      { "hooks": [{ "type": "command", "command": "echo 'Contexto compactado' >> .claude/logs/compaction.log" }] }
    ]
  }
}

Los hooks se cubren en profundidad en el Módulo 05 (Skills y Hooks).

Compaction: Qué Es y Cómo Funciona

Definición

Compaction es el proceso de resumir la conversación para liberar espacio en el context window. Claude Code toma toda la historia de la conversación, la condensa en un resumen conciso, y reemplaza los mensajes originales con ese resumen.

# Antes de compaction:
┌──────────────────────────────────────┐
│ CLAUDE.md                     [2K]   │
│ Mensaje 1 + Respuesta 1      [5K]   │
│ Mensaje 2 + Respuesta 2      [8K]   │
│ Mensaje 3 + Respuesta 3      [12K]  │
│ Mensaje 4 + Respuesta 4      [3K]   │
│ Mensaje 5 + Respuesta 5      [6K]   │
│ ─────────────────────────────────    │
│ Total: 36K tokens usados             │
└──────────────────────────────────────┘

# Después de compaction:
┌──────────────────────────────────────┐
│ CLAUDE.md                     [2K]   │
│ [RESUMEN DE CONVERSACIÓN]     [3K]   │
│ ─────────────────────────────────    │
│ Total: 5K tokens usados              │
│ Liberados: ~31K tokens               │
└──────────────────────────────────────┘

Comando /compact

> /compact

Así de simple. Claude Code comprime la conversación y te muestra un breve resumen de lo que preservó.

También puedes dar instrucciones sobre qué enfatizar en la compactación:

> /compact enfócate en las decisiones de arquitectura y los endpoints creados

Esto le dice a Claude qué priorizar en el resumen.

Qué se preserva vs qué se pierde

Se preserva	Se pierde
Dirección general del trabajo	Código exacto línea por línea
Decisiones tomadas	Razonamientos intermedios
Estructura de lo construido	Output de comandos
Nombres de archivos creados/modificados	Contenido literal de archivos leídos
Errores encontrados y cómo se resolvieron	Stack traces completos
CLAUDE.md (intacto, no se compacta)	Conversación exploratoria

Punto clave: Los archivos del proyecto no se pierden. Están en disco. Claude puede releerlos después de compaction. Lo que se pierde es el recuerdo de haberlos leído.

Ejemplo práctico: Antes y después

Conversación original (5 mensajes, ~40K tokens):

Tú: "Analiza src/auth/ y dime cómo funciona la autenticación"
Claude: [lee 8 archivos, explica JWT flow, middleware, refresh tokens...]

Tú: "Hay un bug: el refresh token no se invalida al logout"
Claude: [analiza, encuentra el problema en auth.service.ts línea 47]

Tú: "Corrígelo y agrega el token a una blacklist en Redis"
Claude: [implementa blacklist, modifica logout, modifica middleware]

Tú: "Crea tests para el nuevo flujo de logout"
Claude: [crea 6 tests con mocks de Redis]

Tú: "El test 3 falla porque el mock de Redis no simula TTL"
Claude: [corrige el mock, test pasa]

Después de /compact (~3K tokens):

[Resumen]: Trabajamos en el sistema de autenticación JWT en src/auth/. 
Encontramos y corregimos un bug donde el refresh token no se invalidaba 
al logout. Implementamos una blacklist en Redis (src/auth/token-blacklist.ts). 
Se crearon 6 tests en src/auth/__tests__/logout.test.ts, todos pasando. 
El mock de Redis necesitó soporte de TTL para funcionar correctamente.
Archivos modificados: auth.service.ts, auth.middleware.ts, 
token-blacklist.ts (nuevo), logout.test.ts (nuevo).

Claude ya no tiene el código exacto en contexto, pero sabe qué hizo, dónde, y por qué. Si necesita el código, lo relee del disco.

Cuándo Compactar

La regla del 70-80%

Compacta cuando el indicador de contexto llegue al 70-80%. No esperes al 95% — a ese punto la calidad ya degradó.

Context: ████████░░ 78%  ← Buen momento para /compact
Context: █████████▓ 95%  ← Ya es tarde, compacta ya

Señales para compactar

Señal	Acción
Indicador > 70%	`/compact`
Respuestas más lentas que antes	`/compact`
Claude "olvidó" algo que dijiste	`/compact`
Cambiaste de subtarea dentro del mismo tema	`/compact` con enfoque
Llevas > 15 mensajes	Evalúa si `/compact` o nueva sesión

Cuándo NO compactar

1. En medio de una operación multi-paso:

# NO compactes aquí:
Tú: "Migra la base de datos de SQLite a PostgreSQL"
Claude: "Paso 1 de 5: Creando schema PostgreSQL..."
# ← NO hagas /compact aquí, Claude perderá el plan de 5 pasos

# Espera a que termine los 5 pasos, luego compacta

2. Cuando necesitas detalles exactos del código actual:

# Si estás en medio de un debugging donde cada línea importa,
# compactar puede hacer que Claude olvide el detalle crítico.
# Mejor termina el debugging y luego compacta.

3. Cuando el contexto es pequeño:

# Si llevas 3 mensajes y el contexto está al 15%, 
# compactar no tiene sentido — no ganas nada.

Auto-Compaction

Cómo funciona

Claude Code puede ejecutar compaction automáticamente cuando detecta que el context window está cerca de su límite. No necesitas hacer nada — Claude decide cuándo es necesario.

# Estás trabajando normalmente...
Tú: "Ahora agrega validación al endpoint"

# Claude Code detecta contexto al 90%
[Sistema]: Auto-compacting conversation to free up context...

Claude: "He compactado la conversación. Aquí tienes un resumen 
         de lo que hemos hecho: [resumen]. Continuando con la 
         validación del endpoint..."

Configuración

La auto-compaction está habilitada por defecto. Puedes controlar su comportamiento en la configuración de Claude Code:

{
  "autoCompact": true,
  "compactThreshold": 80
}

¿Deberías depender de auto-compaction?

No como estrategia principal. Auto-compaction es una red de seguridad, no un plan. Razones:

Compacta en un momento que Claude decide, no tú
No puedes darle instrucciones sobre qué priorizar en el resumen
Puede interrumpir tu flujo en un momento inconveniente
La compaction manual con /compact [enfoque] produce mejores resúmenes

Mejor práctica: Compacta proactivamente con /compact antes de que la auto-compaction se active.

CLAUDE.md: Tu Contexto a Prueba de Compaction

Por qué CLAUDE.md es clave para la compaction

CLAUDE.md no se compacta. Siempre está ahí, íntegro, sin importar cuántas veces compactes o limpies la conversación.

# Después de /compact:
# ✅ CLAUDE.md → intacto
# ⚡ Conversación → resumida

# Después de /clear:
# ✅ CLAUDE.md → intacto
# ❌ Conversación → eliminada

# Después de nueva sesión:
# ✅ CLAUDE.md → intacto
# ❌ Conversación anterior → no existe

Esto tiene una implicación práctica enorme: todo lo que sea crítico para el proyecto debe vivir en CLAUDE.md, no en la conversación.

Qué mover a CLAUDE.md después de descubrirlo en conversación

# Durante la conversación descubriste que:
# - El proyecto usa un pattern específico de error handling
# - Hay una convención de naming no documentada
# - Ciertos archivos no deben tocarse

# Antes de compactar:
Tú: "Agrega a CLAUDE.md estas convenciones que descubrimos:
     1. Errors extienden BaseAppError en src/errors/base.ts
     2. Los migrations van en db/migrations/ con formato YYYYMMDD_name.sql
     3. No modificar src/legacy/ — es código que se va a deprecar"

Claude: [actualiza CLAUDE.md]

# Ahora puedes compactar sin miedo — las convenciones persisten
> /compact

Comparaciones y Decisiones

/compact vs /clear vs nueva sesión

Acción	Contexto conversación	CLAUDE.md	Archivos en disco	Cuándo usar
`/compact`	Resumido	Intacto	Intactos	Mismo tema, liberar espacio
`/clear`	Eliminado	Intacto	Intactos	Reset dentro de la misma terminal
Nueva sesión	No existe	Intacto	Intactos	Tema nuevo o contexto contaminado

Cuánto puedes trabajar antes de necesitar compactar

Escenario	Mensajes antes de compactar	Razón
Explorando codebase grande	5-8	Claude lee muchos archivos, consumo alto
Coding con archivos pequeños	15-20	Mensajes cortos, poco consumo por turno
Debugging con stack traces	8-12	Stack traces consumen mucho contexto
Code review	3-5	Cada archivo leído consume mucho
Conversación solo texto	25-30	Sin archivos ni comandos, bajo consumo

Impacto de compaction en calidad

# Fórmula mental:
Calidad = f(relevancia del contexto, no cantidad)

# Contexto al 90% con mucho ruido:
# → Respuestas genéricas, olvidos, lentitud

# Contexto al 30% post-compaction con resumen limpio:
# → Respuestas enfocadas, rápidas, precisas

# Contraejemplo: compactar en medio de un debugging complejo:
# → Claude pierde el hilo del bug, calidad baja

La compaction mejora la calidad cuando hay mucho contexto irrelevante acumulado. Empeora la calidad cuando elimina contexto que todavía era relevante.

Patterns Comunes

Pattern 1: "Checkpoint, Save, Compact"

Antes de compactar, guarda lo importante fuera de la conversación.

# Paso 1: Checkpoint — pide resumen
Tú: "Resume las decisiones de diseño que hemos tomado hasta ahora."
Claude: [lista de decisiones]

# Paso 2: Save — persiste lo importante
Tú: "Agrega esas decisiones a CLAUDE.md bajo una sección 
     '## Decisiones de arquitectura'."
Claude: [actualiza CLAUDE.md]

# Paso 3: Compact — libera contexto
> /compact

# Ahora tienes contexto limpio + decisiones persistidas en CLAUDE.md

Pattern 2: "Divide por fase"

Para tareas grandes, planifica cuándo compactar.

# Fase 1: Exploración (consume mucho contexto leyendo archivos)
Tú: "Analiza la estructura del proyecto, las dependencias, 
     y cómo funciona el sistema de rutas."
Claude: [lee muchos archivos, explica]

> /compact enfócate en la estructura del proyecto y el sistema de rutas

# Fase 2: Diseño (consume menos, es conversación)
Tú: "Diseña un módulo de notificaciones. Schema, endpoints, flujo."
Claude: [diseña]

# Fase 3: Implementación (consume mucho, genera código)
Tú: "Implementa el schema y el modelo."
Claude: [implementa]

> /compact enfócate en lo que se implementó y dónde están los archivos

# Fase 4: Testing
Tú: "Crea tests para el módulo de notificaciones."

Pattern 3: "Contexto mínimo viable"

Trabaja solo con los archivos que necesitas, no con todo el codebase.

# MAL — carga innecesaria:
Tú: "Lee todos los archivos en src/ y luego modifica el endpoint de login."
# Claude lee 50 archivos, gasta 200K tokens, solo necesitaba 3 archivos

# BIEN — contexto enfocado:
Tú: "Modifica el endpoint de login en src/auth/login.controller.ts. 
     Si necesitas ver cómo funciona el middleware de auth, está en 
     src/middleware/auth.ts."
# Claude lee 2-3 archivos, gasta 10K tokens

Pattern 4: "Fresh context para tareas críticas"

Para tareas que requieren máxima precisión, trabaja con contexto fresco.

# Estás al 60% de contexto y necesitas hacer un refactor delicado

# Opción A: Seguir con contexto parcialmente relevante
# Riesgo: Claude podría mezclar contexto de tareas anteriores

# Opción B: /compact y continuar con contexto limpio
> /compact enfócate en el estado actual de los archivos de autenticación
Tú: "Refactoriza src/auth/ para separar la lógica de tokens 
     en su propio módulo."

# Opción C: Nueva sesión para máxima claridad
# (ver siguiente cápsula: Cuándo empezar nueva sesión)

Pitfalls y Edge Cases

Pitfall 1: Compactar demasiado pronto

# Llevas 3 mensajes, contexto al 15%
> /compact  ← innecesario

# Pierdes detalles de la conversación sin ganar nada
# Solo compacta cuando hay algo que ganar (>50% de contexto usado)

Pitfall 2: Nunca compactar

# Llevas 25 mensajes, contexto al 92%
# Las respuestas son lentas y genéricas
# Claude "olvida" convenciones que le dijiste
# → Deberías haber compactado hace 10 mensajes

Pitfall 3: Compactar sin guardar decisiones

# Descubriste durante la conversación que el proyecto usa un 
# pattern específico de error handling. No lo guardaste en 
# CLAUDE.md. Haces /compact. El resumen no captura ese detalle.
# En el siguiente mensaje, Claude genera errores con un pattern diferente.

# Solución: siempre persiste hallazgos importantes en CLAUDE.md 
# ANTES de compactar

Pitfall 4: Confundir tokens con líneas de código

# "Mi archivo tiene 200 líneas, no puede consumir tanto contexto"
# 
# En realidad:
# - 200 líneas de TypeScript denso ≈ 3,000-5,000 tokens
# - 200 líneas de JSON ≈ 2,000-4,000 tokens  
# - package-lock.json (miles de líneas) ≈ 100K+ tokens
#
# Los tokens NO son líneas. Una línea puede tener 5-50 tokens.

Pitfall 5: No dar enfoque al compactar

# Sin enfoque:
> /compact
# Claude hace un resumen genérico — puede perder lo importante

# Con enfoque:
> /compact prioriza las decisiones de arquitectura, los archivos 
  modificados, y el bug de autenticación que estamos debuggeando
# Claude hace un resumen que preserva lo que necesitas

Edge Case: Archivos muy grandes

# Si Claude leyó un archivo de 10,000 líneas, ese archivo 
# consume ~50K-100K tokens del contexto.
# Después de compaction, el contenido del archivo se pierde,
# pero Claude puede releerlo si lo necesita.
# 
# Estrategia: en vez de pedir "lee todo el archivo", pide
# "lee las líneas 100-200 de file.ts" para consumir menos.

Ejemplo Completo Integrado

Escenario: Sesión larga de desarrollo con gestión de contexto

# ═══════════════════════════════════════════
# SESIÓN: Construir sistema de comentarios
# Proyecto: API REST con Express + PostgreSQL
# ═══════════════════════════════════════════

# ─── Fase 1: Exploración (~15% contexto) ───

Tú: "Analiza cómo están estructurados los modelos en src/models/ 
     y los controllers en src/controllers/. Necesito entender el 
     pattern para agregar un sistema de comentarios."

Claude: [lee 6 archivos, explica patterns]
# Contexto: ~20%

# ─── Fase 2: Diseño (~30% contexto) ───

Tú: "Diseña el modelo Comment: id, postId, userId, content, 
     createdAt, updatedAt, parentId (para replies). Y los endpoints 
     CRUD. Solo diseño, no implementes."

Claude: [diseña schema y endpoints]
# Contexto: ~28%

Tú: "Agrega soft delete (deletedAt) y un campo 'edited' boolean."

Claude: [ajusta diseño]
# Contexto: ~32%

# ─── Fase 3: Implementación model (~50% contexto) ───

Tú: "Crea la migración y el modelo Prisma para Comment."

Claude: [crea migración y modelo]
# Contexto: ~40%

Tú: "Implementa el service con CRUD completo."

Claude: [implementa service]
# Contexto: ~52%

# ─── CHECKPOINT: Compaction estratégica ───

Tú: "Antes de continuar, agrega a CLAUDE.md: 'El sistema de 
     comentarios usa soft delete, replies anidadas con parentId, 
     y campo edited para comentarios modificados. Modelo en 
     prisma/schema.prisma, service en src/services/comment.service.ts.'"

Claude: [actualiza CLAUDE.md]

> /compact enfócate en: modelo Comment creado con soft delete y replies, 
  service implementado en src/services/comment.service.ts, 
  faltan controller, rutas, y tests

# Contexto después de compact: ~12%

# ─── Fase 4: Controller y rutas (contexto fresco) ───

Tú: "Implementa el controller y las rutas para comments. 
     Sigue el pattern de los otros controllers del proyecto."

Claude: [relee un controller existente como referencia, implementa]
# Contexto: ~25%

# ─── Fase 5: Tests ───

Tú: "Tests con Vitest para el comment service: 
     CRUD completo, soft delete, replies, y edit."

Claude: [crea tests]
# Contexto: ~40%

Tú: "Ejecuta los tests."
Claude: [ejecuta, muestra resultados]
# Contexto: ~45%

# ─── Resultado final ───
# Sesión productiva con 1 compaction estratégica
# Contexto nunca pasó del 55%
# Calidad consistente en toda la sesión
# Decisiones persistidas en CLAUDE.md

Ejercicios Prácticos

Ejercicio 1: Monitorear el consumo de contexto

Abre una sesión de Claude Code. Haz las siguientes operaciones y observa cómo cambia el indicador de contexto después de cada una:

Envía un mensaje corto ("Hola, ¿qué modelo estás usando?")
Pide que lea un archivo pequeño (<50 líneas)
Pide que lea un archivo grande (>300 líneas)
Pide que ejecute ls -la en la raíz del proyecto
Pide que ejecute npm test (o el test runner de tu proyecto)

Registra los cambios. ¿Qué operación consumió más contexto?

Qué observar

Típicamente el orden de mayor a menor consumo es:

Leer archivo grande — es el que más consume por mucho
Ejecutar tests — el output de tests puede ser extenso
Leer archivo pequeño — consumo modesto
ls -la — poco output, bajo consumo
Mensaje corto — mínimo

La lección: el factor #1 de consumo son los archivos leídos y el output de comandos, no tus mensajes. Sé selectivo con lo que le pides leer a Claude.

Ejercicio 2: Compaction manual vs automática

Inicia una sesión y trabaja hasta que el contexto esté al ~60%
Haz /compact con un enfoque específico
Inmediatamente pregunta: "¿Qué hemos hecho hasta ahora?"
Evalúa la calidad del resumen: ¿capturó lo importante?
Si falta algo, nota qué tipo de información se perdió

Qué observar

El resumen de /compact debería capturar:

Qué archivos se crearon/modificaron
Qué decisiones se tomaron
Cuál era el objetivo

Típicamente se pierde:

Código exacto generado
Razonamientos intermedios
Intentos fallidos
Output de comandos

Si el resumen no captura algo crítico, próxima vez:

Sé más específico con el enfoque de /compact
Guarda lo crítico en CLAUDE.md antes de compactar

Ejercicio 3: El impacto de la compaction en calidad

Realiza la misma tarea de dos formas:

Forma A: Sin compactar — acumula 15+ mensajes de conversación mixta (exploración, código, debugging) y luego pide una tarea que requiera contexto preciso.

Forma B: Con compaction estratégica — cada 5-7 mensajes, compacta con enfoque. Al final, pide la misma tarea.

Compara: ¿cuál produjo un mejor resultado para la tarea final?

Qué esperar

La Forma B (con compaction) generalmente produce mejores resultados para la tarea final porque:

El contexto es más limpio y relevante
Claude no tiene "ruido" de exploraciones anteriores
Los resúmenes de compaction actúan como "notas organizadas"

La Forma A puede funcionar bien si:

El contexto total todavía cabe cómodamente (<50%)
Todo el contexto acumulado es relevante para la tarea final

Conclusión: compaction no siempre es necesaria, pero cuando el contexto tiene mucho ruido, mejora notablemente la calidad.

Ejercicio 4: Persistir antes de compactar

Inicia una sesión y pide a Claude que analice algún aspecto de tu proyecto
Durante la conversación, identifica 3+ hallazgos o convenciones que Claude descubrió
Pide a Claude que los agregue a CLAUDE.md
Haz /compact
Verifica que los hallazgos siguen disponibles vía CLAUDE.md

Qué observar

Después de la compaction:

Claude puede referirse a los hallazgos porque están en CLAUDE.md
Si hubieras compactado SIN guardar en CLAUDE.md, esos hallazgos probablemente se habrían perdido o quedado como una mención vaga en el resumen

Este ejercicio demuestra el pattern "Save before Compact": siempre persiste lo valioso antes de liberar contexto.

Ejercicio 5: Estimar consumo antes de empezar

Antes de iniciar una tarea, estima cuánto contexto va a consumir:

¿Cuántos archivos necesita leer Claude? → Alto consumo
¿Necesita ejecutar comandos con output largo? → Alto consumo
¿Es mayormente conversación y código generado? → Medio consumo
¿Es una pregunta puntual? → Bajo consumo

Clasifica estas tareas de menor a mayor consumo:

a) "Renombra la variable x a userId en auth.ts"
b) "Analiza todo src/ y sugiere mejoras de arquitectura"
c) "Crea un endpoint CRUD para products"
d) "Ejecuta el test suite completo y corrige los que fallen"

Respuesta

De menor a mayor consumo:

(a) Renombrar variable — Lee 1 archivo, operación puntual. ~2-5K tokens.
(c) CRUD endpoint — Lee 2-3 archivos de referencia, genera código. ~15-30K tokens.
(d) Tests suite — Ejecuta tests (output puede ser largo), lee archivos que fallan, genera fixes. ~30-80K tokens.
(b) Analizar todo src/ — Lee MUCHOS archivos, genera análisis extenso. ~100K-500K tokens dependiendo del tamaño de src/.

Saber esto te permite planificar: para (b), probablemente necesites compactar después. Para (a), ni te preocupes.

Resumen

El context window es la memoria de trabajo de Claude Code. Todo lo que dices, lees, y ejecutas ocupa espacio.
Opus 5 y Sonnet 5 tienen 1M tokens; Haiku 4.5 tiene 200K. Suena mucho, pero archivos grandes y output de comandos lo llenan rápido.
Monitorea el indicador de contexto. Señales de saturación: respuestas lentas, olvidos, respuestas genéricas.
/compact resume la conversación y libera espacio. Preserva la dirección, pierde los detalles.
Compacta al 70-80%, no al 95%. Puedes dar enfoque: /compact prioriza X.
NO compactes en medio de operaciones multi-paso o debugging activo.
Auto-compaction existe como red de seguridad, pero no dependas de ella.
CLAUDE.md no se compacta. Todo lo crítico del proyecto debe vivir ahí.
Pattern clave: "Checkpoint, Save, Compact" — guarda hallazgos en CLAUDE.md antes de compactar.
El consumidor #1 de contexto son los archivos leídos y el output de comandos, no tus mensajes.
Contexto fresco = mejores respuestas. No acumules contexto irrelevante por pereza.

Recursos Adicionales

Claude Code Best Practices — Anthropic Docs — Incluye guías de context management
Claude Code Memory System — CLAUDE.md y jerarquía de memoria
Claude Code Interactive Mode — Comandos como /compact, /clear, y gestión de sesiones
Claude Code CLI Reference — Referencia completa de comandos y flags
Claude Models Overview — Especificaciones de Opus 5, Sonnet 5 y Haiku 4.5
Anthropic Cookbook — Long Context — Técnicas para manejar contextos largos con Claude
Claude Code Overview — Plataformas, capabilities, y límites

← AnteriorMulti-turn Conversations: Iterar Efectivamente con Claude Code Siguiente →Cuándo Empezar una Nueva Sesión vs Continuar la Actual

Context Window y Compaction: Gestionar la Memoria de Claude Code

Context Window y Compaction: Gestionar la Memoria de Claude Code

Descripción

Qué Es el Context Window

Definición técnica

Capacidades actuales (Feb 2026)

Qué consume más tokens

Cómo Monitorear el Contexto

El indicador de Claude Code

Señales de que el contexto se está llenando

Hooks de compaction (PreCompact / PostCompact)

Compaction: Qué Es y Cómo Funciona

Definición

Comando /compact

Qué se preserva vs qué se pierde

Ejemplo práctico: Antes y después

Cuándo Compactar

La regla del 70-80%

Señales para compactar

Cuándo NO compactar

Auto-Compaction

Cómo funciona

Configuración

¿Deberías depender de auto-compaction?

CLAUDE.md: Tu Contexto a Prueba de Compaction

Por qué CLAUDE.md es clave para la compaction

Qué mover a CLAUDE.md después de descubrirlo en conversación

Comparaciones y Decisiones

/compact vs /clear vs nueva sesión

Cuánto puedes trabajar antes de necesitar compactar

Impacto de compaction en calidad

Patterns Comunes

Pattern 1: "Checkpoint, Save, Compact"

Pattern 2: "Divide por fase"

Pattern 3: "Contexto mínimo viable"

Pattern 4: "Fresh context para tareas críticas"

Pitfalls y Edge Cases

Pitfall 1: Compactar demasiado pronto

Pitfall 2: Nunca compactar

Pitfall 3: Compactar sin guardar decisiones

Pitfall 4: Confundir tokens con líneas de código

Pitfall 5: No dar enfoque al compactar

Edge Case: Archivos muy grandes

Ejemplo Completo Integrado

Escenario: Sesión larga de desarrollo con gestión de contexto

Ejercicios Prácticos

Ejercicio 1: Monitorear el consumo de contexto

Ejercicio 2: Compaction manual vs automática

Ejercicio 3: El impacto de la compaction en calidad

Ejercicio 4: Persistir antes de compactar

Ejercicio 5: Estimar consumo antes de empezar

Resumen

Recursos Adicionales

Hooks de compaction (`PreCompact` / `PostCompact`)