Cómo reducir los costos de tokens de Claude Code: la guía práctica de Anthropic para sesiones eficientes

Introducción

Anthropic ha publicado una guía práctica para desarrolladores que quieren obtener más valor de cada sesión de Claude Code.

El mensaje central es simple: la misma tarea de programación puede costar cantidades muy diferentes dependiendo de cómo gestiones la sesión.

Claude Code no es como un editor tradicional con un costo fijo por tarea. Cada solicitud al modelo tiene un costo de inferencia, y las conversaciones largas arrastran repetidamente archivos, resultados de herramientas, salidas de comandos, instrucciones del sistema y mensajes anteriores. Si ese contexto se gestiona mal, una simple corrección de errores puede terminar consumiendo muchos más tokens de lo necesario.

El artículo original destiló los consejos en seis hábitos prácticos:

1. Ejecuta /clear cuando termines una tarea y pases a otra.
2. Elige el modelo y el esfuerzo de razonamiento al inicio de la sesión en lugar de cambiar repetidamente a mitad de camino.
3. Usa @ para referenciar archivos directamente en lugar de hacer que Claude los busque.
4. Añade banderas silenciosas a los comandos que de otro modo producen grandes cantidades de salida.
5. Ejecuta /compact antes de una pausa larga mientras la caché de contexto existente aún esté activa.
6. Envía trabajo de investigación grande y ruidoso a un subagente para que su contexto intermedio no se acumule en la conversación principal.

El propio TL;DR de Anthropic también recomienda ejecutar /context en una sesión nueva para ver lo que ya está cargado, incluyendo CLAUDE.md y las definiciones de herramientas MCP.

Estas sugerencias tienen más sentido una vez que entiendes lo que le sucede a un token dentro de una sesión de Claude Code.

El Ciclo de Vida de un Token

Claude Code se puede usar a través de los planes de pago de Claude o mediante el uso de API por medición. Para usuarios individuales, Claude Pro cuesta actualmente $20 al mes con facturación mensual, mientras que Claude Max comienza en $100 al mes y también ofrece un nivel de uso más alto. El uso de API se factura por separado según el modelo y el volumen de tokens.

La documentación de costos de Claude Code de Anthropic dice que en implementaciones empresariales, el uso promedio es de alrededor de $13 por desarrollador por día activo y aproximadamente $150–250 por desarrollador por mes, aunque los costos reales varían sustancialmente según el modelo, la base de código, el flujo de trabajo y el nivel de automatización.

La misma tarea puede costar varias veces más si Claude tiene que buscar entre archivos innecesarios, ejecutar comandos verbosos o arrastrar repetidamente contexto irrelevante.

Para entender por qué, ayuda separar

cada solicitud en dos fases.

Prefill: Lectura de la entrada

Durante el prefill, el modelo lee la solicitud y su contexto en una sola pasada.

Esa entrada puede incluir:

• Definiciones de herramientas
• El prompt del sistema
• CLAUDE.md
• Tu mensaje actual
• Historial de conversación anterior
• Archivos que Claude ha leído
• Salida de comandos y herramientas ya añadida a la sesión

Todo esto cuenta como tokens de entrada.

Decode: Producción de la salida

Durante el decode, el modelo genera su respuesta token por token.

Eso incluye tokens de razonamiento, llamadas a herramientas y el texto que finalmente ves. A diferencia del prefill, el decode es secuencial: una respuesta de 200 tokens requiere que el modelo genere 200 tokens uno tras otro.

Por eso los tokens de salida suelen ser mucho más caros que los de entrada. Para los modelos Claude actuales que se analizan aquí, el precio de salida es cinco veces el precio base de entrada.

Los precios estándar actuales de la API son:

MTok significa un millón de tokens.

La otra variable principal es el nivel de esfuerzo. Gran parte de la salida generada en una sesión de codificación agéntica puede ser razonamiento. Un mayor esfuerzo permite que el modelo gaste más tokens pensando en un problema difícil, mientras que un menor esfuerzo puede ser más apropiado para trabajo rutinario.

La regla práctica es sencilla: usa un modelo más potente y un mayor esfuerzo cuando el problema sea realmente difícil o ambiguo, no automáticamente para cada tarea pequeña.

