TL;DR Para resumir tu conversación, Claude Code manda una petición aparte que la lleva entera. Con la caché caliente la lee a en torno al 10% del precio de entrada; una hora después de irte no hay caché y la reprocesa al 100%. Compacta antes de la pausa y no al volver, y de paso lo que se queda frío mientras comes es un resumen de dos mil tokens en lugar de cien mil.
Vuelves de comer, escribes "sigue por donde íbamos" y el cursor se queda pensando. Diez segundos, quince. La respuesta acaba llegando y es correcta, pero ese turno solo ha consumido más que la hora entera de trabajo de antes de la pausa. No es que Claude se haya vuelto lento. Es que tu caché se ha muerto mientras comías y ese primer mensaje ha pagado la reconstrucción de toda la conversación.
Tiene arreglo, y el arreglo no es un ajuste ni una variable de entorno. Es una decisión de cuándo compactar, y son ocho caracteres escritos treinta segundos antes de levantarte de la mesa.
Por qué /compact no cuesta siempre lo mismo
Compactar parece una operación local, como si Claude Code recortara texto por su cuenta. No lo es. Para escribir el resumen manda una petición aparte, con tu system prompt, tus tools y tu conversación entera, más una instrucción de resumir pegada al final. El resumen se paga leyendo todo lo que quieres resumir.
Ahí es donde entra la caché. Claude Code cachea el prefijo de cada petición y una lectura desde caché se factura a en torno al 10% del precio de entrada. Con la sesión viva, esa petición de resumen lee tu historial de la caché y lo único que pagas entero es generar el resumen. Tras una pausa larga la caché ha expirado: no queda nada que leer y la misma petición reprocesa el historial completo como entrada nueva.
Mismo comando, misma conversación, mismo resumen. Lo que cambia es el reloj.
Así se ve la diferencia en los dos contadores que la API devuelve en cada respuesta:
# /compact escrito antes de irte a comer (caché caliente)
cache_read_input_tokens: 94.220 ← tu historial, a ~10% del input
cache_creation_input_tokens: 380 ← solo el resumen nuevo
# /compact escrito al volver, hora y media después (caché expirada)
cache_read_input_tokens: 0 ← cero aciertos
cache_creation_input_tokens: 94.600 ← el mismo historial, a precio completo
Y hay una segunda mitad que casi nunca se cuenta. Compactar antes de irte no te libra del reproceso de la vuelta: el primer mensaje después de una pausa larga siempre reconstruye la caché. Lo que cambia es sobre qué la reconstruye. Si te fuiste con la conversación entera encima, vuelves reconstruyendo cien mil tokens. Si te fuiste compactado, vuelves reconstruyendo un resumen. Ese es el beneficio real y son dos cosas a la vez: el resumen te sale por una décima parte, y el turno de la vuelta deja de arrastrarse.
Los tres momentos
1. Antes de levantarte: compacta con instrucciones
No lo dejes en un /compact pelado. Dile qué te importa conservar, porque el resumen lo escribe un modelo que no sabe cuál de las cuarenta cosas de la sesión es la que vas a retomar:
/compact céntrate en la migración de auth/ y en los dos tests que siguen fallando
Aun así, no todo vuelve igual del otro lado: qué sobrevive a un /compact y qué desaparece sin avisar es la letra pequeña de este movimiento.
Y si lo que vas a hacer al volver es otra tarea distinta, esto no es lo tuyo. La duda de compact vs clear se resuelve sola: /clear cuando abandonas el hilo, /compact cuando quieres seguir en él. Esta pregunta de cuándo compactar solo existe si vas a volver a la misma conversación.
2. Comprueba cuánto margen tienes de verdad
La hora no es universal. Es el mejor caso, y puedes verificar en cuál estás con una llamada suelta:
claude -p "hi" --output-format json
Busca el bloque usage.cache_creation en la respuesta:
"cache_creation": {
"ephemeral_1h_input_tokens": 17743,
"ephemeral_5m_input_tokens": 0
}
Si el peso está en ephemeral_1h_input_tokens, tu conversación principal aguanta una hora de silencio. Si está en ephemeral_5m_input_tokens, aguanta cinco minutos y tu "pausa" es levantarte a por agua.
3. Al volver, orientas tú
El resumen te devuelve el contexto, pero a ti no te devuelve la cabeza. /recap te cuenta por dónde ibas sin tocar la caché, porque adjunta el resumen como salida de comando en vez de sustituir el historial.
Quién compacta si no lo haces tú
Alguien va a compactar esa conversación de todas formas. Si el contexto se llena, salta el auto-compact, que decide el momento por ocupación de la ventana. Es un buen sistema y conviene dejarlo en su sitio, pero mide llenado, no relojes: no sabe que te vas a comer y no tiene forma de saberlo.
Compactar antes de la pausa es la única versión de esto que eliges tú, y encima es la versión que puedes dirigir con instrucciones.
Referencia: cuánto vive tu caché
Cada acierto reinicia el contador, así que la caché aguanta mientras trabajas. El TTL solo empieza a correr cuando paras.
| Peticiones | Suscripción, dentro del uso incluido del plan | Usage credits, API key o proveedor cloud |
|---|---|---|
| Conversación principal | Una hora | Cinco minutos |
| Todo lo demás: subagentes, workflows, forks y la propia compactación | Cinco minutos | Cinco minutos |
Dos matices que sorprenden a casi todo el mundo. El primero: en cuanto pasas del uso incluido del plan y entras en usage credits, tu conversación principal baja sola a cinco minutos, porque a partir de ahí la facturan. El segundo: la petición que genera el resumen vive en la fila de abajo, así que hereda cinco minutos aunque tú tengas una hora.
Si quieres fijarlo tú, hay un ajuste por fila. promptCacheTtl (o la variable CLAUDE_CODE_PROMPT_CACHE_TTL) manda sobre la conversación principal, y subagentPromptCacheTtl (o CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL) sobre el resto. Ambos aceptan 5m o 1h y nada más:
{
"promptCacheTtl": "1h"
}
Esto es un hábito de horario, no un ajuste, así que encaja al lado de los otros: 10 hábitos para ahorrar tokens trabaja el tamaño del contexto, y este trabaja el momento en que lo pagas.
Documentación oficial: How Claude Code uses prompt caching
Requisitos: promptCacheTtl, subagentPromptCacheTtl y sus dos variables de entorno necesitan Claude Code v2.1.242 o superior. La TTL de una hora no está disponible a través del Claude apps gateway, y en Amazon Bedrock depende del modelo y de la región.