Receta · Intermedio · 10 min

/clear vs /compact en Claude Code y la compactación en reposo

Cuándo usar /clear o /compact en Claude Code, qué sobrevive a una compactación y cómo apagar la compactación en reposo con idleCompaction.

Probado con Claude Code 2.1.316 · revisado 2026-11-01

Ver los archivos en GitHub Gratis · licencia MIT

El problema

El contexto es todo lo que Claude sabe de tu sesión: CLAUDE.md, archivos leídos, resultados de herramientas y la propia conversación. Cuando se llena, Claude Code compacta: sustituye el historial por un resumen, y ahí se pierden detalles. Y desde octubre de 2026 también puede compactar solo mientras no estás, así que de pronto Claude «olvida» el error exacto o el porqué de una decisión.

La solución

Decide tú cuándo empezar de cero (/clear), cuándo resumir guiando qué conservar (/compact con instrucciones), cuándo resumir solo una parte (/rewind) y cuándo adelantar la compactación automática (/autocompact). Y entiende la compactación en reposo para dejarla, ajustarla o apagarla con idleCompaction: false.

Chuleta dentro de la sesión:

/context                         # ¿cuánto llevo y qué pesa?
/clear nombre-tarea              # tarea nueva sin relación (gratis; /resume la recupera)
/compact conserva X, Y y Z       # misma tarea, menos contexto
/rewind  (o Esc Esc)             # Summarize from here / up to here
/autocompact 500k                # compactar antes (auto = valor del modelo)
/branch probar-otra-idea         # bifurcar la conversación
/config                          # fila Idle compaction

1. /clear o /compact: la regla de una línea

¿Vas a hacer algo que no tiene relación con lo anterior? /clear. ¿Sigues con la misma tarea pero el contexto pesa? /compact con instrucciones.

/clear empieza una conversación nueva con el contexto vacío y no cuesta nada; acepta un nombre (/clear arreglo-login) para etiquetar la conversación anterior en el selector de /resume, y sus alias son /reset y /new. La conversación anterior no se pierde: /resume la recupera y, dentro del mismo proceso de Claude Code, el menú de /rewind muestra arriba una entrada «/resume <id> (previous session)».

/compact [instrucciones] resume lo hablado hasta ahora para liberar espacio y sigue en la misma conversación; es una petición grande, porque lee todo lo que resume. Con la caché caliente sale bastante más barata de lo que sugiere el tamaño; tras una pausa larga, la caché ha caducado y reprocesa todo. Por eso conviene compactar en una pausa natural (entre tareas) y no retomar una sesión enorme y fría solo para compactarla.

Si lo que quieres es descartar un camino equivocado, /rewind a un turno anterior es mejor que compactar: vuelve a un prefijo que ya está en caché.

2. Qué sobrevive a una compactación (y qué no)

La documentación oficial detalla qué pasa con cada cosa.

Lo que no está en disco, como el texto exacto de un error o el porqué de una decisión, es lo que más se pierde. Pon lo importante arriba en SKILL.md. Si una regla debe sobrevivir siempre, quita su paths: o muévela al CLAUDE.md raíz (ver un CLAUDE.md que funciona).

3. Compacta tú, y dile qué conservar

Tienes cuatro formas de controlar la compactación en vez de esperar a la automática:

1. /compact con foco: «/compact conserva el error exacto del test de pagos, las rutas tocadas y por qué descartamos Redis».
2. Instrucciones fijas en CLAUDE.md: una sección «# Compact instructions», que la documentación oficial muestra como ejemplo para personalizar la compactación.
3. Compactar solo una parte: /rewind (o Esc dos veces con el prompt vacío), elige un mensaje y pulsa «Summarize from here» o «Summarize up to here»; puedes escribir instrucciones en la fila «add context (optional)». Los mensajes originales siguen en el transcript del disco.
4. Adelantar la automática: /autocompact 500k fija hasta dónde se llena la ventana antes de compactar; /autocompact auto vuelve al valor del modelo.

La sección para CLAUDE.md:

# Compact instructions
Al compactar, conserva siempre:
- el texto exacto de los errores y de los tests que fallan
- las rutas de los archivos modificados
- las decisiones tomadas y por qué se descartaron las alternativas
- los próximos pasos pendientes

Truco recomendado antes de una compactación grande: pide a Claude que escriba el estado en un archivo. Ese archivo está en disco y puedes pedirle que lo relea después; es más fiable que confiar en el resumen.

Antes de que compactemos, escribe en NOTAS.md: objetivo, decisiones tomadas (con el porqué), errores encontrados con su texto exacto, archivos tocados y próximos pasos. No cambies código.

4. La compactación en reposo (idle compaction), explicada

Desde la 2.1.299 (14-oct-2026) en terminal, y desde la 2.1.314 (30-oct) en VS Code y en la pestaña Code de la app de escritorio, Claude Code compacta por su cuenta una conversación larga que dejas parada. La idea es ahorrar: con suscripción, la caché de la conversación dura una hora; si vuelves después, tu siguiente mensaje reprocesaría todo. Al compactar antes de que caduque, el siguiente mensaje envía solo el resumen.

Se activa cuando se cumplen todas estas condiciones:

• sesión interactiva (terminal, panel de VS Code o pestaña Code del escritorio, en tu máquina o por SSH);
• autoCompactEnabled activado;
• conversación con la caché de una hora;
• Claude Code puede obtener flags de Anthropic;
• el contexto llega al umbral (200.000 tokens por defecto);
• ha pasado cerca de una hora sin peticiones con el equipo despierto (el CHANGELOG habla de unos 54 minutos).

Cómo saberlo: en terminal verás una línea que empieza por «Compacted while idle, before the prompt cache expired»; en VS Code y escritorio, un aviso con «a summary written while you were away». El precio es el mismo de cualquier compactación: detalles resumidos. La issue #98747 cuenta un caso en que se perdió contexto de varias sesiones.

5. Apagarla, ajustarla o convivir con ella

Si prefieres decidir tú cuándo se resume, tienes tres opciones:

1. Desde la sesión: /config y cambia la fila «Idle compaction» (2.1.302 o posterior); se guarda en tus ajustes de usuario y se aplica al momento. Si la fila no aparece, otro origen de ajustes (gestionado, --settings, proyecto o local) fija la clave, o tu equipo no puede obtener flags y entonces no se ejecuta.
2. En ~/.claude/settings.json: "idleCompaction": false (requiere 2.1.290 o posterior; en versiones anteriores, apaga autoCompactEnabled). La variable DISABLE_AUTO_COMPACT la apaga junto con la compactación automática.
3. Subir o bajar el umbral con CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS (por defecto 200000; el mínimo real es 100000).

Apagarla:

{
  "idleCompaction": false
}

Dejarla activada, pero con umbral de 150 k:

{
  "env": {
    "CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS": "150000"
  }
}

Ten en cuenta el coste de apagarla: si vuelves de comer a una conversación de 300 k tokens, el primer mensaje reprocesa todo sin caché y eso cuenta para tu límite (ver límite de uso). Recomendación práctica: déjala activada y, antes de levantarte en mitad de una tarea delicada, haz tú un /compact con instrucciones o guarda NOTAS.md. Así el resumen lo decides tú.

6. Cuándo cambiar de estrategia: /branch, subagentes y 1M de contexto

Si quieres probar otro enfoque sin perder la conversación actual, /branch [nombre] crea una rama de la conversación y conserva la original para volver con /resume; /fork copia la sesión a una sesión en segundo plano.

Para lecturas grandes (logs, mucha documentación, explorar un repositorio), delega en un subagente: los archivos quedan en su contexto y a ti solo te llega el resumen.

Si de verdad necesitas una ventana mayor, los modelos Fable, Sonnet 5 y posteriores, Haiku 5.5, Opus 4.6 y posteriores y Sonnet 4.6 admiten 1 millón de tokens; la compactación funciona igual, pero más tarde.

Para ver dónde estás en cualquier momento: /context muestra la cuadrícula por categorías con sugerencias, y context_window.used_percentage se puede poner en la barra de estado (ver límite de uso). Y si usas modo plan, activa showClearContextOnPlanAccept: al aprobar el plan, una opción limpia el contexto y empieza a implementar solo con el plan (ver modo plan).