El almacenamiento en caché de prompts es la mayor palanca de costos

El almacenamiento en caché de prompts es una de las partes más importantes del modelo de costos de Claude Code.

Cada solicitud de Claude Code comienza con una gran cantidad de material repetido: definiciones de herramientas, el prompt del sistema, CLAUDE.md y el historial de conversación acumulado hasta el momento.

Si el comienzo de una nueva solicitud coincide exactamente con una solicitud reciente, el servidor puede reutilizar el estado calculado previamente en lugar de procesar todo el prefijo compartido de nuevo.

Una lectura de caché cuesta solo 0,1× el precio normal del token de entrada.

Las escrituras de caché son más caras que la entrada normal porque el servidor tiene que almacenar el estado calculado. Una escritura de caché estándar de cinco minutos cuesta 1,25× el precio de entrada base, mientras que una escritura de caché de una hora cuesta 2×. El punto importante es que la escritura ocurre una sola vez, mientras que los aciertos de caché posteriores pueden reutilizar repetidamente el prefijo a una décima parte del costo normal de entrada.

Imagina que una conversación ya contiene 50.000 tokens de historial. Sin un acierto de caché, el modelo tendría que hacer prefill de todo ese historial a la tarifa normal de entrada en la siguiente solicitud. Con una caché válida, el prefijo compartido se lee a 0,1× de la tarifa base y solo la parte

el material añadido debe procesarse al precio de entrada completo.

A lo largo de un bucle de agente prolongado, esa diferencia puede volverse considerable.

¿Qué rompe la caché?

La caché debe coincidir de forma continua desde el inicio de la solicitud. Si algo cambia cerca del principio de ese prefijo—o cambia parte de la clave de caché—el historial restante ya no puede reutilizarse de la misma manera.

El artículo original destaca seis casos comunes.

1. Cambiar el modelo con /model
2. Cada modelo tiene una caché separada. Cambiar de un modelo a otro significa que el siguiente turno tiene que rellenar la conversación existente nuevamente para el nuevo modelo.
3. Cambiar el nivel de esfuerzo de razonamiento con /effort
4. El nivel de esfuerzo es parte de la clave de caché. Cambiarlo en medio de una sesión puede forzar que la conversación se procese de nuevo.
5. Activar el modo rápido
6. El modo rápido también cambia la clave de caché. Anthropic recomienda activarlo al principio si planeas usarlo. Desactivar el modo rápido no conlleva la misma penalización de caché.
7. Ejecutar /compact
8. La compactación reescribe la conversación en un resumen más corto. La conversación anterior ya no coincide, por lo que la caché de conversación previa no puede simplemente continuar.
9. Dejar que la caché expire
10. En las suscripciones de Claude Code, Anthropic indica que la caché de prompt expira después de una hora de inactividad. Con una clave API, el TTL predeterminado es de cinco minutos a menos que se habilite explícitamente la caché de una hora.
11. Reanudar una sesión antigua
12. Una sesión antigua generalmente ya no tendrá una caché activa, y el prompt del sistema se reconstruye cuando se inicia Claude Code. Por lo tanto, la siguiente solicitud a menudo requiere un nuevo relleno.

Esto no significa que nunca debas cambiar de modelo, de nivel de esfuerzo o compactar una conversación. Significa que hay momentos más económicos para hacerlo: al inicio de una sesión o justo después de /clear, en lugar de a mitad de un contexto largo y costoso.

También hay un caso menos evidente en el modo opusplan. Anthropic señala que entrar o salir del modo plan puede cambiar de modelo, por lo que cada transición puede invalidar la caché del modelo correspondiente.

Por qué /compact es más económico antes de una pausa

/compact resume la conversación actual en una versión mucho más corta.

Dado que producir ese resumen requiere leer el contexto existente, es más económico compactar mientras la conversación aún está disponible a través de la caché de prompt. Si esperas hasta después de una pausa larga y la caché ha expirado, Claude puede necesitar leer la conversación completa al costo de entrada normal antes de poder resumirla.

Por eso Anthropic recomienda compactar antes de alejarte del teclado durante un período prolongado.

Tu sesión está creciendo silenciosamente

La caché de prompt hace que el contexto repetido sea más económico, pero no impide que el contexto mismo crezca.

