Uno de los conceptos más importantes para dominar Claude Code es entender cómo funciona la ventana de contexto y cómo optimizar su uso para sesiones más largas y productivas.

¿Qué es la ventana de contexto?

La ventana de contexto (o context window) es la cantidad máxima de información que Claude puede "recordar" y procesar en una conversación. Se mide en tokens.

¿Qué es un token?

Un token es una unidad de texto que el modelo usa para procesar lenguaje. No es exactamente una palabra ni un carácter, sino algo intermedio.

Regla aproximada:

1 token ≈ 4 caracteres en inglés
1 token ≈ 0.75 palabras en inglés
1 token ≈ 3-4 caracteres en español

Ejemplos:

"Hola" = 1 token
"Claude Code" = 2 tokens
"autenticación" = 3 tokens
"const userName = 'John';" = 7 tokens

Para visualizar cómo se tokeniza el texto, puedes usar herramientas como:

Anthropic Tokenizer (oficial)
OpenAI Tokenizer (similar)

Ventana de contexto por modelo

Todos los modelos Claude actuales tienen la misma ventana de contexto:

Modelo	Context Window	Aproximado en palabras	Aproximado en páginas
Opus 4.5	200,000 tokens	~150,000 palabras	~600 páginas
Sonnet 4.5	200,000 tokens	~150,000 palabras	~600 páginas
Haiku 4.5	200,000 tokens	~150,000 palabras	~600 páginas

Referencia:

200K tokens equivalen aproximadamente a una novela completa
Es suficiente para analizar codebases medianos completos
Permite conversaciones muy largas con contexto completo

¿Qué consume tokens en Claude Code?

Cuando trabajas con Claude Code, varios elementos consumen tokens de tu ventana de contexto:

1. Mensajes del usuario

Cada mensaje que escribes consume tokens.

> Implementa autenticación JWT

Consumo: ~5 tokens

> Implementa autenticación JWT completa con:
  - Login y registro
  - Refresh tokens
  - Middleware de autorización
  - Tests exhaustivos
  - Documentación de la API

Consumo: ~35 tokens

2. Respuestas de Claude

Cada respuesta que Claude genera también consume tokens.

Una respuesta corta:

Voy a implementar la autenticación JWT paso a paso.

Consumo: ~12 tokens

Una respuesta larga con código:

[Explicación detallada + 100 líneas de código + ejemplos]

Consumo: ~500-1000 tokens

3. Archivos leídos

Cuando Claude lee archivos con la herramienta Read, el contenido completo se añade al contexto.

// src/auth/jwt.ts (50 líneas)
import jwt from 'jsonwebtoken';
 
export function generateToken(userId: string): string {
  return jwt.sign({ userId }, process.env.JWT_SECRET!, {
    expiresIn: '24h'
  });
}
 
// ... resto del archivo

Consumo: ~400-600 tokens (dependiendo de la densidad del código)

Importante:

Cada archivo leído permanece en contexto para toda la sesión
Leer muchos archivos grandes llena el contexto rápidamente
Claude no vuelve a leer archivos que ya están en contexto (optimización automática)

4. Resultados de herramientas

Los resultados de comandos bash, búsquedas, etc. también consumen tokens.

# Comando
git log --oneline -20
 
# Resultado (20 commits)
abc123 feat: add JWT auth
def456 fix: email validation
...

Consumo: ~200-400 tokens

5. Contexto del sistema (CLAUDE.md)

El archivo CLAUDE.md se carga automáticamente y consume tokens durante toda la sesión.

# Proyecto: Mi App
 
## Arquitectura
Frontend: React + TypeScript
Backend: Node.js + Express
...
 
## Convenciones
- No usar any
- Tests obligatorios
...

Consumo: Variable, típicamente 200-2000 tokens dependiendo del tamaño.

Optimización:

CLAUDE.md se carga una sola vez al inicio
Es más eficiente que repetir instrucciones en cada mensaje
Mantén CLAUDE.md conciso pero completo

6. Historial de la conversación

Todo el historial de la sesión permanece en contexto:

Tus mensajes anteriores
Respuestas previas de Claude
Archivos leídos
Resultados de comandos

Una conversación típica de 30 mensajes con código puede consumir 50,000-80,000 tokens.

Ejemplo de cálculo de contexto

Veamos una sesión típica de desarrollo:

Inicio de sesión:
├─ System prompt (interno)         → ~2,000 tokens
├─ CLAUDE.md del proyecto          → ~1,000 tokens
├─ Skills cargadas                 → ~500 tokens
└─ Total inicial                   → ~3,500 tokens
 
Desarrollo de feature:
├─ Mensaje: "Implementa login JWT" → ~10 tokens
├─ Respuesta de Claude             → ~200 tokens
├─ Lee src/auth/types.ts           → ~300 tokens
├─ Lee src/config/jwt.ts           → ~250 tokens
├─ Implementa src/auth/login.ts    → ~800 tokens
├─ Crea tests                      → ~600 tokens
├─ Ejecuta npm test (resultado)    → ~400 tokens
└─ Total después de feature        → ~6,060 tokens (+ 3,500 inicial = 9,560)
 
Continúa conversación (20 mensajes más):
├─ Mensajes y respuestas           → ~15,000 tokens
├─ 5 archivos más leídos           → ~2,500 tokens
├─ Resultados de comandos          → ~3,000 tokens
└─ Total acumulado                 → ~30,060 tokens

Con 30,000 tokens usados de 200,000 disponibles, aún tienes 85% de contexto libre.

Ventajas de una ventana de contexto grande

1. Sesiones más largas

Con 200K tokens puedes tener conversaciones muy extensas sin perder contexto:

Sesión típica de 1-2 horas: 20,000-50,000 tokens
Sesión compleja de 4-6 horas: 80,000-120,000 tokens
Sesión intensiva de todo el día: 150,000-180,000 tokens

2. Leer archivos grandes sin problemas

Puedes leer archivos grandes sin preocuparte:

Archivo de 500 líneas: ~3,000-5,000 tokens
Archivo de 1000 líneas: ~6,000-10,000 tokens

Con 200K tokens, puedes leer 20-30 archivos medianos antes de acercarte al límite.

3. Mantener contexto completo del proyecto

Claude puede tener en memoria simultáneamente:

Arquitectura del proyecto (desde CLAUDE.md)
10-20 archivos de código relevantes
Historial completo de la conversación
Resultados de comandos y tests
Todo el contexto de debugging

Esto permite respuestas más precisas y coherentes.

4. Análisis de codebase completo

Puedes analizar proyectos completos:

> Analiza toda la estructura de autenticación del proyecto

Claude puede leer:

src/auth/login.ts
src/auth/register.ts
src/auth/jwt.ts
src/middleware/auth.ts
tests/auth/*.test.ts
docs/auth.md

Y entender las relaciones entre todos los archivos.

¿Qué pasa cuando el contexto se llena?

Cuando te acercas al límite de 200K tokens, Claude Code usa resúmenes automáticos para mantener la conversación fluida.

Comportamiento automático

Antes del límite (< 180K tokens):
- Todo funciona normal
- Contexto completo disponible
Cerca del límite (180K-195K tokens):
- Claude comienza a resumir mensajes antiguos automáticamente
- Se prioriza:
  - Mensajes recientes (últimos 20-30)
  - Archivos más relevantes
  - Información del CLAUDE.md
  - Resultados de comandos recientes
En el límite (>195K tokens):
- Se activa compactación agresiva
- Solo se mantiene contexto esencial
- Puedes usar /compact manualmente (ver punto 9.3)

Síntomas de contexto lleno

Los veremos en detalle en el punto 9.2, pero incluyen:

Respuestas más lentas
Claude "olvida" cosas mencionadas hace mucho
Degradación en coherencia

Comparación con otros LLMs

Para poner en perspectiva la ventana de 200K tokens:

Modelo	Context Window	Comparación
Claude 3.5 Sonnet	200,000 tokens	⭐ Referencia
GPT-4 Turbo	128,000 tokens	64% del de Claude
GPT-4	8,000 tokens	4% del de Claude
Gemini 1.5 Pro	1,000,000 tokens	5x Claude (pero menos común)

Claude Code tiene una de las ventanas de contexto más generosas del mercado, lo que permite sesiones de desarrollo muy largas sin interrupciones.

Estrategias para maximizar el uso del contexto

Veremos esto en detalle en el punto 9.4, pero aquí van algunos tips iniciales:

✅ Hacer

Usa CLAUDE.md para información repetitiva
Mensajes concisos cuando sea posible
Lee solo archivos necesarios en cada momento
Usa /compact cuando notes degradación

❌ Evitar

Pegar archivos completos en mensajes (usa Read en su lugar)
Repetir instrucciones que ya están en CLAUDE.md
Leer archivos generados innecesariamente (node_modules, dist, etc.)
Comandos con output masivo (ej: git log --all en repos gigantes)

Monitoreo del contexto

Puedes verificar el uso actual de contexto con:

> /context

Esto muestra:

Tokens usados actualmente
Archivos cargados en contexto
Skills activas
Espacio disponible

Ejemplo de output:

📊 Context Usage:
├─ Tokens used: 45,230 / 200,000 (22.6%)
├─ Files loaded: 8
│  ├─ src/auth/login.ts
│  ├─ src/auth/jwt.ts
│  ├─ src/middleware/auth.ts
│  └─ ... (5 more)
├─ Skills loaded: 3
│  ├─ /commit
│  ├─ /review
│  └─ /test
└─ Context remaining: 154,770 tokens (77.4%)
 
💡 Tip: You have plenty of context available!

Casos prácticos

Caso 1: Desarrollo de feature simple

Escenario: Implementar validación de email

Tokens usados:
- CLAUDE.md: 800 tokens
- Conversación (10 mensajes): 3,000 tokens
- 2 archivos leídos: 1,000 tokens
- Código generado: 500 tokens
Total: ~5,300 tokens (2.6% del contexto)

Conclusión: Sesión muy ligera, puedes continuar sin preocupaciones.

Caso 2: Debugging complejo

Escenario: Investigar bug en sistema de autenticación

Tokens usados:
- CLAUDE.md: 1,000 tokens
- Conversación (40 mensajes): 20,000 tokens
- 15 archivos leídos: 8,000 tokens
- Logs de errores: 5,000 tokens
- Pruebas y resultados: 8,000 tokens
Total: ~42,000 tokens (21% del contexto)

Conclusión: Sesión moderada, aún tienes 79% disponible.

Caso 3: Refactor masivo

Escenario: Refactorizar arquitectura de todo un módulo

Tokens usados:
- CLAUDE.md: 1,500 tokens
- Conversación (100 mensajes): 60,000 tokens
- 30 archivos leídos: 25,000 tokens
- Diffs y cambios: 15,000 tokens
- Tests y resultados: 10,000 tokens
Total: ~111,500 tokens (55% del contexto)

Conclusión: Sesión pesada. Considera usar /compact si continúas mucho más.

Resumen

La ventana de contexto de Claude Code es:

✅ 200,000 tokens para todos los modelos ✅ Suficiente para la mayoría de sesiones de desarrollo ✅ Compartida entre todos los elementos (mensajes, archivos, comandos) ✅ Gestionada automáticamente con resúmenes cuando se llena ✅ Monitoreable con el comando /context

Consume tokens:

Mensajes del usuario y respuestas de Claude
Archivos leídos con Read
Resultados de comandos bash
CLAUDE.md y skills cargadas
Todo el historial de la conversación

Para sesiones óptimas:

Entiende qué consume tokens
Monitorea con /context en sesiones largas
Usa CLAUDE.md para información repetitiva
Lee solo archivos necesarios
Usa /compact cuando sea necesario

En el siguiente punto (9.2) aprenderás a identificar los síntomas de contexto lleno para actuar antes de que afecte tu productividad.

9.2 Síntomas de contexto lleno

Saber detectar cuándo el contexto se está llenando es crucial para mantener la calidad de tus sesiones con Claude Code. En este punto aprenderás a identificar los signos de alerta y cómo actuar antes de que afecte tu productividad.

¿Por qué importa detectar el contexto lleno?

Cuando el contexto se acerca al límite (200K tokens), Claude Code debe comprometer algunas cosas para continuar funcionando:

Resume automáticamente mensajes antiguos
Prioriza información reciente sobre antigua
Puede "olvidar" detalles mencionados hace tiempo
Respuestas más lentas debido al procesamiento adicional

Detectar estos síntomas temprano te permite tomar acción (como usar /compact o iniciar nueva sesión) antes de que la calidad se degrade significativamente.

Síntomas principales

1. Claude "olvida" cosas mencionadas anteriormente

Síntoma más común y obvio.

Ejemplo:

[Inicio de sesión]
Usuario: Estamos usando PostgreSQL con Prisma.
          Toda la DB está en src/db/
 
Claude: Entendido, veo que usan PostgreSQL con Prisma.
 
[... 80 mensajes después ...]
 
Usuario: Añade una consulta a la tabla users
 
Claude: ¿Qué base de datos estás usando?

¿Qué pasó?

La información inicial se resumió o eliminó del contexto
Claude perdió el detalle de qué DB y ORM se usa
Señal clara de que el contexto está lleno

Cómo identificarlo:

✅ Pregunta información que ya diste al inicio de la sesión ✅ No recuerda decisiones tomadas hace muchos mensajes ✅ Pide aclaraciones sobre convenciones ya establecidas

2. Respuestas más lentas

Cuando el contexto está lleno, Claude necesita más tiempo para procesar.

Comportamiento normal:

Usuario: Crea una función que valide emails
[Claude responde en 2-4 segundos]

Con contexto lleno:

Usuario: Crea una función que valide emails
[Claude responde en 8-15 segundos o más]

Nota: La lentitud también puede deberse a:

Carga de servidores de Anthropic
Tu conexión a internet
Complejidad de la tarea

Pero si notas lentitud progresiva a medida que avanza la sesión, probablemente es el contexto.

3. Respuestas menos coherentes con el proyecto

Claude pierde el hilo del contexto arquitectónico del proyecto.

Ejemplo:

[CLAUDE.md especifica: "Siempre usar async/await, NUNCA callbacks"]
 
[Inicio de sesión - comportamiento correcto]
Usuario: Implementa la función de login
 
Claude: async function login(email: string, password: string) {
          const user = await db.users.findOne({ email });
          ...
        }
 
[... 100 mensajes después - contexto lleno]
Usuario: Implementa la función de logout
 
Claude: function logout(userId, callback) {
          db.sessions.delete(userId, (err, result) => {
            if (err) callback(err);
            ...
          });
        }

¿Qué pasó?

Claude "olvidó" las convenciones en CLAUDE.md
Volvió a patterns que no usas en tu proyecto
Señal de que el contexto está resumido

4. Pregunta por archivos que ya leyó

Claude tiene un mecanismo para no releer archivos que ya están en contexto, pero si el contexto se resumió, puede perder esa información.

Ejemplo:

[Mensaje 10]
Usuario: Lee src/auth/jwt.ts y explícalo
 
Claude: [Lee archivo]
        Este archivo maneja la generación de tokens JWT...
 
[Mensaje 90]
Usuario: Modifica la función generateToken en src/auth/jwt.ts
 
Claude: No tengo visibilidad de ese archivo.
        ¿Puedes mostrarme src/auth/jwt.ts?

Señal clara: El archivo fue resumido/eliminado del contexto activo.

5. Pérdida de contexto de debugging

Durante sesiones largas de debugging, pierdes el hilo de investigación.

Ejemplo:

[Mensajes 1-30: Investigando bug en autenticación]
Usuario: El token expira antes de tiempo
Claude: [Lee múltiples archivos, analiza código]
        El problema está en src/config/jwt.ts línea 12
 
Usuario: ¿Por qué pasa eso?
Claude: [Analiza más]
        Porque estás usando segundos pero la librería espera milisegundos
 
[Mensajes 31-80: Otros temas]
...
 
[Mensaje 81]
Usuario: ¿Cuál era el bug del token que encontramos antes?
 
Claude: ¿Puedes darme más contexto sobre qué bug del token?

Señal: Claude perdió el contexto completo del debugging anterior.

6. Respuestas genéricas en lugar de específicas

Claude empieza a dar respuestas más generales que no consideran tu codebase específico.

Ejemplo con contexto disponible:

Usuario: ¿Cómo valido emails en este proyecto?
 
Claude: En tu proyecto usas la función validateEmail
        de src/utils/validators.ts que implementa:
        - Regex para formato básico
        - Verificación de dominios permitidos
        - Normalización a lowercase
 
        La puedes usar así: validateEmail(email)

Con contexto lleno:

Usuario: ¿Cómo valido emails en este proyecto?
 
Claude: Para validar emails puedes:
        1. Usar una librería como validator.js
        2. Implementar tu propio regex
        3. Usar HTML5 email input
 
        Ejemplo con validator.js:
        import validator from 'validator';
        validator.isEmail('test@example.com');

Diferencia: La segunda respuesta es genérica, no considera tu implementación existente.

7. Repetición de información ya discutida

Claude vuelve a explicar cosas que ya explicó antes en la misma sesión.

Ejemplo:

[Mensaje 20]
Usuario: Explícame qué es JWT
 
Claude: [Explicación detallada de JWT]
 
[Mensaje 80]
Usuario: ¿Los JWT son seguros para tokens de sesión?
 
Claude: Primero déjame explicarte qué es JWT.
        JWT significa JSON Web Token y es un estándar...

Señal: Claude no recuerda que ya explicó JWT.

Síntomas secundarios

8. Errores al referenciar variables o funciones

Claude menciona variables/funciones que no existen o usa nombres incorrectos.

[En el archivo real la función se llama: getUserById]
 
Claude: Puedes usar la función fetchUser() que está
        en src/services/userService.ts

Causa: El contexto se resumió y Claude "alucinó" el nombre de la función.

9. Código que no sigue patterns establecidos

Claude genera código que no se alinea con los patterns que ya usaste en la sesión.

[Toda la sesión has usado interfaces con prefijo I]
 
[Mensaje 90]
Claude: interface UserProfile {
          name: string;
          email: string;
        }

Esperado (según tu pattern):

interface IUserProfile {
  name: string;
  email: string;
}

10. No relaciona archivos entre sí

Claude trata archivos de forma aislada sin ver las relaciones.

Usuario: ¿UserService depende de AuthService?
 
[Con contexto lleno]
Claude: No tengo suficiente información para confirmar eso.
 
[Con contexto disponible]
Claude: Sí, UserService importa validateToken de AuthService
        en la línea 3 de src/services/userService.ts

Escala de severidad

No todos los síntomas indican el mismo nivel de urgencia:

🟢 Leve (< 60% contexto usado)

Síntomas:

Ocasionalmente pide re-leer un archivo antiguo
Respuestas ligeramente más lentas

Acción: Ninguna, sigue trabajando normalmente.

🟡 Moderado (60-80% contexto usado)

Síntomas:

Olvida detalles mencionados hace >50 mensajes
Respuestas genéricas ocasionales
Lentitud notable

Acción: Considera usar /compact si planeas continuar mucho más.

🟠 Alto (80-95% contexto usado)

Síntomas:

Pérdida de contexto de debugging
No relaciona archivos entre sí
Pregunta información del CLAUDE.md
Lentitud significativa

Acción: Usa /compact inmediatamente o inicia nueva sesión.

🔴 Crítico (> 95% contexto usado)

Síntomas:

Claude "olvida" casi todo lo anterior
Respuestas muy genéricas
Errores y alucinaciones
Muy lento

Acción: Inicia nueva sesión. /compact puede no ser suficiente.

Cómo verificar el nivel de contexto

Método 1: Comando /context

> /context

Output:

📊 Context Usage:
├─ Tokens used: 165,430 / 200,000 (82.7%)
├─ Files loaded: 23
├─ Skills loaded: 4
└─ Context remaining: 34,570 tokens (17.3%)
 
⚠️ Warning: Context usage is high. Consider using /compact.

Interpretación:

< 50%: 🟢 Excelente
50-70%: 🟢 Bien
70-85%: 🟡 Moderado, monitorear
85-95%: 🟠 Alto, usar /compact
> 95%: 🔴 Crítico, nueva sesión

Método 2: Test de memoria

Pregunta algo que mencionaste hace muchos mensajes:

> ¿Recuerdas qué base de datos estamos usando?

Si Claude responde correctamente con detalles específicos, el contexto está bien.

Si responde genéricamente o pregunta de nuevo, el contexto está comprometido.

Método 3: Observar comportamiento

Monitorea:

¿Las respuestas son más lentas que al inicio?
¿Claude hace preguntas que ya respondiste?
¿El código generado sigue tus convenciones?

Comparación: Sesión normal vs. Contexto lleno

Sesión normal (30% contexto)

Usuario: Añade validación de email a la función register
 
Claude: [Lee src/auth/register.ts]
        Voy a añadir la validación usando la función
        validateEmail que ya tienes en src/utils/validators.ts
 
        [Genera código coherente con tu proyecto]
        ✅ Rapido (~3 segundos)
        ✅ Específico a tu codebase
        ✅ Sigue tus convenciones

Contexto lleno (90% contexto)

Usuario: Añade validación de email a la función register
 
Claude: [Tarda en responder ~12 segundos]
 
        Para validar emails, una buena opción es usar
        la librería validator.js:
 
        npm install validator
 
        import validator from 'validator';
 
        function register(email, password) {
          if (!validator.isEmail(email)) {
            throw new Error('Invalid email');
          }
          // ...
        }
 
        ❌ Lento
        ❌ Genérico (sugiere instalar librería que no usas)
        ❌ No usó tu función validateEmail existente
        ❌ Código no sigue tus convenciones (no async, no TypeScript)

Patrones de comportamiento que llenan el contexto rápido

🔴 Anti-pattern 1: Leer archivos masivamente

> Lee todos los archivos en src/

Si tienes 50 archivos, acabas de consumir 30,000-50,000 tokens de golpe.

🔴 Anti-pattern 2: Comandos con output enorme

> Ejecuta git log --all --graph

En repos grandes, el output puede ser 10,000+ líneas = 40,000+ tokens.

🔴 Anti-pattern 3: Copiar/pegar archivos completos en mensajes

> Aquí está el archivo completo:
  [Pega 500 líneas de código]
  ¿Qué problema tiene?

Mejor: Usa Read en lugar de copy/paste.

🔴 Anti-pattern 4: Conversaciones sin foco

> Ayúdame con autenticación
[30 mensajes]
> Ahora ayúdame con el sistema de notificaciones
[30 mensajes]
> Ahora con el dashboard
[30 mensajes]

Cada tema nuevo añade más archivos y contexto al stack.

Buenas prácticas para evitar llenar el contexto

✅ 1. Sesiones enfocadas

Una sesión = Un tema principal

Sesión 1: Implementar autenticación
Sesión 2: Implementar notificaciones
Sesión 3: Refactor de dashboard

✅ 2. Usar CLAUDE.md efectivamente

En lugar de repetir instrucciones en cada sesión, ponlas en CLAUDE.md.

❌ Mal:

[Cada nueva sesión]
Usuario: Recuerda que usamos TypeScript estricto,
         interfaces con prefijo I, async/await siempre...

✅ Bien:

[En CLAUDE.md]
## Convenciones TypeScript
- Modo estricto
- Interfaces: Prefijo I
- Funciones: async/await

✅ 3. Leer solo archivos necesarios

❌ Mal:

> Lee src/auth/login.ts, register.ts, jwt.ts,
  middleware.ts, types.ts, utils.ts

✅ Bien:

> Lee src/auth/login.ts
 
[Después de analizar]
> Ahora necesito ver src/auth/jwt.ts

✅ 4. Compactar proactivamente

No esperes a que el contexto esté al 95%. Usa /compact cuando llegues al 70-80% si planeas continuar la sesión.

> /context
[Muestra 75% usado]
 
> /compact

✅ 5. Nueva sesión para temas nuevos

Si completaste una tarea grande y vas a empezar algo diferente:

[Sesión 1 - Completada]
✅ Implementada autenticación JWT completa
 
[Nueva sesión para tema diferente]
> [Abrir nueva sesión de Claude Code]
> Ahora vamos a implementar el sistema de notificaciones

Test rápido: ¿Tu sesión está comprometida?

Responde estas preguntas:

¿Claude está más lento que al inicio de la sesión? (Sí/No)
¿Ha preguntado información que ya le diste? (Sí/No)
¿Las respuestas son menos específicas a tu proyecto? (Sí/No)
¿Has tenido >50 mensajes de conversación? (Sí/No)
¿Has leído >15 archivos? (Sí/No)

Resultados:

0-1 Sí: 🟢 Contexto saludable
2-3 Sí: 🟡 Monitorear con /context
4-5 Sí: 🟠 Usar /compact o nueva sesión

Caso real: Sesión de debugging que se degradó

[Mensaje 1-20: Debugging de bug en autenticación]
✅ Contexto: 15% usado
✅ Claude muy específico, rápido
 
[Mensaje 21-50: Implementar fix + tests]
✅ Contexto: 35% usado
✅ Sigue bien
 
[Mensaje 51-80: Refactor de módulo relacionado]
🟡 Contexto: 65% usado
🟡 Empieza a ralentizarse
 
[Mensaje 81-120: Otro bug encontrado durante refactor]
🟠 Contexto: 85% usado
🟠 Claude pregunta cosas ya dichas
🟠 Respuestas más genéricas
 
[Mensaje 121+: Intentar continuar]
🔴 Contexto: 95% usado
🔴 Claude "olvidó" detalles del debugging original
🔴 Muy lento
🔴 Alucinaciones en nombres de funciones
 
ACCIÓN: Usar /compact o nueva sesión

Lección: Deberías haber usado /compact alrededor del mensaje 80.

Resumen

Los síntomas principales de contexto lleno son:

🔴 Claude "olvida" información mencionada anteriormente 🔴 Respuestas más lentas progresivamente 🔴 Menos coherencia con el proyecto 🔴 Pregunta por archivos que ya leyó 🔴 Pérdida de contexto de debugging 🔴 Respuestas genéricas en lugar de específicas

Para prevenir:

✅ Usa /context para monitorear ✅ Sesiones enfocadas en un tema ✅ Lee solo archivos necesarios ✅ Usa CLAUDE.md para info repetitiva ✅ /compact al 70-80% si continúas ✅ Nueva sesión al 90%+

Escala de acción:

< 60%: 🟢 Continúa normal
60-80%: 🟡 Considera /compact si vas a continuar mucho
80-95%: 🟠 Usa /compact ahora
> 95%: 🔴 Nueva sesión recomendada

En el siguiente punto (9.3) aprenderás a usar el comando /compact para recuperar espacio en el contexto sin perder lo esencial de tu sesión.

9.3 Comando /compact

El comando /compact es tu herramienta principal para recuperar espacio en la ventana de contexto sin perder el hilo de tu trabajo. Aprende cuándo y cómo usarlo efectivamente.

¿Qué es /compact?

/compact es un comando nativo de Claude Code que resume la conversación actual para liberar espacio en el contexto mientras mantiene la información esencial.

¿Qué hace exactamente?

Analiza toda la conversación hasta el momento
Identifica la información más importante
Resume mensajes antiguos manteniendo lo esencial
Libera tokens para continuar la conversación
Mantiene los mensajes más recientes sin cambios

Analogía

Imagina tu conversación como un cuaderno de notas:

Antes de /compact:

Páginas 1-50: Todos los detalles de cada paso
Páginas 51-100: Conversación actual
Problema: El cuaderno está casi lleno

Después de /compact:

Página 1: Resumen ejecutivo de lo hecho
Páginas 2-50: Eliminadas, espacio libre
Páginas 51-100: Conversación reciente (sin cambios)
Resultado: Tienes espacio para continuar

Cuándo usar /compact

✅ Situaciones ideales

1. Contexto al 70-80%

> /context
 
📊 Context Usage:
├─ Tokens used: 155,000 / 200,000 (77.5%)
└─ Context remaining: 45,000 tokens (22.5%)

Acción: Usar /compact preventivamente si planeas continuar la sesión.

2. Notas síntomas de degradación

Respuestas más lentas
Claude "olvida" cosas
Pregunta información ya dada

Acción: Usar /compact inmediatamente.

3. Antes de una tarea compleja nueva

[Después de completar autenticación - 60% contexto usado]
 
Usuario: Perfecto. Ahora vamos a implementar
         el sistema de notificaciones completo.
 
[Antes de continuar]
> /compact
 
[Ahora sí]
> Implementa el sistema de notificaciones...

Beneficio: Empiezas la nueva tarea con contexto fresco.

4. Sesiones muy largas (>50 mensajes)

Incluso si el contexto no está lleno, una sesión larga se beneficia de compactación:

[Mensaje 60 de una sesión larga]
> /compact
 
[Continúa con espacio libre]

5. Después de debugging extenso

Las sesiones de debugging acumulan mucho contexto (logs, traces, intentos fallidos):

[Después de resolver un bug complejo]
> El bug está resuelto. Déjame compactar antes de continuar.
> /compact

❌ Cuándo NO usar /compact

1. Al inicio de la sesión

[Mensaje 5]
> /compact  ❌ Innecesario

Razón: No hay nada que compactar aún.

2. Contexto bajo (<50%)

> /context
📊 Context used: 35,000 / 200,000 (17.5%)
 
> /compact  ❌ Innecesario

Razón: Tienes mucho espacio disponible.

3. Cuando necesitas información antigua

[Mensaje 80]
Usuario: ¿Recuerdas el bug que encontramos en el mensaje 20?
         Necesito esos detalles exactos.
 
> /compact  ❌ Mala idea

Razón: Al compactar, perderás los detalles específicos del mensaje 20.

Cómo usar /compact

Uso básico

Simplemente escribe el comando:

> /compact

Proceso:

Claude Code analiza la conversación
Genera un resumen inteligente
Reemplaza mensajes antiguos con el resumen
Te muestra un reporte del resultado

Ejemplo de ejecución

> /compact
 
⏳ Compacting conversation...
 
✅ Compaction complete!
 
📊 Results:
├─ Tokens before: 165,430
├─ Tokens after: 58,220
├─ Tokens freed: 107,210 (64.8% reduction)
└─ Context remaining: 141,780 tokens (70.9%)
 
📝 Summary generated:
   This conversation focused on implementing JWT authentication
   for a Node.js/Express API. Key achievements:
   - Created auth service with token generation/validation
   - Implemented middleware for protected routes
   - Added comprehensive tests with 95% coverage
   - Fixed token expiration bug (seconds vs milliseconds)
 
   Current state: Authentication complete and tested.
   Active files in context: src/auth/jwt.ts, src/middleware/auth.ts
 
💡 You now have plenty of context to continue!

Interpretación del resultado

Tokens before: Lo que tenías antes de compactar Tokens after: Lo que tienes después (el resumen) Tokens freed: Cuánto espacio recuperaste Summary generated: Resumen de lo que se hizo

Qué se mantiene y qué se pierde

✅ Se mantiene

1. Información esencial

- Decisiones arquitectónicas importantes
- Bugs encontrados y sus soluciones
- Archivos clave en el proyecto
- Estado actual del desarrollo

2. Mensajes recientes

Los últimos 10-20 mensajes generalmente se mantienen sin cambios.

[Mensajes 1-70]: Resumidos ✂️
[Mensajes 71-90]: Intactos ✅

3. Contexto del CLAUDE.md

El archivo CLAUDE.md siempre se mantiene completo.

4. Skills cargadas

Las skills activas permanecen disponibles.

❌ Se pierde (o se resume)

1. Detalles granulares antiguos

[Antes de /compact]
Mensaje 20: "Cambia validateEmail para aceptar dominios .co.uk"
Mensaje 21: [Implementación exacta del cambio]
 
[Después de /compact]
Resumen: "Se actualizó validateEmail para soportar más dominios"

Perdido: Los detalles exactos de la implementación.

2. Conversaciones de debugging antiguas

[Antes de /compact]
Mensajes 10-40: [Stack traces completos, logs, intentos fallidos]
 
[Después de /compact]
Resumen: "Se debuggeó y resolvió un bug en la generación de tokens"

Perdido: Los stack traces y logs exactos.

3. Código generado en mensajes antiguos

[Antes de /compact]
Mensaje 25: [Claude generó 100 líneas de código]
 
[Después de /compact]
Resumen: "Se implementó la función authenticateUser"

Nota importante: El código sigue existiendo en tus archivos, solo se pierde de la conversación.

4. Exploraciones que no llevaron a nada

[Mensajes 30-35: Intentar enfoque A, no funcionó]
[Mensajes 36-40: Intentar enfoque B, no funcionó]
[Mensaje 41: Enfoque C funcionó ✅]
 
[Después de /compact]
Resumen: "Se implementó enfoque C exitosamente"

Perdido: Los intentos A y B (pero eso está bien).

Estrategias de uso efectivo

Estrategia 1: Compactación preventiva

No esperes a que el contexto esté lleno.

> /context
📊 Tokens used: 140,000 / 200,000 (70%)
 
> /compact preventivamente
 
[Ahora]
📊 Tokens used: 50,000 / 200,000 (25%)
✅ Espacio para continuar sin problemas

Estrategia 2: Compactar entre fases

Compacta al terminar una fase y antes de empezar otra.

[Fase 1: Implementación completa ✅]
> /compact
 
[Fase 2: Testing]
> Ahora escribamos tests exhaustivos

Estrategia 3: Documentar antes de compactar

Si hay información que necesitarás después, documéntala primero.

> Antes de compactar, documenta todas las decisiones
  técnicas que tomamos en DECISIONES.md
 
[Claude crea el documento]
 
> /compact
 
[Ahora la información está guardada en un archivo]

Estrategia 4: Compactar después de debugging

Una vez resuelto el bug, compacta para limpiar logs y traces.

[Debugging completo - 80% contexto usado]
> Bug resuelto. Compactemos para continuar.
> /compact
 
[Contexto limpio - 30% usado]
> Ahora implementemos la siguiente feature

Casos prácticos

Caso 1: Sesión larga de desarrollo

Escenario:

90 mensajes de conversación
Implementaste autenticación completa
Quieres continuar con autorización
Contexto al 75%

Acción:

> Hemos completado la autenticación. Antes de continuar
  con autorización, hagamos /compact
 
> /compact
 
✅ Tokens freed: 95,000 (64% reduction)
 
> Perfecto. Ahora implementemos el sistema de roles
  y permisos para autorización.

Resultado: Puedes continuar en la misma sesión sin problemas.

Caso 2: Debugging que se extendió

Escenario:

50 mensajes debuggeando un bug complejo
Múltiples archivos leídos
Logs y stack traces
Contexto al 85%
Bug finalmente resuelto

Acción:

> ✅ Bug resuelto. Voy a compactar toda la sesión
  de debugging para liberar espacio.
 
> /compact
 
✅ Compaction complete!
   Tokens freed: 110,000
 
> Ahora refactoricemos el código que arreglamos
  para hacerlo más mantenible.

Caso 3: Cambio de tema dentro de sesión

Escenario:

Implementaste feature A (40 mensajes)
Quieres empezar feature B (completamente diferente)
Contexto al 55%

Opciones:

Opción 1: Nueva sesión (recomendado)

[Cerrar sesión actual]
[Abrir nueva sesión]
> Implementar feature B

Opción 2: Compactar y continuar

> Feature A completa. Compactemos antes de empezar
  con algo totalmente diferente.
 
> /compact
 
> Ahora vamos con feature B...

Frecuencia recomendada

Proyectos pequeños/medianos

├─ Sesión típica: 30-50 mensajes
├─ Frecuencia: 0-1 veces por sesión
└─ Trigger: Cuando llegues a 70% contexto

Proyectos grandes/complejos

├─ Sesión típica: 60-100+ mensajes
├─ Frecuencia: 1-3 veces por sesión
└─ Triggers:
   ├─ Al 70% contexto
   ├─ Entre fases del desarrollo
   └─ Después de debugging complejo

Sesiones de debugging

├─ Frecuencia: Después de resolver cada bug
└─ Razón: Debugging acumula mucho contexto basura

/compact vs. Nueva sesión

¿Cuándo usar /compact?

✅ Quieres continuar en el mismo tema ✅ Contexto entre 60-90% ✅ Necesitas mantener skills cargadas ✅ Estás en medio de algo

Ejemplo:

Implementando sistema de autenticación complejo
├─ Login ✅
├─ Register ✅
├─ [Contexto 75%] → /compact
├─ Password reset (en progreso)
└─ OAuth2 (pendiente)

¿Cuándo usar nueva sesión?

✅ Cambias completamente de tema ✅ Contexto >90% ✅ Terminaste una tarea completa ✅ /compact no liberó suficiente espacio

Ejemplo:

[Sesión 1: Autenticación completa ✅]
[Nueva sesión]
[Sesión 2: Sistema de notificaciones]

Limitaciones de /compact

1. No es mágico

Si el contexto está al 98%, /compact puede reducirlo al 60-70%, pero no al 10%.

Antes: 196,000 tokens (98%)
Después: ~120,000 tokens (60%)

2. Pierdes granularidad

Los detalles específicos se resumen.

[Antes]
Mensaje 20: [Código exacto de validateEmail con 30 líneas]
 
[Después de /compact]
Resumen: "Se implementó validateEmail"

Si necesitas el código exacto, debes:

Leerlo del archivo
O buscarlo en tu historial de archivos

3. No recupera el 100%

Típicamente recuperas entre 50-70% del contexto usado.

Tokens usados: 160,000
Después de /compact: ~60,000 - 80,000
Recuperado: 80,000 - 100,000 tokens

4. Puede afectar coherencia si se abusa

Compactar múltiples veces en la misma sesión puede degradar la coherencia:

[Primera /compact]: ✅ Bien
[Segunda /compact]: ✅ Bien
[Tercera /compact]: 🟡 Empieza a perder hilo
[Cuarta /compact]: 🔴 Mejor nueva sesión

Buenas prácticas

✅ Hacer

Compactar preventivamente al 70% si continúas
Compactar entre fases del desarrollo
Documentar antes si hay info importante
Compactar después de debugging
Verificar resultado con /context después

❌ Evitar

Compactar con <50% contexto (innecesario)
Compactar repetidamente (>3 veces por sesión)
Compactar cuando necesitas info antigua específica
Compactar en lugar de nueva sesión para temas diferentes

Ejemplo completo de flujo

[Inicio de sesión]
Usuario: Implementa autenticación JWT
 
[... 40 mensajes implementando ...]
 
> /context
📊 Tokens used: 65,000 / 200,000 (32.5%)
 
[... 30 mensajes más - testing y fixes ...]
 
> /context
📊 Tokens used: 135,000 / 200,000 (67.5%)
 
Usuario: Autenticación completa. Antes de continuar
         con autorización, compactemos.
 
> /compact
 
✅ Compaction complete!
├─ Tokens before: 135,000
├─ Tokens after: 48,000
└─ Tokens freed: 87,000 (64.4% reduction)
 
> /context
📊 Tokens used: 48,000 / 200,000 (24%)
 
Usuario: Perfecto. Ahora implementemos el sistema
         de roles y permisos.
 
[... Continúa sin problemas ...]

Troubleshooting

Problema: /compact no liberó suficiente espacio

Antes: 180,000 tokens
Después: 150,000 tokens (solo 30K freed)

Causas posibles:

Muchos archivos grandes en contexto
Información muy densa y esencial
Mensajes recientes consumían mucho

Soluciones:

Iniciar nueva sesión
Cerrar archivos no necesarios (no hay comando directo, pero puedes mencionar que no los necesitas)
Enfocarte en menos archivos

Problema: Claude "olvidó" algo importante después de /compact

Solución:

> En el mensaje 30 mencionamos que usamos bcrypt para
  hash de passwords. ¿Lo recuerdas?
 
Claude: No tengo ese detalle en el resumen. ¿Puedes
        confirmarlo?
 
> Sí, usamos bcrypt. Está en src/auth/password.ts

O simplemente pide que lea el archivo de nuevo.

Problema: Después de /compact, Claude no relaciona archivos

Solución:

> Lee src/auth/login.ts y src/middleware/auth.ts
  y explica cómo se relacionan

Darle acceso a ambos archivos de nuevo restaura la relación.

Resumen

¿Qué es /compact?

Comando que resume la conversación para liberar contexto
Mantiene información esencial y mensajes recientes
Libera típicamente 50-70% del contexto usado

¿Cuándo usarlo? ✅ Contexto al 70-80% ✅ Entre fases del desarrollo ✅ Después de debugging ✅ Antes de tareas complejas nuevas

¿Cuándo NO usarlo? ❌ Contexto <50% ❌ Necesitas información antigua específica ❌ Al inicio de sesión

Limitaciones:

No recupera el 100%
Pierde detalles granulares
Abusar (>3 veces) puede degradar coherencia

Alternativa:

Nueva sesión para cambios completos de tema
Nueva sesión si contexto >90%

En el siguiente punto (9.4) aprenderás estrategias de optimización para evitar llenar el contexto en primer lugar y mantener sesiones eficientes.

9.4 Estrategias de optimización

La mejor forma de gestionar el contexto es optimizar su uso desde el principio. En este punto aprenderás técnicas para maximizar la eficiencia de tus sesiones con Claude Code.

Filosofía de optimización

Principio fundamental

"Mantén en contexto solo lo que necesitas, cuando lo necesitas"

No se trata de minimizar el uso de contexto a toda costa, sino de usarlo de forma inteligente y estratégica.

Balance correcto

❌ Demasiado restrictivo:
   No leer archivos → Respuestas genéricas
 
✅ Optimizado:
   Leer solo archivos relevantes → Respuestas específicas
 
❌ Demasiado liberal:
   Leer 50 archivos "por si acaso" → Contexto lleno rápidamente

Estrategia 1: CLAUDE.md efectivo

El archivo CLAUDE.md es tu arma secreta para optimizar contexto.

¿Por qué funciona?

CLAUDE.md se carga una sola vez al inicio y permanece disponible toda la sesión. Información que pondrías en CLAUDE.md vs. repetir en mensajes:

❌ Sin CLAUDE.md (ineficiente):

[Cada nueva sesión - 200 tokens]
Usuario: Recuerda que usamos:
- TypeScript estricto
- Interfaces con prefijo I
- async/await siempre
- Tests con Vitest
- No usar console.log
- Prisma como ORM
- PostgreSQL
...
 
[Tokens gastados: 200 × 10 sesiones = 2,000 tokens]

✅ Con CLAUDE.md (eficiente):

# CLAUDE.md (500 tokens, una sola vez)
 
## Stack
- TypeScript (modo estricto)
- PostgreSQL + Prisma
- Vitest para testing
 
## Convenciones
- Interfaces: Prefijo I
- Funciones: async/await
- Logging: usar logger de src/utils/logger.ts
...
 
[Tokens gastados: 500 tokens (solo una vez)]

Qué incluir en CLAUDE.md

✅ Información estable

## Stack tecnológico
## Convenciones de código
## Estructura de carpetas
## Comandos importantes
## Reglas invariables
## Patrones de diseño usados

❌ NO incluir

## TODOs actuales (cambian constantemente)
## Bugs conocidos (cambian con cada fix)
## Features en desarrollo (mejor en Issues/Tickets)

CLAUDE.md por niveles

Usa la jerarquía de CLAUDE.md estratégicamente:

~/.claude/CLAUDE.md              → Preferencias globales (500 tokens)
   - Estilo de código personal
   - Convenciones generales
 
/proyecto/CLAUDE.md              → Específico del proyecto (800 tokens)
   - Stack del proyecto
   - Arquitectura
   - Comandos
 
/proyecto/src/auth/CLAUDE.md     → Específico del módulo (200 tokens)
   - Detalles de autenticación
   - Flujos específicos

Total en contexto: 1,500 tokens vs. repetir 500 tokens en cada mensaje.

Estrategia 2: Leer archivos estratégicamente

La lectura de archivos es la fuente principal de consumo de contexto.

Técnica: Lectura incremental

❌ Leer todo de golpe:

> Lee todos los archivos de src/auth/

Resultado: 10 archivos × 500 tokens = 5,000 tokens de golpe

✅ Leer incrementalmente:

> Lee src/auth/login.ts
 
[Claude analiza]
 
> Ahora necesito ver src/auth/jwt.ts
 
[Claude lee solo ese]
 
> Perfecto. Con esos dos archivos implementa la feature

Resultado: 2 archivos × 500 tokens = 1,000 tokens

Técnica: Especificar secciones

En lugar de leer archivos completos, especifica qué necesitas:

❌ Leer archivo completo (500 líneas):

> Lee src/services/userService.ts

Tokens: ~3,000

✅ Especificar función:

> Muéstrame solo la función getUserById de src/services/userService.ts

Claude puede usar Grep para encontrar solo esa sección.

Tokens: ~200

Técnica: Glob pattern selectivo

❌ Patrón muy amplio:

> Lee todos los archivos .ts del proyecto

✅ Patrón específico:

> Lee solo los archivos *Service.ts de src/services/

Priorizar archivos

Mantén en contexto los archivos más relevantes para la tarea actual:

Implementando autenticación:
✅ src/auth/login.ts
✅ src/auth/jwt.ts
✅ src/middleware/auth.ts
❌ src/utils/validators.ts (a menos que lo necesites)
❌ src/services/emailService.ts (no relacionado)

Estrategia 3: Mensajes concisos y precisos

Cada palabra en tus mensajes consume tokens.

Comparación

❌ Verboso (50 tokens):

> Hola Claude, espero que estés bien. Me gustaría que por favor
  me ayudaras a implementar una función que se encargue de
  validar si un email tiene un formato correcto. La función
  debería retornar true si es válido y false si no lo es.
  Por favor usa TypeScript y sigue las convenciones del proyecto.

✅ Conciso (15 tokens):

> Implementa validateEmail(email: string): boolean
  Retorna true si el email es válido.

Ahorro: 35 tokens por mensaje. En 50 mensajes = 1,750 tokens.

Balance entre concisión y claridad

❌ Demasiado conciso (ambiguo):

> Haz login

¿Implementar? ¿Testear? ¿Debuggear?

✅ Conciso pero claro:

> Implementa la función login con validación de email y password

Usar referencias en lugar de copiar

❌ Copiar código en mensaje:

> Este código tiene un error:
 
[Pega 100 líneas de código]
 
¿Qué está mal?

Tokens: ~600

✅ Referenciar archivo:

> Hay un error en src/auth/login.ts línea 42.
  ¿Qué está mal?

Tokens: ~15

Claude puede leer el archivo si es necesario.

Estrategia 4: Evitar comandos con output masivo

Algunos comandos bash generan output gigantesco que llena el contexto.

❌ Comandos peligrosos

git log sin límite

> git log --all --graph
 
[Output: 5,000 commits = 30,000 tokens]

✅ Mejor:

> git log --oneline -20
 
[Output: 20 commits = 400 tokens]

find masivo

> find . -name "*.ts"
 
[Output: 500 archivos = 3,000 tokens]

✅ Mejor:

> find ./src/auth -name "*.ts"
 
[Output: 10 archivos = 100 tokens]

cat de archivos gigantes

> cat package-lock.json
 
[Output: 10,000 líneas = 50,000 tokens]

✅ Mejor:

> cat package.json
 
[Output: 50 líneas = 300 tokens]

npm list completo

> npm list
 
[Output: Árbol completo = 10,000 tokens]

✅ Mejor:

> npm list --depth=0
 
[Output: Solo dependencias directas = 500 tokens]

Usar flags de limitación

La mayoría de comandos tienen flags para limitar output:

Comando	Flag de limitación
`git log`	`--oneline -N` o `-N`
`ls`	`-1` (una columna)
`find`	`-maxdepth N`
`grep`	`--max-count=N`
`head`	`-n N`
`tail`	`-n N`

Estrategia 5: Sesiones enfocadas

Una sesión = Un tema principal.

❌ Sesión dispersa

[Misma sesión]
> Implementa autenticación
[30 mensajes]
> Ahora crea el dashboard
[30 mensajes]
> Ahora optimiza la base de datos
[30 mensajes]
> Ahora documenta la API
[30 mensajes]
 
Total: 120 mensajes, contexto lleno al 95%

✅ Sesiones enfocadas

[Sesión 1: Autenticación]
> Implementa autenticación completa
[30 mensajes]
✅ Completado
 
[Sesión 2: Dashboard]
> Crea el dashboard
[30 mensajes]
✅ Completado
 
[Sesión 3: Base de datos]
> Optimiza la base de datos
[30 mensajes]
✅ Completado
 
[Sesión 4: Documentación]
> Documenta la API
[30 mensajes]
✅ Completado

Beneficios:

Contexto limpio para cada tema
Mejor coherencia
Más fácil retomar después

Estrategia 6: Skills personalizadas para tareas repetitivas

Las skills reducen la necesidad de repetir instrucciones largas.

Sin skill (ineficiente)

[Cada vez que haces commit - 100 tokens]
> Analiza los cambios staged, genera un mensaje de commit
  siguiendo Conventional Commits, asegúrate de que sea
  descriptivo, incluye el Co-Authored-By, y haz el commit.

Si haces 10 commits por sesión: 1,000 tokens

Con skill (eficiente)

<!-- .claude/skills/commit/SKILL.md - 200 tokens (una vez) -->
---
name: commit
description: Genera commit siguiendo Conventional Commits
---
 
Analiza cambios staged, genera mensaje descriptivo
siguiendo Conventional Commits y haz el commit con Co-Authored-By.

Uso:

> /commit

Tokens por uso: ~5 tokens

10 commits: 50 tokens vs. 1,000 tokens

Estrategia 7: Documentar decisiones importantes

En lugar de mantener decisiones en la conversación, guárdalas en archivos.

Ejemplo

❌ Mantener en conversación:

Usuario: ¿Por qué usamos bcrypt en lugar de argon2?
 
[20 mensajes después]
 
Claude: Elegimos bcrypt porque...
  [Larga explicación - 500 tokens en contexto]
 
[40 mensajes después - puede ser resumido o perdido]

✅ Documentar en archivo:

> Documenta en docs/decisiones.md por qué elegimos bcrypt

Claude crea:

# Decisiones técnicas
 
## Hash de passwords: bcrypt vs argon2
 
**Decisión:** Usar bcrypt
 
**Razones:**
- Ampliamente adoptado y probado
- Excelente soporte en Node.js
- Configuración de cost factor flexible
- argon2 es más nuevo, menos maduro en el ecosistema

Beneficio:

Sale del contexto de conversación
Queda documentado permanentemente
Puedes consultarlo en futuras sesiones

Estrategia 8: Usar /context para monitorear

Monitorea el uso de contexto regularmente.

Frecuencia recomendada

Cada 20-30 mensajes en sesiones largas:
 
> /context

Interpretar resultados

📊 Context Usage: 45,000 / 200,000 (22.5%)

Acción: Ninguna, sigue trabajando.

📊 Context Usage: 140,000 / 200,000 (70%)

Acción: Considera /compact si vas a continuar mucho más.

📊 Context Usage: 180,000 / 200,000 (90%)

Acción: /compact inmediatamente o nueva sesión.

Estrategia 9: Cerrar archivos mentalmente

Aunque Claude Code no tiene un comando explícito para "cerrar" archivos del contexto, puedes indicarlo:

> Ya no necesito src/auth/register.ts en contexto.
  Enfócate solo en login.ts y jwt.ts

Esto da una señal clara de qué archivos priorizar.

Estrategia 10: Compactación proactiva

No esperes a que el contexto esté lleno.

Puntos estratégicos para /compact

1. Entre fases del desarrollo

[Implementación completa ✅]
> /compact
 
[Testing ✅]
> /compact
 
[Refactoring]

2. Después de debugging

[Bug resuelto después de 40 mensajes de debugging]
> /compact
 
[Continúa con desarrollo normal]

3. Antes de tareas complejas

[Contexto al 65%]
> Voy a implementar algo complejo. Compactemos primero.
> /compact
 
[Ahora con contexto fresco]
> Implementa [tarea compleja]

Receta completa: Sesión optimizada

Veamos una sesión completa aplicando todas las estrategias:

Preparación

# 1. CLAUDE.md configurado (una vez)
cat > .claude/CLAUDE.md << EOF
## Stack
- Node.js + TypeScript
- PostgreSQL + Prisma
- Testing: Vitest
 
## Convenciones
- Interfaces: Prefijo I
- Funciones: async/await
- No usar console.log
EOF

Inicio de sesión

> /context
📊 15,000 / 200,000 (7.5%) - CLAUDE.md cargado
 
> Implementa función login que valide email y password
  contra la base de datos

Claude lee solo archivos necesarios:

src/auth/login.ts
src/models/User.ts

Tokens: ~18,000 total

Desarrollo

[Claude implementa]
 
> Ahora escribe tests para login
 
[Claude lee]
- tests/auth/login.test.ts
 
> /context
📊 45,000 / 200,000 (22.5%)

Continuar

[30 mensajes más implementando y testeando]
 
> /context
📊 95,000 / 200,000 (47.5%)
 
> Login completo. Ahora implementa register con TDD

Mid-session

[40 mensajes implementando register]
 
> /context
📊 155,000 / 200,000 (77.5%)
 
> Register completo. Compactemos antes de continuar.
 
> /compact
 
📊 55,000 / 200,000 (27.5%) - Recuperado 100K tokens
 
> Perfecto. Ahora password reset

Finalización

[Completa password reset]
 
> /context
📊 110,000 / 200,000 (55%)
 
> Autenticación completa ✅
 
[Sesión exitosa sin llenar contexto]

Resultado:

Implementaste 3 features completas
Nunca llenaste el contexto
Usaste solo 1 compactación
Sesión coherente de inicio a fin

Anti-patterns comunes

❌ Anti-pattern 1: "Lee todo para entender el proyecto"

> Lee todos los archivos del proyecto para entender
  la arquitectura
 
[Lee 50 archivos]
[Contexto: 80,000 tokens de golpe]

✅ Mejor:

> Explica la estructura del proyecto basándote en CLAUDE.md
  y la estructura de carpetas
 
[Claude usa Glob para ver estructura sin leer archivos]

❌ Anti-pattern 2: Repetir instrucciones en cada mensaje

[Cada mensaje]
> Recuerda usar TypeScript estricto, interfaces con I,
  y async/await...
  [Luego la instrucción real]

✅ Mejor:

Pon las convenciones en CLAUDE.md una sola vez.

❌ Anti-pattern 3: Debugging sin compactar

[Debugging por 60 mensajes - contexto al 90%]
[Bug resuelto]
[Sigue trabajando en el mismo contexto lleno]

✅ Mejor:

[Bug resuelto]
> /compact
[Contexto limpio para continuar]

❌ Anti-pattern 4: Sesiones interminables

[Una sesión de 8 horas con 200 mensajes]
[Contexto compactado 4 veces]
[Claude cada vez más incoherente]

✅ Mejor:

[Sesión 1: 2 horas - Feature A]
[Break]
[Sesión 2: 2 horas - Feature B]
[Break]
[Sesión 3: 2 horas - Feature C]

Métricas de sesión optimizada

🏆 Sesión excelente

✅ Duración: 1-3 horas
✅ Mensajes: 30-60
✅ Contexto máximo: 60-70%
✅ Compactaciones: 0-1
✅ Archivos leídos: 5-15
✅ Tema: Enfocado en 1-2 features relacionadas

🟡 Sesión aceptable

🟡 Duración: 3-5 horas
🟡 Mensajes: 60-100
🟡 Contexto máximo: 75-85%
🟡 Compactaciones: 1-2
🟡 Archivos leídos: 15-25
🟡 Tema: 2-3 features relacionadas

🔴 Sesión problemática

🔴 Duración: >6 horas
🔴 Mensajes: >150
🔴 Contexto máximo: >90%
🔴 Compactaciones: >3
🔴 Archivos leídos: >30
🔴 Tema: Múltiples features no relacionadas

Checklist de optimización

Antes de cada sesión:

CLAUDE.md actualizado con info del proyecto
Tema claro y enfocado para la sesión
Skills relevantes configuradas

Durante la sesión:

Leer solo archivos necesarios
Mensajes concisos pero claros
Verificar /context cada 20-30 mensajes
Compactar proactivamente si es necesario

Al terminar:

Documentar decisiones importantes en archivos
Si quedó algo pendiente, anotar para próxima sesión
Considerar si necesitas nueva sesión para el siguiente tema

Resumen

Estrategias principales:

CLAUDE.md efectivo → Carga información una sola vez
Lectura incremental → Solo archivos necesarios
Mensajes concisos → Cada palabra cuenta
Evitar comandos masivos → Limita output de bash
Sesiones enfocadas → Un tema por sesión
Skills para repetitivos → Reduce tokens de instrucciones
Documentar decisiones → Saca info de conversación
Monitorear con /context → Previene problemas
Cerrar archivos mentalmente → Prioriza lo relevante
Compactación proactiva → No esperes al 90%

Objetivo:

Sesiones largas y productivas
Contexto siempre disponible
Respuestas coherentes y rápidas
Mínimo desperdicio de tokens

En el siguiente punto (9.5) aprenderás a monitorear tokens de forma más detallada y usar herramientas para optimizar aún más.

9.5 Monitoreo de tokens

Saber exactamente cuánto contexto estás usando y qué lo consume te permite tomar decisiones informadas para optimizar tus sesiones. En este punto aprenderás a monitorear tokens efectivamente.

Comando /context

El comando principal para monitorear el uso de contexto.

Uso básico

> /context

Output típico

📊 Context Usage:
├─ Tokens used: 85,430 / 200,000 (42.7%)
├─ Files loaded: 12
│  ├─ src/auth/login.ts (1,250 tokens)
│  ├─ src/auth/jwt.ts (890 tokens)
│  ├─ src/middleware/auth.ts (670 tokens)
│  ├─ src/models/User.ts (450 tokens)
│  ├─ tests/auth/login.test.ts (2,100 tokens)
│  └─ ... (7 more files)
├─ Skills loaded: 3
│  ├─ /commit (150 tokens)
│  ├─ /review (280 tokens)
│  └─ /test (200 tokens)
├─ CLAUDE.md: 850 tokens
│  ├─ Global (~/.claude/CLAUDE.md): 300 tokens
│  └─ Project (.claude/CLAUDE.md): 550 tokens
├─ Conversation: 78,940 tokens
│  ├─ Your messages: 12,000 tokens
│  ├─ Assistant messages: 45,000 tokens
│  └─ Tool results: 21,940 tokens
└─ Context remaining: 114,570 tokens (57.3%)
 
💡 Tip: You're using context efficiently!

Desglose del output

1. Tokens used

Tokens used: 85,430 / 200,000 (42.7%)

Qué significa:

Has usado 85,430 tokens de los 200,000 disponibles
Estás al 42.7% de capacidad
Te quedan 114,570 tokens libres

Escala de interpretación:

Porcentaje	Estado	Acción
0-50%	🟢 Excelente	Continúa normal
50-70%	🟢 Bien	Monitorea ocasionalmente
70-85%	🟡 Moderado	Considera `/compact` si continúas mucho
85-95%	🟠 Alto	Usa `/compact` o nueva sesión pronto
95-100%	🔴 Crítico	`/compact` inmediatamente o nueva sesión

2. Files loaded

Files loaded: 12
├─ src/auth/login.ts (1,250 tokens)
├─ src/auth/jwt.ts (890 tokens)
...

Qué muestra:

Número total de archivos en contexto
Qué archivos específicamente
Cuántos tokens consume cada uno

Análisis:

✅ Bien: 5-15 archivos relacionados con la tarea
🟡 Moderado: 15-25 archivos
🔴 Problema: >30 archivos (probablemente hay archivos innecesarios)

Pregunta clave: ¿Todos estos archivos son necesarios para mi tarea actual?

3. Skills loaded

Skills loaded: 3
├─ /commit (150 tokens)
├─ /review (280 tokens)
└─ /test (200 tokens)

Qué muestra:

Skills activas en la sesión
Tokens que consume cada skill

Nota: Las skills consumen relativamente pocos tokens (100-500 cada una), así que no son un problema típico.

4. CLAUDE.md

CLAUDE.md: 850 tokens
├─ Global (~/.claude/CLAUDE.md): 300 tokens
└─ Project (.claude/CLAUDE.md): 550 tokens

Qué muestra:

Cuánto consume tu CLAUDE.md global
Cuánto consume el CLAUDE.md del proyecto
Total combinado

Optimización:

✅ Óptimo: 500-2,000 tokens total
🟡 Aceptable: 2,000-5,000 tokens
🔴 Excesivo: >5,000 tokens (considera reducir)

Si tu CLAUDE.md consume >5,000 tokens, probablemente tiene demasiado detalle.

5. Conversation

Conversation: 78,940 tokens
├─ Your messages: 12,000 tokens
├─ Assistant messages: 45,000 tokens
└─ Tool results: 21,940 tokens

Desglose:

Your messages: Todos tus mensajes en la sesión
Assistant messages: Todas las respuestas de Claude
Tool results: Output de Read, Bash, Grep, etc.

Análisis:

Si Tool results es muy alto (>50% de Conversation), probablemente:

Estás ejecutando comandos con mucho output
Has leído muchos archivos
Hay logs/resultados largos

6. Context remaining

Context remaining: 114,570 tokens (57.3%)

Qué significa:

Espacio libre disponible
Puedes tener ~57 mensajes más de tamaño promedio
O leer ~25 archivos más medianos

Interpretar los datos

Caso 1: Sesión balanceada

📊 Context Usage: 65,000 / 200,000 (32.5%)
├─ Files loaded: 8
├─ Skills loaded: 2
├─ CLAUDE.md: 1,200 tokens
└─ Conversation: 60,000 tokens
    ├─ Your messages: 10,000 tokens
    ├─ Assistant messages: 35,000 tokens
    └─ Tool results: 15,000 tokens

Análisis:

✅ Contexto saludable (32.5%)
✅ Número razonable de archivos (8)
✅ CLAUDE.md conciso (1,200 tokens)
✅ Balance entre mensajes y resultados de tools

Acción: Ninguna, sigue trabajando.

Caso 2: Demasiados archivos

📊 Context Usage: 125,000 / 200,000 (62.5%)
├─ Files loaded: 35  ⚠️
├─ Skills loaded: 3
├─ CLAUDE.md: 1,000 tokens
└─ Conversation: 75,000 tokens

Análisis:

🟡 Contexto moderado pero subiendo rápido
🔴 Demasiados archivos (35)
✅ Skills y CLAUDE.md bien

Problema: Probablemente leíste archivos que no necesitas.

Acción:

> No necesito más referencias a los archivos de tests.
  Enfócate solo en src/auth/login.ts y jwt.ts

O considera /compact.

Caso 3: Tool results altos

📊 Context Usage: 145,000 / 200,000 (72.5%)
├─ Files loaded: 10
├─ Skills loaded: 2
├─ CLAUDE.md: 800 tokens
└─ Conversation: 140,000 tokens
    ├─ Your messages: 15,000 tokens
    ├─ Assistant messages: 50,000 tokens
    └─ Tool results: 75,000 tokens  ⚠️

Análisis:

🟡 Contexto al 72.5%
🔴 Tool results muy altos (53% de conversación)

Problema: Probablemente ejecutaste comandos con mucho output.

Ejemplos:

git log --all sin límite
npm test con output verbose
Leer archivos muy grandes

Acción: Usa flags de limitación en comandos futuros.

Caso 4: CLAUDE.md excesivo

📊 Context Usage: 98,000 / 200,000 (49%)
├─ Files loaded: 12
├─ Skills loaded: 4
├─ CLAUDE.md: 12,000 tokens  ⚠️
└─ Conversation: 80,000 tokens

Análisis:

🟡 Contexto casi al 50%
🔴 CLAUDE.md consume 12,000 tokens (excesivo)

Problema: CLAUDE.md tiene demasiado detalle.

Solución: Optimiza CLAUDE.md:

Elimina información redundante
Sé más conciso
Mueve detalles muy específicos a documentación separada

Frecuencia de monitoreo

Sesión corta (< 30 mensajes)

Verificar: Una vez al inicio, una al final

No es necesario monitorear constantemente.

Sesión media (30-60 mensajes)

Verificar:
- Al inicio
- Mitad de sesión (~mensaje 30)
- Al final

Sesión larga (> 60 mensajes)

Verificar:
- Al inicio
- Cada 20-30 mensajes
- Antes de tareas complejas
- Al final

Debugging intensivo

Verificar:
- Antes de empezar
- Después de cada intento de fix
- Al resolver el bug

Debugging acumula contexto rápidamente (logs, traces, intentos fallidos).

Comandos complementarios

Además de /context, hay otros comandos útiles para monitoreo.

/stats

Muestra estadísticas de la sesión actual:

> /stats
 
📈 Session Statistics:
├─ Messages exchanged: 45
├─ Tools used: 68
│  ├─ Read: 12
│  ├─ Write: 8
│  ├─ Edit: 15
│  ├─ Bash: 20
│  ├─ Grep: 10
│  └─ Glob: 3
├─ Session duration: 1h 23m
└─ Last compaction: Never

Útil para:

Ver cuántas herramientas has usado
Entender qué consume más contexto
Decidir si necesitas /compact

/cost (si usas API)

Si usas Claude Code con tu propia API key:

> /cost
 
💰 Session Cost:
├─ Input tokens: 85,000
├─ Output tokens: 62,000
├─ Total cost: $2.35
└─ Average cost per message: $0.052

Útil para:

Controlar gastos
Optimizar uso de tokens = optimizar costos

Herramientas externas

Anthropic Console Tokenizer

URL: https://console.anthropic.com/tokenizer

Uso:

Copia texto o código
Pégalo en el tokenizer
Ve cuántos tokens consume

Ejemplo:

function validateEmail(email: string): boolean {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return regex.test(email);
}

Resultado: 47 tokens

Útil para:

Estimar cuánto consumirá un archivo antes de leerlo
Optimizar mensajes largos
Diseñar CLAUDE.md eficiente

Script para contar tokens de CLAUDE.md

Puedes crear un script local:

#!/bin/bash
# count-tokens.sh
 
# Aproximación: 4 caracteres = 1 token en inglés/código
# 3.5 caracteres = 1 token en español
 
chars=$(wc -m < .claude/CLAUDE.md)
tokens=$((chars / 4))
 
echo "📝 CLAUDE.md stats:"
echo "├─ Characters: $chars"
echo "└─ Estimated tokens: ~$tokens"

Uso:

chmod +x count-tokens.sh
./count-tokens.sh
 
📝 CLAUDE.md stats:
├─ Characters: 3,200
└─ Estimated tokens: ~800

Patrones de consumo

Pattern 1: Crecimiento lineal (saludable)

Mensaje 10:  15,000 tokens (7.5%)
Mensaje 20:  28,000 tokens (14%)
Mensaje 30:  42,000 tokens (21%)
Mensaje 40:  55,000 tokens (27.5%)
Mensaje 50:  68,000 tokens (34%)

Análisis:

Crecimiento constante y predecible
~1,300 tokens por mensaje en promedio
Puedes continuar sin problemas

Pattern 2: Pico súbito (alerta)

Mensaje 10:  15,000 tokens (7.5%)
Mensaje 20:  28,000 tokens (14%)
Mensaje 25:  85,000 tokens (42.5%)  ⚠️ +57K de golpe
Mensaje 30:  92,000 tokens (46%)

Análisis:

Algo consumió 57,000 tokens entre mensaje 20-25
Probablemente:
- Leíste muchos archivos
- Comando con output masivo
- Copiaste código largo en un mensaje

Acción: Identifica qué causó el pico y evítalo en el futuro.

Pattern 3: Crecimiento acelerado (problema)

Mensaje 10:  15,000 tokens (7.5%)
Mensaje 20:  35,000 tokens (17.5%)   +20K
Mensaje 30:  65,000 tokens (32.5%)   +30K
Mensaje 40: 110,000 tokens (55%)     +45K
Mensaje 50: 170,000 tokens (85%)     +60K

Análisis:

Cada bloque de 10 mensajes consume más que el anterior
Aceleración peligrosa
Llegarás al límite pronto

Causas comunes:

Leer más archivos con cada mensaje
Debugging que acumula logs
Mensajes cada vez más largos

Acción: /compact en mensaje 40 para resetear.

Dashboard mental de monitoreo

Desarrolla un "dashboard mental" para evaluar rápidamente:

Quick check (sin /context)

Pregúntate:

¿Cuántos mensajes llevo?
- < 20: Probablemente < 30% contexto
- 20-50: Probablemente 30-60% contexto
- 50-80: Probablemente 60-85% contexto
- 80: Probablemente > 85% contexto
¿Cuántos archivos he leído?
- < 10: Bajo impacto
- 10-20: Impacto moderado
- 20: Alto impacto
¿He ejecutado comandos con output largo?
- Sí → Impacto alto
- No → Impacto bajo
¿Claude está más lento?
- Sí → Probablemente > 70% contexto
- No → Probablemente < 70% contexto

Regla del pulgar

Tokens aproximados ≈ (mensajes × 1,500) + (archivos × 800) + output_commands

Ejemplo:

40 mensajes × 1,500 = 60,000
15 archivos × 800 = 12,000
Output commands = ~8,000
Total ≈ 80,000 tokens (40%)

No es exacto, pero da una idea rápida.

Optimización basada en datos

Análisis post-sesión

Después de una sesión, revisa:

> /context
 
[Analiza el desglose]

Preguntas:

¿Qué consumió más tokens?
- Si fueron archivos: Lee menos archivos en próximas sesiones
- Si fueron tool results: Limita output de comandos
- Si fueron mensajes: Sé más conciso
¿Llegué al límite?
- Sí → Usa /compact más temprano o sesiones más cortas
- No → Estrategia actual funciona
¿Cuántas veces compacté?
- 0-1: Bien
- 2-3: Considera sesiones más cortas
- 3: Definitivamente necesitas sesiones más cortas

Iteración

Con cada sesión, ajusta:

Sesión 1:
├─ 80 mensajes
├─ Contexto: 92%
├─ Compactaciones: 2
└─ Lección: Sesión muy larga
 
Sesión 2 (ajuste):
├─ 50 mensajes
├─ Contexto: 68%
├─ Compactaciones: 1
└─ Lección: Mejor, pero puedo optimizar archivos leídos
 
Sesión 3 (ajuste):
├─ 50 mensajes
├─ 10 archivos (vs 20 en sesión 2)
├─ Contexto: 52%
├─ Compactaciones: 0
└─ Resultado: ✅ Óptimo

Alertas automáticas

Aunque Claude Code no tiene alertas automáticas configurables, puedes crear hábitos:

Trigger mental

CADA 20 MENSAJES → /context

Ejemplo:

[Mensaje 20] > /context
[Mensaje 40] > /context
[Mensaje 60] > /context

Antes de tareas grandes

ANTES de implementar algo complejo → /context

Ejemplo:

> Voy a implementar autenticación completa.
  Primero déjame ver el contexto.
> /context
[Verificas que tienes espacio suficiente]
> Ok, implementemos autenticación...

Comparación entre sesiones

Sesión eficiente

📊 Final de sesión:
├─ Mensajes: 45
├─ Tokens: 72,000 / 200,000 (36%)
├─ Archivos: 10
├─ Compactaciones: 0
└─ Resultado: Feature completa + tests ✅

Ratio eficiencia: 1,600 tokens/mensaje

Sesión ineficiente

📊 Final de sesión:
├─ Mensajes: 45
├─ Tokens: 168,000 / 200,000 (84%)
├─ Archivos: 35
├─ Compactaciones: 2
└─ Resultado: Feature incompleta ❌

Ratio eficiencia: 3,733 tokens/mensaje

Problema: Consumiste 2.3× más tokens para el mismo número de mensajes.

Resumen

Comando principal:

> /context

Monitorear:

✅ Tokens used (% del total)
✅ Files loaded (cantidad y cuáles)
✅ CLAUDE.md size
✅ Conversation breakdown

Frecuencia:

Sesión corta: Inicio + final
Sesión media: Cada 30 mensajes
Sesión larga: Cada 20 mensajes
Debugging: Frecuente

Acciones según %:

< 50%: 🟢 Continúa normal
50-70%: 🟢 Monitorea ocasionalmente
70-85%: 🟡 Considera /compact
85-95%: 🟠 Usa /compact o nueva sesión
95%: 🔴 Nueva sesión recomendada

Optimización:

Analiza qué consume más tokens
Ajusta estrategia en próximas sesiones
Itera hasta encontrar tu patrón óptimo

En el siguiente punto (9.6) aprenderás cuándo iniciar una nueva sesión en lugar de continuar compactando la actual.

9.6 Cuándo iniciar nueva sesión

Saber cuándo terminar una sesión e iniciar una nueva es tan importante como saber usar /compact. En este punto aprenderás a reconocer los momentos ideales para empezar de cero.

¿Por qué iniciar nueva sesión?

Ventajas de sesión nueva

1. Contexto completamente limpio

Nueva sesión:
├─ 0 mensajes antiguos
├─ 0 archivos previos
├─ 0 tool results acumulados
└─ 200,000 tokens disponibles (100%)

vs.

Después de /compact:
├─ Resumen de mensajes antiguos
├─ Algunos archivos pueden quedar
├─ Tool results resumidos
└─ ~120,000-140,000 tokens disponibles (60-70%)

2. Mejor coherencia

Claude empieza "fresco" sin influencia de:

Decisiones previas de otra feature
Código de otro módulo
Debugging de otro bug

3. Prevenir degradación

Múltiples compactaciones en la misma sesión pueden degradar la coherencia.

Sesión con 3+ compactaciones:
├─ Resumen del resumen del resumen
├─ Pérdida de hilo original
└─ Respuestas menos precisas

4. Organización mental

Sesiones separadas = Temas separados

Más fácil de:

Retomar después
Exportar/documentar
Compartir con equipo

Cuándo iniciar nueva sesión

✅ Situación 1: Cambio completo de tema

Señal clara: La nueva tarea no tiene relación con la anterior.

Ejemplo claro

[Sesión 1]
✅ Implementada autenticación JWT completa
   - Login, register, password reset
   - Middleware, tests
   - Documentación
 
[NUEVA SESIÓN]
> Ahora voy a implementar el sistema de notificaciones por email

Razón: Autenticación y notificaciones son módulos completamente diferentes.

Contra-ejemplo (NO nueva sesión)

[Misma sesión]
✅ Implementado login con JWT
 
[CONTINUAR]
> Ahora implementa register también con JWT

Razón: Register está relacionado con login, mismo módulo.

✅ Situación 2: Contexto > 90%

Señal clara: /context muestra > 90% usado.

> /context
 
📊 Context Usage: 183,000 / 200,000 (91.5%)
 
⚠️ Warning: Context near limit!

Acción:

[Opción 1: Compactar]
> /compact
 
[Si después de compactar sigue > 70%]
📊 Context Usage: 145,000 / 200,000 (72.5%)
 
[Entonces mejor nueva sesión]

Opción 2: Directamente nueva sesión (recomendado si estás al >95%)

✅ Situación 3: Tarea completada

Señal clara: Terminaste lo que te propusiste en la sesión.

Feature completa

[Sesión]
Objetivo: Implementar autenticación
 
✅ Login implementado
✅ Register implementado
✅ Password reset implementado
✅ Tests completos
✅ Documentación actualizada
 
[TAREA COMPLETA → NUEVA SESIÓN]

Bug resuelto

[Sesión]
Objetivo: Resolver bug de tokens que expiran
 
✅ Bug identificado
✅ Fix implementado
✅ Tests verificados
✅ Desplegado
 
[BUG RESUELTO → NUEVA SESIÓN]

✅ Situación 4: Múltiples compactaciones

Señal clara: Ya compactaste 2-3 veces en la misma sesión.

[Sesión actual]
├─ Primera compactación (mensaje 60)
├─ Segunda compactación (mensaje 100)
├─ Tercera compactación (mensaje 140)
└─ Ahora en mensaje 160
 
[3+ COMPACTACIONES → NUEVA SESIÓN]

Razón: La coherencia se degrada con cada compactación.

✅ Situación 5: Nueva jornada de trabajo

Señal clara: Empiezas a trabajar otro día o después de un break largo.

[Viernes 5 PM]
Sesión 1: Trabajo del día ✅
 
[Lunes 9 AM]
Nueva sesión: Nuevo día de trabajo

Razón:

Contexto fresco para empezar el día
Posiblemente nueva tarea o perspectiva diferente

✅ Situación 6: Cambio de fase del proyecto

Señal clara: Pasas de una fase a otra.

Ejemplo

[Sesión 1: Implementación]
Implementar features completas
 
[NUEVA SESIÓN]
[Sesión 2: Testing]
Escribir tests exhaustivos
 
[NUEVA SESIÓN]
[Sesión 3: Refactoring]
Refactorizar para mejor mantenibilidad
 
[NUEVA SESIÓN]
[Sesión 4: Documentación]
Documentar todo el módulo

✅ Situación 7: Pérdida de coherencia

Señales:

Claude "olvida" información importante
Pregunta cosas ya respondidas
Respuestas genéricas en lugar de específicas
Código no sigue convenciones establecidas

> Claude, ¿recuerdas qué ORM estamos usando?
 
Claude: No tengo esa información. ¿Qué ORM estás usando?
 
[YA DISCUTIDO 50 MENSAJES ATRÁS]
 
[PÉRDIDA DE COHERENCIA → NUEVA SESIÓN]

✅ Situación 8: Depuración completada

Señal clara: Resolviste un bug después de una sesión larga de debugging.

[Sesión de debugging - 80 mensajes]
├─ Analizado logs
├─ Leído 20 archivos
├─ Probado 5 teorías
├─ Encontrado root cause
└─ Bug resuelto ✅
 
[DEBUGGING COMPLETO → NUEVA SESIÓN]

Razón: Debugging acumula mucho "ruido" en el contexto (logs, intentos fallidos, etc.)

Cuándo NO iniciar nueva sesión

❌ Situación 1: Contexto < 70%

> /context
📊 Context Usage: 95,000 / 200,000 (47.5%)
 
[NO nueva sesión, sigue trabajando]

Razón: Tienes mucho espacio disponible.

❌ Situación 2: En medio de algo

[Implementando login]
✅ Función de validación completa
🟡 Función de autenticación a medias
❌ Tests no escritos
 
[NO nueva sesión, termina primero]

Razón: Perderías el hilo de lo que estabas haciendo.

❌ Situación 3: Tareas relacionadas

[Sesión actual]
✅ Implementado validateEmail()
 
[Siguiente tarea]
> Ahora implementa validatePassword()
 
[NO nueva sesión, están relacionadas]

Razón: Ambas son validadores, comparten contexto útil.

❌ Situación 4: Después de un solo /compact

[Sesión]
> /compact
📊 Context: 45,000 / 200,000 (22.5%)
 
[NO nueva sesión, tienes mucho espacio]

Razón: Un /compact te dio espacio suficiente para continuar.

Decisión: /compact vs. Nueva sesión

Árbol de decisión

¿Necesitas más espacio de contexto?
│
├─ NO → Continúa normal
│
└─ SÍ → ¿Estás en medio de algo?
    │
    ├─ SÍ → ¿Contexto < 90%?
    │   │
    │   ├─ SÍ → Usa /compact
    │   │
    │   └─ NO → Nueva sesión
    │
    └─ NO (tarea completa) → ¿El siguiente tema está relacionado?
        │
        ├─ SÍ → Usa /compact
        │
        └─ NO → Nueva sesión

Ejemplos aplicando el árbol

Ejemplo 1

Contexto: 75%
En medio: Sí (implementando login)
Siguiente: Implementar register (relacionado)
 
DECISIÓN: /compact

Ejemplo 2

Contexto: 92%
En medio: No (autenticación completa)
Siguiente: Sistema de notificaciones (no relacionado)
 
DECISIÓN: Nueva sesión

Ejemplo 3

Contexto: 45%
En medio: No
Siguiente: Tests de autenticación (relacionado)
 
DECISIÓN: Continuar normal (no se necesita ninguna acción)

Ejemplo 4

Contexto: 88%
En medio: Sí (debugging un bug complejo)
Siguiente: Seguir con el mismo bug
 
DECISIÓN: /compact (para tener espacio pero no perder contexto del bug)

Cómo iniciar nueva sesión

Opción 1: Cerrar terminal y abrir nuevo

# Sesión actual
> exit
 
# Nueva terminal
claude

Ventaja: Completamente nuevo, sin conexión con sesión anterior.

Opción 2: Comando /clear (si disponible)

> /clear

Nota: Verifica si tu versión de Claude Code tiene este comando.

Opción 3: Nueva ventana/tab

# Terminal 1 (sesión antigua, puedes dejarla abierta)
claude
 
# Terminal 2 (nueva sesión)
claude

Ventaja: Puedes tener ambas sesiones abiertas para referencia.

Transición entre sesiones

Práctica recomendada

Antes de cerrar la sesión actual, documenta:

1. Estado actual

> Antes de cerrar, documenta en STATUS.md:
  - Qué completamos en esta sesión
  - Qué queda pendiente
  - Cualquier decisión importante tomada

2. Next steps

> Crea TODO.md con los próximos pasos para la siguiente sesión

3. Exportar conversación (opcional)

Si la conversación tiene valor:

> /export
 
[Guarda la conversación para referencia futura]

Iniciar nueva sesión con contexto

# Nueva sesión
claude
 
> Lee STATUS.md y TODO.md para entender dónde quedamos
 
[Claude lee los archivos]
 
> Perfecto, continuemos con el primer item del TODO

Ventaja:

Contexto limpio (200K tokens)
Pero con conocimiento de lo que se hizo antes
Sin consumir tokens de la conversación anterior

Patrones de sesiones

Pattern 1: Sesiones por feature

Sesión 1: Login
Sesión 2: Register
Sesión 3: Password reset
Sesión 4: OAuth integration

Ventaja: Una feature = una conversación clara.

Pattern 2: Sesiones por día

Lunes AM: Sesión 1
Lunes PM: Sesión 2
Martes AM: Sesión 3
Martes PM: Sesión 4

Ventaja: Empezar cada jornada fresco.

Pattern 3: Sesiones por fase

Sesión 1: Planning (diseño de arquitectura)
Sesión 2: Implementation
Sesión 3: Testing
Sesión 4: Refactoring
Sesión 5: Documentation

Ventaja: Separación clara de fases.

Pattern 4: Sesiones híbridas

Sesión larga (3-4 horas):
├─ Implementación completa de auth
├─ 1-2 compactaciones durante la sesión
└─ Sin cambiar de tema
 
Break largo
 
Nueva sesión (2 horas):
├─ Tema diferente: Notificaciones
└─ Contexto fresco

Casos prácticos

Caso 1: Desarrollo de feature larga

Escenario: Implementar sistema de autenticación completo (login, register, OAuth, 2FA)

Estrategia: Múltiples sesiones

[Sesión 1 - 2 horas]
- Login + Register
- Contexto final: 65%
 
[Nueva sesión - 2 horas]
- Password reset + Email verification
- Contexto final: 60%
 
[Nueva sesión - 2 horas]
- OAuth integration
- Contexto final: 70%
 
[Nueva sesión - 1 hora]
- 2FA
- Contexto final: 45%

Resultado: 4 sesiones limpias vs. 1 sesión caótica con 4+ compactaciones.

Caso 2: Debugging maratón

Escenario: Bug muy complejo que requiere 4+ horas de investigación

Estrategia 1: Sesión continua con compactaciones

[Sesión única - 4 horas]
├─ Hora 1: Análisis inicial (30% contexto)
├─ Hora 2: Múltiples teorías (70% contexto)
├─ /compact → (45% contexto)
├─ Hora 3: Más investigación (80% contexto)
├─ /compact → (50% contexto)
└─ Hora 4: Encontrado y resuelto ✅

Ventaja: Mantienes todo el contexto del debugging.

Estrategia 2: Break + nueva sesión

[Sesión 1 - 2 horas]
├─ Análisis e investigación
└─ Documentar teorías en DEBUG.md
 
[Break 30 min]
 
[Sesión 2 - 2 horas]
├─ Lee DEBUG.md para contexto
├─ Continúa investigación con mente fresca
└─ Resuelve el bug ✅

Ventaja: Break te da perspectiva nueva.

Recomendación: Estrategia 1 si estás "en la zona", Estrategia 2 si te sientes atascado.

Caso 3: Refactor grande

Escenario: Refactorizar todo el módulo de autenticación

Estrategia recomendada: Sesiones por archivo/componente

[Sesión 1]
- Refactor de login.ts
- Tests actualizados
✅ Completo
 
[Sesión 2]
- Refactor de register.ts
- Tests actualizados
✅ Completo
 
[Sesión 3]
- Refactor de jwt.ts
- Tests actualizados
✅ Completo

Ventaja: Progreso incremental claro, fácil de retomar.

Métricas de sesiones saludables

Sesión ideal

✅ Duración: 1-3 horas
✅ Mensajes: 30-80
✅ Contexto máximo: 50-70%
✅ Compactaciones: 0-1
✅ Tema: Único y enfocado
✅ Resultado: Tarea completa

Sesión aceptable

🟡 Duración: 3-5 horas
🟡 Mensajes: 80-120
🟡 Contexto máximo: 70-85%
🟡 Compactaciones: 1-2
🟡 Tema: 2 temas relacionados
🟡 Resultado: Mayoría de tarea completa

Sesión problemática (considerar dividir)

🔴 Duración: >5 horas
🔴 Mensajes: >150
🔴 Contexto máximo: >90%
🔴 Compactaciones: >2
🔴 Tema: Múltiples temas no relacionados
🔴 Resultado: Tareas incompletas o confusión

Checklist de decisión

Usa este checklist antes de decidir:

¿Nueva sesión?

¿El contexto está > 85%?
¿Completé la tarea que me propuse?
¿El siguiente tema es diferente al actual?
¿Ya compacté 2+ veces?
¿Noté pérdida de coherencia en Claude?
¿Es un nuevo día / después de break largo?

Si respondiste SÍ a 3 o más → Nueva sesión

¿Continuar con /compact?

¿Estoy en medio de algo?
¿El siguiente paso está relacionado?
¿Contexto entre 70-90%?
¿Es mi primera compactación?
¿No he notado pérdida de coherencia?

Si respondiste SÍ a 3 o más → /compact y continuar

¿Continuar sin acción?

¿Contexto < 70%?
¿Todo funciona bien?
¿Claude sigue siendo coherente?

Si respondiste SÍ a las 3 → Continuar normal

Resumen

Inicia nueva sesión cuando:

✅ Cambio completo de tema ✅ Contexto > 90% ✅ Tarea completada (y siguiente es diferente) ✅ 2-3+ compactaciones ya realizadas ✅ Nueva jornada de trabajo ✅ Cambio de fase del proyecto ✅ Pérdida de coherencia notable ✅ Debugging completado

NO inicies nueva sesión cuando:

❌ Contexto < 70% ❌ Estás en medio de algo ❌ Tarea siguiente está relacionada ❌ Después de solo 1 compactación

Regla de oro:

"Mejor una nueva sesión limpia que forzar una sesión degradada"

Transición inteligente:

Documenta estado actual
Crea TODO para próxima sesión
Exporta conversación si tiene valor
Nueva sesión lee documentación
Continúa desde donde quedaste

Con esto concluye el módulo sobre gestión de contexto. En la práctica aplicarás todo lo aprendido para optimizar tus sesiones con Claude Code.

Práctica del módulo 9: Gestión de contexto y tokens

En esta práctica aplicarás todas las técnicas del módulo para optimizar el uso de contexto en sesiones reales con Claude Code. Aprenderás a monitorear, optimizar y tomar decisiones inteligentes sobre cuándo compactar o iniciar nuevas sesiones.

Objetivos

Entender cómo se consume el contexto en sesiones reales
Monitorear tokens efectivamente con /context
Aplicar estrategias de optimización
Usar /compact en momentos estratégicos
Decidir cuándo iniciar nueva sesión vs. compactar
Desarrollar hábitos de gestión de contexto

Preparación: Proyecto de práctica

Usarás el mismo proyecto TODO App del módulo 8, pero con foco en gestión de contexto.

Si aún no lo tienes

# Crear proyecto
mkdir ~/claude-practice-context
cd ~/claude-practice-context
npm init -y
 
# Instalar dependencias
npm install express
npm install -D typescript @types/node @types/express ts-node vitest
npx tsc --init

Crear CLAUDE.md optimizado

Aplica lo aprendido en el módulo:

cat > CLAUDE.md << 'EOF'
# Proyecto: Práctica de gestión de contexto
 
## Stack
- Node.js + TypeScript
- Express
- Vitest
 
## Convenciones
- TypeScript estricto, no `any`
- Interfaces: Prefijo `I`
- Funciones: async/await
- Tests: TDD
 
## Comandos
- `npm run dev` → Desarrollo
- `npm test` → Tests
 
## Reglas
- Tests obligatorios
- No usar console.log
EOF

Meta: CLAUDE.md conciso (~200-300 tokens) con info esencial.

Ejercicio 1: Baseline - Medir consumo normal

Objetivo: Entender cómo se consume contexto en una sesión típica.

Paso 1.1: Iniciar sesión y medir estado inicial

claude

> /context

Anota:

Tokens iniciales: ______ / 200,000 (___%)
CLAUDE.md tokens: ______
Skills cargadas: ______

Paso 1.2: Implementar feature simple

> Implementa función validateEmail(email: string): boolean
  con tests

Paso 1.3: Medir después de feature

> /context

Anota:

Tokens ahora: ______ / 200,000 (___%)
Archivos leídos: ______
Tokens consumidos en esta tarea: ______ (diferencia)

Paso 1.4: Calcular ratio

Ratio tokens/tarea = Tokens consumidos / 1 feature
                   = ______ tokens

Reflexión: ¿Te parece eficiente? ¿Qué consumió más tokens?

Ejercicio 2: Optimización de lectura de archivos

Objetivo: Comparar lectura masiva vs. incremental.

Experimento A: Lectura masiva (❌ ineficiente)

# Nueva sesión
exit
claude

> /context
[Anota tokens iniciales: ______]
 
> Lee todos los archivos en src/
 
> /context
[Anota tokens ahora: ______]
[Diferencia: ______]

Tokens consumidos por lectura masiva: ______

Experimento B: Lectura incremental (✅ eficiente)

# Nueva sesión
exit
claude

> /context
[Anota tokens iniciales: ______]
 
> Lee solo src/utils/validators.ts
 
> /context
[Anota tokens ahora: ______]
[Diferencia: ______]

Tokens consumidos por lectura incremental: ______

Comparación

Lectura masiva: ______ tokens
Lectura incremental: ______ tokens
Ahorro: ______ tokens (___%)

Lección aprendida: _________________

Ejercicio 3: Impacto de mensajes verbosos vs. concisos

Objetivo: Medir cómo afectan los mensajes largos al contexto.

Paso 3.1: Nueva sesión

exit
claude

Paso 3.2: Mensaje verboso

> /context
[Tokens iniciales: ______]
 
> Hola Claude, espero que estés bien. Me gustaría que por favor
  me ayudaras a implementar una función de validación de passwords.
  La función debería verificar que el password tenga al menos 8
  caracteres, incluya mayúsculas, minúsculas, números y caracteres
  especiales. Por favor implementa esto en TypeScript siguiendo
  las mejores prácticas y agrega tests completos. Gracias.
 
> /context
[Tokens ahora: ______]
[Tu mensaje consumió aprox: ______]

Paso 3.3: Nueva sesión con mensaje conciso

exit
claude

> /context
[Tokens iniciales: ______]
 
> Implementa validatePassword(password: string): boolean
  Requisitos: min 8 chars, mayúsculas, minúsculas, números, especiales
  Incluye tests.
 
> /context
[Tokens ahora: ______]
[Tu mensaje consumió aprox: ______]

Comparación

Mensaje verboso: ~______ tokens
Mensaje conciso: ~______ tokens
Ahorro: ______ tokens

Lección: _________________

Ejercicio 4: Sesión larga con monitoreo

Objetivo: Practicar monitoreo durante una sesión larga.

Paso 4.1: Iniciar sesión y establecer baseline

exit
claude

> /context
📊 Baseline: ______ tokens (___%)

Paso 4.2: Implementar 3 funciones con monitoreo

Función 1: validateEmail

> Implementa validateEmail con tests

> /context
📊 Después de función 1: ______ tokens (___%)
   Incremento: ______

Función 2: validatePassword

> Implementa validatePassword con tests

> /context
📊 Después de función 2: ______ tokens (___%)
   Incremento: ______

Función 3: validateUsername

> Implementa validateUsername con tests

> /context
📊 Después de función 3: ______ tokens (___%)
   Incremento: ______

Paso 4.3: Análisis

Tokens promedio por función: ______ tokens
Progresión:
├─ Función 1: +______ tokens
├─ Función 2: +______ tokens
└─ Función 3: +______ tokens
 
Patrón: [ ] Lineal  [ ] Acelerado  [ ] Desacelerado

¿El incremento es consistente? ___________

Ejercicio 5: Practicar /compact

Objetivo: Usar /compact en el momento adecuado.

Paso 5.1: Llenar contexto intencionalmente

exit
claude

> Implementa servicio completo de autenticación:
  - login, register, logout
  - refresh tokens
  - password reset
  - email verification
  Con tests para todo
 
[Esto debería consumir bastante contexto]
 
> /context
📊 Contexto antes de compact: ______ tokens (___%)

Paso 5.2: Compactar

> /compact

Anota el resultado:

✅ Compaction complete!
├─ Tokens before: ______
├─ Tokens after: ______
├─ Tokens freed: ______ (___% reduction)
└─ Context remaining: ______ tokens (___%)

Paso 5.3: Verificar efecto

> /context
 
📊 Después de compact: ______ tokens (___%)

Paso 5.4: Probar coherencia post-compact

> ¿Qué implementamos en esta sesión?

¿Claude recuerda correctamente? [ ] Sí [ ] Parcialmente [ ] No

> ¿Qué stack estamos usando? (debe estar en CLAUDE.md)

¿Claude recuerda? [ ] Sí [ ] No

Análisis

Efectividad del /compact:
- Tokens recuperados: ______ (___%)
- Coherencia mantenida: [ ] Excelente  [ ] Buena  [ ] Regular  [ ] Mala
- ¿Valdría la pena compactar de nuevo o mejor nueva sesión?
  _________________

Ejercicio 6: Decisión - /compact vs. Nueva sesión

Objetivo: Practicar tomar la decisión correcta.

Escenario A

Contexto actual: 78%
Tarea completada: ✅ Autenticación implementada
Siguiente tarea: Implementar dashboard (diferente módulo)
Compactaciones previas: 0
 
¿Qué harías?
[ ] /compact y continuar
[ ] Nueva sesión
[ ] Continuar sin compactar
 
Justificación: _________________

Prueba tu decisión: Implementa lo que decidiste y evalúa el resultado.

Escenario B

Contexto actual: 92%
Tarea completada: ❌ En medio de debugging complejo
Siguiente: Seguir debuggeando el mismo bug
Compactaciones previas: 1
 
¿Qué harías?
[ ] /compact y continuar
[ ] Nueva sesión
[ ] Continuar sin compactar
 
Justificación: _________________

Prueba tu decisión: Implementa lo que decidiste y evalúa el resultado.

Escenario C

Contexto actual: 45%
Tarea completada: ✅ Validadores implementados
Siguiente: Tests de integración para validadores
Compactaciones previas: 0
 
¿Qué harías?
[ ] /compact y continuar
[ ] Nueva sesión
[ ] Continuar sin compactar
 
Justificación: _________________

Prueba tu decisión: Implementa lo que decidiste y evalúa el resultado.

Ejercicio 7: Optimizar CLAUDE.md

Objetivo: Crear un CLAUDE.md que consuma tokens eficientemente.

Paso 7.1: CLAUDE.md actual

> /context

Anota cuánto consume tu CLAUDE.md: ______ tokens

Paso 7.2: Si > 2,000 tokens, optimiza

Estrategias:

Eliminar info redundante
Ser más conciso
Mover detalles específicos a docs/

# Edita .claude/CLAUDE.md
# Hazlo más conciso

Paso 7.3: Verificar mejora

# Nueva sesión
exit
claude

> /context

CLAUDE.md ahora: ______ tokens

Ahorro: ______ tokens (___%)

Ejercicio 8: Comandos con output controlado

Objetivo: Evitar comandos que llenen el contexto.

Experimento: git log

exit
claude

> /context
[Baseline: ______]
 
> Ejecuta: git log --all --graph
 
> /context
[Ahora: ______]
[Incremento: ______]

vs.

exit
claude

> /context
[Baseline: ______]
 
> Ejecuta: git log --oneline -10
 
> /context
[Ahora: ______]
[Incremento: ______]

Comparación

git log --all: +______ tokens
git log -10: +______ tokens
Ahorro: ______ tokens

Lista de comandos seguros

Identifica 5 comandos que usas frecuentemente y encuentra sus versiones "token-safe":

1. Comando: ___________
   Token-safe: ___________
 
2. Comando: ___________
   Token-safe: ___________
 
3. Comando: ___________
   Token-safe: ___________
 
4. Comando: ___________
   Token-safe: ___________
 
5. Comando: ___________
   Token-safe: ___________

Ejercicio 9: Sesión completa optimizada

Objetivo: Aplicar todas las estrategias en una sesión real.

Paso 9.1: Planificación

Tarea: Implementar módulo completo de "Tasks" (CRUD completo)

Estrategia:

Plan:
├─ Sesión 1: Modelos + Create + Read
├─ Sesión 2: Update + Delete
└─ Sesión 3: Tests de integración

Plan:
├─ Sesión única con compactación estratégica
└─ Monitoreo cada 15-20 mensajes

Tu decisión: _________________

Paso 9.2: Ejecución con métricas

Inicio:

> /context
📊 Inicio: ______ tokens (___%)

Cada 20 mensajes (o después de cada sub-tarea):

> /context
 
[Mensaje 20]
📊 ______ tokens (___%)
 
[Mensaje 40]
📊 ______ tokens (___%)
 
[Mensaje 60]
📊 ______ tokens (___%)

Si llegas a 70%:

¿Qué hiciste?
[ ] /compact
[ ] Nueva sesión
[ ] Continuar
 
¿Funcionó bien? _________________

Paso 9.3: Resultado final

📊 Resultados de la sesión:
├─ Duración: ______ horas
├─ Mensajes: ______
├─ Contexto máximo: ______ (___%)
├─ Compactaciones: ______
├─ Archivos leídos: ______
├─ Sesiones usadas: ______
└─ Tarea completada: [ ] Sí  [ ] Parcialmente  [ ] No
 
Eficiencia: [ ] Excelente  [ ] Buena  [ ] Regular  [ ] Mala
 
¿Qué harías diferente la próxima vez?
_________________

Ejercicio 10: Identificar síntomas de contexto lleno

Objetivo: Reconocer cuándo el contexto está afectando la calidad.

Paso 10.1: Crear sesión larga

Trabaja en una sesión hasta que notes algún síntoma:

Síntomas detectados:
[ ] Claude más lento
[ ] Olvida información anterior
[ ] Respuestas genéricas
[ ] Pregunta por archivos ya leídos
[ ] Código no sigue convenciones
 
Mensaje donde lo noté: ______
Contexto en ese punto: ______ (___%)

Paso 10.2: Acción correctiva

Acción tomada:
[ ] /compact
[ ] Nueva sesión
[ ] Otra: _________________
 
¿Se resolvió el problema? [ ] Sí  [ ] No

Ejercicio 11: Comparación de estrategias

Objetivo: Comparar diferentes enfoques para la misma tarea.

Tarea de prueba

"Implementar sistema completo de usuarios: CRUD + autenticación + permisos"

Estrategia A: Sesión única larga

exit
claude

Implementa todo en una sola sesión.

📊 Resultados:
├─ Tiempo: ______ horas
├─ Mensajes: ______
├─ Contexto final: ______ (___%)
├─ Compactaciones: ______
├─ Calidad del código: [ ] Excelente  [ ] Buena  [ ] Regular
└─ Coherencia mantenida: [ ] Sí  [ ] Parcialmente  [ ] No

Estrategia B: Múltiples sesiones enfocadas

Sesión 1: CRUD básico
Sesión 2: Autenticación
Sesión 3: Permisos

📊 Resultados:
├─ Tiempo total: ______ horas
├─ Mensajes totales: ______
├─ Sesiones: 3
├─ Contexto máximo en cualquier sesión: ______ (___%)
├─ Calidad del código: [ ] Excelente  [ ] Buena  [ ] Regular
└─ Coherencia mantenida: [ ] Sí  [ ] Parcialmente  [ ] No

Comparación

¿Cuál estrategia fue mejor?
[ ] Estrategia A (sesión única)
[ ] Estrategia B (múltiples sesiones)
 
¿Por qué?
_________________

Checklist de validación

Marca cada punto cuando lo hayas completado:

Monitoreo

Usé /context regularmente durante sesiones
Entiendo qué consume más tokens (archivos, mensajes, tool results)
Puedo estimar cuánto contexto tengo sin usar /context

Optimización

Creé CLAUDE.md conciso (< 2,000 tokens)
Practicé lectura incremental de archivos
Reduje verbosidad en mis mensajes
Identifiqué comandos "token-safe" para mi workflow

/compact

Usé /compact exitosamente al menos 2 veces
Entiendo cuándo usar /compact vs. nueva sesión
Verifiqué coherencia después de compactar

Nueva sesión

Inicié nueva sesión cuando era apropiado
Documenté estado antes de cerrar sesión
Retomé trabajo en nueva sesión sin perder contexto

Síntomas

Identifiqué al menos 3 síntomas de contexto lleno
Tomé acción correctiva cuando los detecté

Workflow

Completé al menos una tarea grande con gestión óptima de contexto
Mi ratio tokens/mensaje mejoró vs. inicio del ejercicio

Métricas de éxito

Compara tus sesiones antes y después de este módulo:

Antes del módulo

Sesión típica:
├─ Contexto final: ______ (___%)
├─ Compactaciones: ______
├─ Archivos leídos: ______
├─ Tokens/mensaje: ______
└─ Síntomas de degradación: [ ] Sí  [ ] No

Después del módulo

Sesión típica:
├─ Contexto final: ______ (___%)
├─ Compactaciones: ______
├─ Archivos leídos: ______
├─ Tokens/mensaje: ______
└─ Síntomas de degradación: [ ] Sí  [ ] No

Mejora

Contexto final: ______ → ______ (___% mejora)
Compactaciones: ______ → ______
Tokens/mensaje: ______ → ______ (___% mejora)

Retos adicionales (opcionales)

Reto A: Sesión maratón optimizada

Objetivo: Trabajar 4+ horas en una sola sesión sin llenar contexto
 
Estrategia:
- Compactación proactiva cada 70%
- Documentar decisiones en archivos
- Lectura selectiva de archivos
- Mensajes ultra-concisos
 
¿Lo lograste? [ ] Sí  [ ] No
Contexto máximo: ______ (___%)

Reto B: Proyecto completo con 0 compactaciones

Objetivo: Completar un módulo entero sin necesitar /compact
 
Estrategia:
- CLAUDE.md súper optimizado
- Sesiones cortas y enfocadas
- Monitoreo constante
- Nueva sesión cuando es necesario
 
¿Lo lograste? [ ] Sí  [ ] No
Sesiones necesarias: ______

Reto C: Optimización extrema de CLAUDE.md

Objetivo: CLAUDE.md efectivo con < 500 tokens
 
Tu CLAUDE.md actual: ______ tokens
 
Optimiza y mide:
Nuevo CLAUDE.md: ______ tokens
 
¿Sigue siendo útil? [ ] Sí  [ ] No
¿Claude sigue las convenciones? [ ] Sí  [ ] No

Reflexión final

Lecciones aprendidas

1. _________________
2. _________________
3. _________________

Hábitos nuevos que adoptarás

1. _________________
2. _________________
3. _________________

Tu estrategia personal de gestión de contexto

Para sesiones cortas (< 1 hora):
_________________
 
Para sesiones medias (1-3 horas):
_________________
 
Para sesiones largas (3+ horas):
_________________
 
Para debugging:
_________________
 
Para implementación de features:
_________________

Próximo módulo

En el Módulo 10: Claude Code SDK aprenderás a usar Claude Code como framework para construir tus propios agentes personalizados, automatizaciones y herramientas.

¡Excelente trabajo dominando la gestión de contexto! Esta es una de las habilidades más importantes para ser un power user de Claude Code.