Compruébalo

En una sesión cualquiera, /context te enseña cuánto llevas. Lo comprobamos con Claude Code 2.1.316 en Linux: claude -p "/context" devolvió la tabla por categorías, con un 2 % usado en una sesión nueva. En cambio, /compact con -p sobre una sesión vacía responde «Not enough messages to compact», así que la prueba de verdad se hace en una sesión interactiva:

1. Lee varios archivos grandes y mira /context.
2. Lanza /compact con instrucciones y vuelve a mirar /context.
3. Pregunta por algo que pediste conservar y por algo que no.

Para la compactación en reposo, el método sería fijar CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS=100000, llenar más de 100 k tokens, dejar la sesión parada algo más de una hora con el PC despierto y buscar la línea «Compacted while idle»; después, repetir con "idleCompaction": false. Esta prueba no la hemos ejecutado todavía (lleva más de una hora y consume límite), así que aquí solo contamos lo que dice la documentación.

Por qué funciona

Claude Code envía todo el contexto en cada petición y la ventana tiene un tamaño fijo. Compactar cambia el historial por un resumen y recarga desde disco lo que tiene en disco (CLAUDE.md, memoria, plan, archivos recientes). Por eso lo que guías con instrucciones o guardas en un archivo sobrevive mejor que lo que solo estaba en la conversación. La compactación en reposo hace lo mismo antes de que caduque la caché de una hora. Fuentes: ventana de contexto, comandos, idleCompaction, caché al compactar, checkpointing, costes y el CHANGELOG.

Errores típicos

• Tras compactar, Claude olvida el error exacto o por qué descartasteis algo → eso solo estaba en la conversación y se resumió → usa /compact con instrucciones, «# Compact instructions» en CLAUDE.md o guarda NOTAS.md antes.
• Una regla de .claude/rules deja de aplicarse después de compactar → tiene paths: y solo se recarga cuando hace falta → quita su paths: o muévela al CLAUDE.md raíz.
• Una skill larga pierde instrucciones tras compactar → se reinyecta desde el principio con un tope de 5.000 tokens → pon lo importante arriba en SKILL.md.
• No aparece la fila «Idle compaction» en /config → otro origen de ajustes fija la clave o tu equipo no puede obtener flags → revisa los ajustes gestionados, de proyecto y local.
• Compactas una sesión vieja y gasta mucho → la caché ya había caducado y reprocesa todo → compacta en una pausa natural o empieza con /clear.
• Compactas para deshacer un camino equivocado → resumir no quita el error del contexto tan bien como volver atrás → usa /rewind.

Preguntas frecuentes

¿/clear borra mi conversación?

No. Empieza una nueva; la anterior se recupera con /resume y, en el mismo proceso, desde el menú de /rewind.

¿Por qué tras compactar Claude «olvida» cosas?

Porque la conversación se sustituye por un resumen. CLAUDE.md, la memoria, el plan y hasta cinco archivos recientes se recargan; el resto queda resumido. Guía el resumen con /compact <instrucciones> o «# Compact instructions» en CLAUDE.md.

Vi «Compacted while idle»: ¿qué ha pasado?

La compactación en reposo resumió una conversación de más de 200 k tokens que llevaba cerca de una hora parada, para que tu siguiente mensaje no reprocese todo. Si no la quieres: /config > Idle compaction, o "idleCompaction": false.

¿Compactar gasta límite?

Sí: la petición de resumen lee la conversación. Con la caché caliente sale barata; con una sesión fría, cara. /clear no cuesta nada.

¿Es buena idea desactivar la compactación automática?

Solo si controlas el contexto tú mismo con /context y /compact. Sin ella tendrás que vigilar tú el llenado y compactar o limpiar a mano. Si lo que quieres es que ocurra antes, en vez de quitarla usa /autocompact.

Me sale «Error during compaction: conversation too long»

Ese caso se trata en la receta de errores comunes (contexto lleno). Como prevención: compacta antes con /autocompact o divide el trabajo con /clear y NOTAS.md.

Toda la biblioteca