Cada vez que Claude lee un archivo, el contenido del archivo se añade a la conversación. Cada vez que ejecuta un comando, la salida también puede añadirse. A partir de ese momento, los turnos posteriores siguen llevando ese material.

El turno 40 no es solo la solicitud más reciente. También lleva gran parte de lo que ocurrió en los turnos 1 al 39.

Por eso las sesiones largas pueden acumular costos mucho más rápido de lo que los desarrolladores esperan. Incluso cuando el historial antiguo es

En caché, transportar repetidamente contexto irrelevante no es gratuito, y también consume espacio en la ventana de contexto.

Claude Code sí tiene una salvaguarda para salidas de Bash extremadamente grandes. La documentación actual de Anthropic dice que cuando la salida de un comando supera los 30.000 caracteres, Claude Code escribe la salida en un archivo y conserva solo una vista previa breve y la ruta en la conversación.

El caso incómodo es una salida ruidosa pero que aún está por debajo de ese umbral.

Una suite de pruebas que imprime cientos de líneas de pruebas exitosas puede permanecer por debajo de los 30.000 caracteres. Si es así, esas líneas pueden permanecer en la conversación y seguir enviándose en turnos posteriores.

Por lo tanto, Anthropic recomienda mantener activamente el contexto de trabajo ágil.

1. Referenciar archivos con @

Si sabes qué archivo necesita Claude, reférencialo directamente.

En lugar de pedirle a Claude que localice un archivo por nombre, usa una mención @ para que el archivo se adjunte al mensaje desde el principio.

Compara estas instrucciones conceptualmente:

Los tests están fallando.

Claude puede tener que buscar en el repositorio, inspeccionar varios archivos y recopilar varios resultados de herramientas antes de llegar al problema real.

Una solicitud más específica elimina parte de esa exploración:

Corrige el test que falla en utils.test.ts.

Y una referencia @ puede evitar la llamada de lectura separada:

Corrige el test que falla en @utils.test.ts.

El archivo ocupa contexto de todos modos. El ahorro proviene de evitar búsquedas y turnos de lectura innecesarios.

También evita adjuntar el mismo archivo repetidamente en una conversación. Una vez que un archivo ha entrado en el contexto, mencionarlo de nuevo puede añadir otra copia.

1. Añadir indicadores silenciosos a comandos ruidosos

La salida repetida de comandos puede dominar silenciosamente una sesión.

Para los comandos que ejecutas constantemente, incluye una versión concisa en CLAUDE.md para que Claude conozca la invocación de menor ruido desde el principio.

Por ejemplo:

ejecutar un solo archivo de test con npx vitest run  --reporter=dot

Un reportero de puntos puede devolver solo un resultado compacto en lugar de cientos de líneas de salida detallada.

Esto es un pequeño cambio de configuración, pero a lo largo de muchos turnos puede ahorrar una gran cantidad de contexto repetido.

1. Aislar el trabajo de alta salida en un subagente

Un subagente tiene su propia ventana de contexto.

Tiene su propio prompt de sistema, herramientas y CLAUDE.md, pero no hereda la conversación principal completa. Puede inspeccionar registros, ejecutar comandos, buscar en el historial o leer un archivo grande y luego devolver solo la respuesta a la sesión principal.

Esto es útil para tareas como:

• "Revisa este registro de compilación y dime qué está mal."
• "Busca en este archivo grande e informa de la sección relevante."

”

• “Ejecuta la suite completa de pruebas y devuelve los fallos importantes.”
• “Inspecciona el historial de Git y resume el cambio que introdujo este comportamiento.”

Las lecturas de archivos intermedias y la salida de comandos desaparecen cuando el subagente termina. Solo su respuesta devuelta entra en la sesión principal.

Hay una compensación: como el subagente no hereda la conversación principal, puede necesitar releer material que la sesión principal ya conoce. Para trabajos pequeños, esa sobrecarga puede hacer que un subagente sea menos eficiente. Vale la pena cuando la tarea aislada es lo suficientemente ruidosa como para que no quieras que su proceso permanezca en el contexto principal.

1. Usa /clear cuando cambie la tarea

Este es uno de los hábitos más simples y valiosos.

Una vez que terminas una corrección de errores y comienzas una tarea diferente, ejecuta:

/clear

Las lecturas de archivos de la tarea anterior, la salida de comandos, los enfoques fallidos y el contexto temporal ya no necesitan acompañar cada turno posterior.

La propia comparación de Anthropic muestra que mantener tres tareas separadas en una sola sesión continua puede enviar sustancialmente más tokens que limpiar entre tareas.

Si necesitas conservar la sesión anterior para más adelante, Anthropic recomienda usar /rename antes de /clear.

Si todavía estás trabajando en la misma tarea y solo necesitas comprimir la parte más antigua de la conversación, /compact es la mejor herramienta.

Usa /rewind cuando solo los últimos turnos salieron mal

Hay otra opción útil que es fácil pasar por alto:

/rewind

Si la sesión solo se desvió durante los últimos turnos, rebobinar puede eliminar esos turnos sin reescribir toda la conversación anterior.

Eso importa para el almacenamiento en caché. Anthropic dice que la parte anterior al punto de rebobinado puede permanecer en caché, mientras que /compact reescribe la conversación y, por lo tanto, tiene su propio costo.

Entonces, los tres comandos sirven para diferentes propósitos:

Gestionar tokens se está convirtiendo en una habilidad de desarrollador

Una vez que estos mecanismos están claros, surge un patrón más amplio.

La codificación asistida por IA eficiente ahora requiere un nuevo tipo de juicio operativo. Los desarrolladores necesitan saber no solo cómo escribir y depurar código, sino también:

• Qué modelo es apropiado para la tarea
• Cuánto esfuerzo de razonamiento está justificado
• Qué pertenece al contexto activo
• Cuándo una sesión debe limpiarse o compactarse
• Qué trabajos deben moverse a subagentes
• Qué comandos producen salida innecesaria
• Qué cambios invalidarán un caché de indicaciones

Hace un año, estas decisiones apenas existían en el desarrollo de software diario. Ahora pueden determinar si dos desarrolladores pagan cantidades muy diferentes para completar esencialmente el mismo trabajo.

La propia Anthropic ilustra cuán importante es esto a escala.

La compañía informó en 2026 que más del 80% del código fusionado en el repositorio de Anthropic fue escrito por Claude, y que el ingeniero típico

estaba fusionando alrededor de 8 veces más código por día que en 2024. En un benchmark interno de optimización por separado, un sistema basado en Claude pasó de aceleraciones de aproximadamente 3× en 2025 a alrededor de 52× para abril de 2026.

En ese nivel de uso de IA, la eficiencia de inferencia no es un detalle contable menor.

La lección más profunda de la guía de Anthropic, por lo tanto, no es meramente "gastar menos tokens". Es entender hacia dónde van los tokens y asegurarse de que se gasten en razonamiento útil, cambios de código y trabajo con herramientas, en lugar de historia obsoleta y salida evitable.

Preguntas frecuentes

¿Por qué Claude Code se vuelve más caro durante sesiones largas?

Cada nuevo turno arrastra consigo el historial de conversación relevante, incluyendo mensajes, archivos, llamadas a herramientas y salida de comandos. El almacenamiento en caché de prompts hace que los prefijos repetidos sean mucho más baratos, pero el contexto creciente sigue consumiendo tokens y capacidad de la ventana de contexto.

¿Cuánto puede ahorrar el almacenamiento en caché de prompts de Claude?

Un acierto de caché de prompt se factura a 0.1× el precio normal del token de entrada base, lo que representa una reducción del 90% para esa porción de entrada almacenada en caché. Las escrituras en caché cuestan más que la entrada normal, pero las lecturas repetidas de caché pueden compensar rápidamente ese costo inicial de escritura.

¿Debo usar /clear o /compact en Claude Code?

Usa /clear cuando te estés moviendo a una tarea diferente y ya no necesites el contexto actual. Usa /compact cuando te mantengas en la misma tarea pero quieras que Claude resuma el historial de conversación más antiguo en un contexto de trabajo más reducido.

¿Qué hace /rewind en Claude Code?

/rewind te permite saltar hacia atrás a un mensaje anterior y eliminar los turnos posteriores del contexto activo. Es útil cuando solo la parte más reciente de una conversación tomó una dirección equivocada y no necesitas compactar ni limpiar toda la sesión.

¿Cambiar el modelo de Claude aumenta el costo de tokens?

Puede hacerlo. Cada modelo utiliza una caché de prompts separada, por lo que cambiar de modelo en medio de una conversación larga puede forzar a que el historial existente se procese nuevamente al precio completo de entrada para el nuevo modelo.

¿Por qué debería usar @ al hacer referencia a un archivo?

Una referencia de archivo con @ adjunta el archivo directamente al mensaje, lo que puede ahorrarle a Claude la búsqueda del archivo o la realización de una llamada de lectura adicional. El contenido del archivo sigue consumiendo contexto, por lo que el beneficio es evitar pasos de descubrimiento innecesarios, no hacer que el archivo en sí sea gratuito.

¿Cuándo debería usar un subagente de Claude Code?

Usa un subagente para trabajos que generan mucha salida intermedia que no necesitas en la conversación principal, como inspeccionar registros o ejecutar una búsqueda amplia. El subagente trabaja en un contexto separado y envía solo su respuesta final de vuelta a la sesión principal.

¿Cómo puedo verificar qué está consumiendo contexto actualmente?

Ejecuta /context en una sesión nueva de Claude Code. Anthropic recomienda usarlo para inspeccionar el contexto de inicio, como CLAUDE.md y las definiciones de herramientas MCP, para que puedas eliminar instrucciones o integraciones que no necesitas.

Herramientas relacionadas

• Claude Code: La herramienta de codificación agéntica de Anthropic para trabajar con bases de código desde la terminal, IDE, web y otros entornos compatibles.
• Claude: La interfaz principal de asistente de Anthropic y entrada de cuenta.

punto para los planes de Claude que incluyen Claude Code.

• Claude Agent SDK: El SDK expone el mismo bucle de agente, herramientas y fundamentos de gestión de contexto que utiliza Claude Code.
• Vitest: Un marco de pruebas de JavaScript utilizado en el ejemplo de Anthropic para reducir la salida de pruebas ruidosa con --reporter=dot.

Enlaces relacionados

• Maximizando el valor de tus sesiones de Claude Code: La guía oficial de Anthropic de agosto de 2026 que constituye la base técnica de este artículo.
• Gestión de costos de Claude Code: Documentación oficial para rastrear el uso, controlar el gasto y reducir el consumo de tokens.
• Precios de la API de Claude: Precios actuales de modelos, caché de prompts, modo rápido y API.
• Documentación de caché de prompts: Explicación oficial de los TTL de caché, multiplicadores de escritura, lecturas de caché y comportamiento de implementación.
• Gestión de sesiones de Claude Code: Guía de Anthropic para elegir entre continuar, rebobinar, compactar y borrar una sesión.
• Eligiendo un modelo de Claude y nivel de esfuerzo: Orientación sobre cómo igualar la capacidad del modelo y el esfuerzo de razonamiento a la dificultad de la tarea.
• El caché de prompts lo es todo: Las lecciones de ingeniería de Anthropic sobre cómo preservar la eficiencia del caché de prompts en flujos de trabajo agentivos.
• Cuando la IA se construye a sí misma: El informe de Anthropic sobre código interno escrito por IA, producción de ingeniería y experimentos de optimización impulsados por modelos.

Resumen

Los costos de Claude Code están determinados por más que el precio del modelo. La longitud del contexto, el esfuerzo de razonamiento, la salida de comandos, la duración de la sesión, los aciertos de caché, el descubrimiento de archivos y el uso de subagentes pueden cambiar cuántos tokens consume una tarea.

Los hábitos de mayor valor son simples: limpia el contexto cuando cambie la tarea, evita cambios innecesarios de modelo o esfuerzo a mitad de sesión, mantén corta la salida ruidosa, referencia archivos conocidos directamente, compacta antes de una pausa larga y aísla el trabajo de alta salida cuando un subagente sea más adecuado.

Estas prácticas no pretenden minimizar el uso de tokens a toda costa. Pretenden asegurar que los tokens que pagas contribuyen a la tarea en lugar de transportar repetidamente historial irrelevante.

El uso eficiente de Claude Code es cada vez más una forma de ingeniería de contexto: mantén el contexto relevante, preserva la caché cuando ayude y gasta el razonamiento donde realmente mejore el resultado.