Reduce el consumo de tokens de Claude: 6 arreglos reales

Nadie presupuesta tokens. Luego llega un mes intenso, la factura se duplica y, de repente, todos en el equipo son expertos en ventanas de contexto. Hemos auditado suficientes configuraciones de Claude Code para conocer el patrón: la factura rara vez la impulsa el trabajo que pediste. La impulsa todo lo que viaja de acompañante.

Esta guía es el playbook que usamos de verdad. Los arreglos están ordenados por impacto, lo que significa que los estructurales y aburridos van primero y el divertido (el routing de modelos) va al final, porque ahí es donde está el dinero. Los precios de abajo son tarifas de API a mediados de 2026: unos 3 $ por millón de tokens de entrada en Sonnet, 5 $ en Opus, 1 $ en Haiku, con los tokens de salida costando unas cinco veces más. Si estás en una suscripción Pro o Max pagas en límites de uso en lugar de dólares, pero cada arreglo de aquí te compra lo mismo: más trabajo por sesión antes de chocar con el muro.

A dónde van realmente los tokens

Cada petición que Claude Code envía a la API lleva toda tu sesión hasta el momento, más un preámbulo fijo: el system prompt, tu CLAUDE.md, la descripción de cada skill instalado y el esquema completo de cada herramienta de cada servidor MCP conectado. Ese preámbulo se factura en cada turno, lo use el turno o no.

En una configuración madura esto suma rápido. Los cuatro quemadores que más vemos, en orden:

El primero son las relecturas de contexto. Un agente que leyó tu archivo de configuración de 2.000 líneas ayer lo vuelve a leer hoy, porque las sesiones no recuerdan nada. Multiplica por cada archivo que "revisa por si acaso" y el redescubrimiento se convierte en una partida de la factura.

El segundo son los esquemas de herramientas MCP. Cada servidor que has conectado inyecta sus definiciones de herramientas en cada petición. No cuando se usa la herramienta. Siempre. Cinco servidores pueden significar de 15.000 a 25.000 tokens de esquemas plantados delante de tu pregunta real, todo el día, todos los días.

El tercero es un CLAUDE.md hinchado. Un archivo de memoria de 3.000 líneas son unos 30.000 tokens de impuesto sobre cada petición de cada sesión, para siempre. La mayoría de esas líneas aplican quizá a una sesión de cada diez.

El cuarto es re-explicar. "Usa conventional commits. No toques la carpeta legacy. Preferimos pnpm." Si tecleas tus preferencias en el chat cada mañana, estás pagando por enseñar la misma lección a diario, y la lección luego viaja en el historial de la sesión en cada turno posterior.

El caché de prompts suaviza todo esto. El contexto estable repetido se factura a más o menos una décima parte del precio normal de entrada. Pero las escrituras de caché cuestan un extra, el contenido cacheado sigue ocupando tu ventana de contexto, y un solo byte cambiado cerca del principio del prompt invalida todo lo que viene después. El caché es un descuento, no un arreglo.

Mide antes de optimizar

Adivinar el desperdicio de tokens es su propia forma de desperdicio. Diez minutos de medición te dicen cuál de los seis arreglos de abajo importa de verdad en tu configuración.

Dentro de Claude Code, /cost muestra lo que ha gastado la sesión actual, y /context muestra lo que ocupa la ventana ahora mismo, desglosado en system prompt, herramientas, archivos de memoria y mensajes. Ese segundo es el espejo honesto: si los esquemas de herramientas y el CLAUDE.md se llevan 40.000 tokens antes de que hayas tecleado nada, ya has encontrado tu problema.

Para el histórico, la herramienta comunitaria ccusage lee los archivos de transcripción que Claude Code ya guarda en disco y te da desgloses por día y por modelo. Los usuarios de API pueden ver lo mismo en la página de uso de la consola de Anthropic, separado por clave. Y si quieres saber lo que cuesta un archivo concreto, el endpoint count_tokens de la API da un número exacto; pasar tu CLAUDE.md por él son treinta segundos que te bajan a tierra.

Consigue una semana de línea base antes de cambiar nada. Cada afirmación que hacemos abajo sobre nuestros propios números salió de hacer exactamente esto, y el skill Token Budget Auditor existe para automatizar todo el ejercicio (más sobre él en el arreglo 6).

Arreglo 1: sustituye los prompts repetidos por skills

Este es el cambio con más palanca para la mayoría, y funciona gracias a una decisión de diseño: la revelación progresiva. Las instrucciones completas de un skill se cargan solo cuando el skill se activa. El único coste que pagas en cada petición es su descripción de activación, normalmente de 30 a 60 tokens. Si el formato te es nuevo, nuestro explicador de skills de Claude cubre la mecánica.

Haz las cuentas con un prompt que pegues a diario. Digamos que son 2.000 palabras, unos 2.600 tokens: tus reglas de estilo de código, tu checklist de revisión, lo que sea que guardas en una nota y pegas cada mañana. Una vez pegado, se queda en el historial de la sesión y se reenvía en cada turno. A 30 turnos por sesión, ese único bloque genera unos 78.000 tokens de entrada por sesión. En 22 días laborables, alrededor de 1,7 millones de tokens al mes. En Sonnet eso son unos 5 $ sin caché, digamos de 1 a 2 $ con buenos aciertos de caché.

Como skill, el mismo contenido cuesta su descripción de 50 tokens por turno, unos 33.000 tokens al mes, más el cuerpo completo de 2.600 tokens solo en las sesiones donde realmente se dispara. Llámalo una reducción del 95 al 98 por ciento para ese bloque.

Cinco dólares al mes suenan a nada hasta que recuerdas dos cosas. Nadie tiene un solo prompt pegado; las configuraciones que auditamos tienen de cinco a diez. Y el coste en dólares ni siquiera es el daño principal: esos tokens ocupan contexto, lo que empuja las sesiones largas a la compactación antes, lo que dispara relecturas, que cuestan más de lo que costaba el prompt. Convertir prompts pegados en skills es el cambio individual con la mejor relación esfuerzo-ahorro que conocemos.

Arreglo 2: pon a dieta tu CLAUDE.md

CLAUDE.md es contexto siempre encendido. Ese es todo su valor y todo su coste. El test para cada línea es simple: ¿aplica esto a la mayoría de sesiones de este proyecto?

Va en CLAUDE.md: comandos de build y test, la disposición del repositorio, las tres restricciones no obvias que rompen cosas cuando se violan, reglas duras como "nunca hagas commit directo a main". Esto suele ser de 30 a 60 líneas.

No va: instrucciones de flujo para tareas que haces cada semana (eso es un skill), guías de estilo para trabajo ocasional como escribir docs o migraciones (skill), explicaciones largas de arquitectura que Claude puede leer del código, y todo lo que copiaste "por si hace falta". Si una sección aplica a menos de la mitad de tus sesiones, está pagando alquiler a jornada completa por trabajo a media jornada. Muévela a un skill y no costará nada hasta el día en que sea relevante.

Seguimos viendo archivos CLAUDE.md de más de 2.000 líneas, y sus dueños suelen sorprenderse dos veces: primero por el recuento de tokens (pásalo por count_tokens), y luego al descubrir que recortarlo hizo a Claude más obediente, no menos. Las instrucciones compiten por la atención. Cuarenta líneas afiladas ganan a dos mil blandas.

Arreglo 3: poda los servidores MCP que no usas

Los servidores MCP son el quemador más silencioso porque el coste es invisible en el uso diario. Conectar un servidor significa que sus esquemas de herramientas se serializan en cada petición. Un servidor típico expone de 10 a 30 herramientas a unos cientos de tokens de esquema cada una; los servidores oficiales grandes son peores. Cuando medimos nuestra propia configuración, un servidor popular añadía por sí solo unos 20.000 tokens por petición, y lo habíamos usado dos veces ese mes.

Ejecuta claude mcp list y sé implacable. Para cada servidor, pregúntate cuándo lo usaste de verdad por última vez. Nuestra regla tras hacer este ejercicio en nuestras propias máquinas: dos servidores por proyecto es de sobra, y deberían acotarse a los proyectos que los necesitan en lugar de configurarse globalmente. Un servidor de base de datos no pinta nada gravando tus sesiones de escritura de blog.

Reconsidera también si cada servidor superviviente debería ser un servidor. Muchas conexiones MCP existen para envolver una CLI que Claude podría ejecutar directamente por bash con coste fijo cero. Escribimos el marco de decisión completo en skills vs MCP, pero la versión corta: MCP se gana su impuesto de esquemas cuando necesitas acceso vivo y autenticado a un sistema externo. Para instrucciones, flujos de trabajo y cualquier cosa basada en archivos, un skill hace el trabajo sin el alquiler por petición.

Podar es además el raro arreglo que es instantáneo. Sin refactorizar, sin migración. Quita tres servidores ociosos y tu siguiente petición pesa 30.000 tokens menos.

Arreglo 4: hábitos de sesión que mantienen el contexto pequeño

La estructura arregla los costes fijos. Los hábitos arreglan los variables.

Empieza sesiones nuevas por tarea. Una sesión inmortal que deambula de un arreglo de bug a un refactor a "ya que estás, actualiza el README" arrastra todo el contexto del bug a cada turno del README. El historial se reenvía en cada petición, así que los turnos de una sesión larga se vuelven progresivamente más caros. Cuando el tema cambia, /clear o una sesión nueva es casi siempre más barato que continuar, y la calidad del output suele mejorar además, porque el contexto rancio confunde más de lo que ayuda.

Usa /compact en fronteras naturales, no en el último momento. Claude Code compacta automáticamente cuando la ventana se llena, pero para entonces llevas una hora pagando tarifa completa por un historial hinchado. Compactar justo después de un hito ("los tests pasan, ahora la siguiente funcionalidad") encoge el historial mientras tú controlas qué merece conservarse. La compactación cuesta una pasada de resumen; cargar con peso muerto cuesta en cada turno.

Acota tus peticiones. "Encuentra dónde validamos emails y arregla la regex" manda a Claude a una expedición de grep por una docena de archivos, cada uno leído al contexto y facturado durante el resto de la sesión. Si sabes que está en src/lib/validators.ts, dilo. Diez segundos de especificidad ahorran rutinariamente 50.000 tokens de exploración. La misma lógica aplica a las lecturas: señalar a Claude un rango de líneas gana a dejar que ingiera un archivo de 2.000 líneas para usar 40.

Nada de esto exige más disciplina que fijarse. Observa /context durante un día y los patrones de desperdicio se identifican solos.

Arreglo 5: enruta las subtareas baratas a modelos más baratos

Sí, el routing de modelos ahorra dinero. Lo ponemos quinto porque en todas las auditorías que hemos hecho, los equipos se lanzaban a por él mientras un CLAUDE.md hinchado y seis servidores MCP ociosos quemaban el triple. Primero estructura, luego routing.

Dicho eso, la aritmética es real: Haiku cuesta una quinta parte de Sonnet, y de nuevo una quinta parte de Opus. La forma limpia de explotarlo en Claude Code son los subagentes. Exploración, resumir un archivo largo, generar tests boilerplate, primeras versiones de mensajes de commit: delega esto en un subagente con Haiku mientras el bucle principal sigue en tu modelo primario. La propia arquitectura de Claude Code hace esto internamente para algunas tareas de búsqueda, lo que te dice que Anthropic considera sólido el patrón.

Lo que no recomendamos es alternar el modelo de la sesión principal de un lado a otro a mitad de tarea. Los cachés de prompts son por modelo, así que cada cambio tira tu prefijo cacheado y vuelve a pagar precio completo por reconstruirlo. Elige un modelo por sesión; enruta en la frontera del subagente. Y deja el razonamiento duro en el modelo fuerte. Un modelo barato que produce un plan equivocado cuesta más que uno caro que acierta a la primera. Eso también lo hemos medido, por desgracia.

Arreglo 6: los skills de eficiencia de tokens que estamos testeando

Mantenemos una categoría dedicada de eficiencia de tokens, y la sometemos a un estándar más estricto que ninguna otra: un veredicto ahí tiene que venir con una factura de antes y después medida, no con sensaciones. Eso hace los veredictos más lentos. Este es el estado actual, con honestidad.

Token Budget Auditor lee tus transcripciones y tu configuración y nombra a tus principales derrochadores de tokens: contexto de sistema hinchado, lecturas de archivos redundantes, bucles de herramientas parlanchines. Es el paso de "mide primero" empaquetado como skill. Veredicto pendiente; estamos ejecutando una comparación de facturación antes/después en nuestras propias cuentas antes de puntuarlo.

Context Compression empaqueta la disciplina de resumir y continuar del arreglo 4 para que las sesiones largas se compacten en resúmenes estructurados en lugar de arrastrar historial en bruto. En la cola de pruebas; estamos midiendo el ahorro de tokens contra la pérdida de información a lo largo de una semana de sesiones reales, porque una compresión que olvida tus restricciones es peor que ninguna compresión.

Prompt Cache Optimizer reestructura el contexto para hacerlo amigable al caché: contenido estable primero, contenido volátil al final. El desperdicio más común que ataca es un timestamp interpolado cerca del principio de un prompt, invalidando el caché en silencio en cada petición. Arreglo de una línea, ahorro de dos dígitos cuando aplica. Estamos midiendo tasas de acierto de caché en vivo antes de emitir veredicto.

El único skill adyacente que ya ha superado las pruebas es Memory Management, que sacó un 9,2/10 en nuestra prueba de una semana. Vive en nuestra categoría de productividad, pero en el fondo es una jugada de tokens: la memoria persistente convierte el redescubrimiento repetido (el modo de fallo más caro del arreglo 4) en una escritura y recuperaciones baratas. Que Claude recuerde las decisiones de tu proyecto es Claude no releyendo doce archivos para reconstruirlas.

La lista completa, con notas de test y los veredictos que existan, está en mejores skills de eficiencia. Preferimos enseñarte una cola con mediciones en marcha que una página de puntuaciones seguras que no podemos respaldar.

El Optimizer Pack, si quieres el atajo

Un párrafo honesto sobre nuestro propio producto. El Optimizer Pack es la configuración de eficiencia que instalaríamos en nuestras propias máquinas: los tres skills de eficiencia de arriba más Memory Management, preconfigurados, con una plantilla de CLAUDE.md recortada y una checklist de auditoría de MCP, instalados con un comando. Cuesta 10 $, sobre todo porque empaquetar y mantener las configuraciones lleva tiempo real. Todo lo que contiene también está disponible gratis desde las páginas individuales de los skills; el pack te ahorra una tarde de configuración, nada más. Si disfrutas trasteando, sáltatelo.

Un antes y después realista

Aquí va un esbozo basado en un compuesto de usuarios intensivos que hemos auditado: un desarrollador que corre Claude Code más de cuatro horas al día en Sonnet vía API, con un CLAUDE.md de 2.500 líneas, cinco servidores MCP y sesiones maratonianas.

Antes: unos 140 millones de tokens de entrada y 4 millones de salida al mes. Con un rendimiento de caché mediocre (el CLAUDE.md tenía una cabecera dinámica, así que el caché apenas funcionaba), eso ronda los 480 $ al mes.

Después de aplicar los arreglos 1 a 5: podar tres servidores MCP y recortar el CLAUDE.md a 60 líneas redujo el preámbulo por petición en unos 45.000 tokens. Convertir siete prompts pegados en skills eliminó otro trozo del historial de cada turno. Las sesiones frescas y la compactación temprana acortaron la longitud media del historial en un tercio. Arreglar el invalidador de caché hizo que el contexto estable restante por fin se facturara a tarifa de caché. Enrutar los subagentes de exploración a Haiku afeitó el resto. Factura nueva: unos 210 $ al mes.

Eso es una reducción del 55 por ciento con cero cambio en lo que se construyó. Tus números serán distintos, y trataríamos con sospecha a cualquiera que prometa un porcentaje exacto, incluidos nosotros. Pero reducir aproximadamente a la mitad la factura de un usuario intensivo solo con estructura coincide con lo que hemos visto más de una vez. El patrón se sostiene también en suscripciones: la misma persona dejó de chocar con los límites del plan Max a media tarde.

FAQ

¿Algo de esto importa si estoy en una suscripción Pro o Max en vez de la API? Sí, solo que en otra moneda. Las suscripciones te miden mediante límites de uso, y esos límites los consumen los mismos tokens que paga un usuario de API. Una configuración más ligera significa más trabajo real antes de tocar el tope. Los usuarios que "chocan constantemente con los límites" suelen cargar 40.000 tokens de preámbulo por petición sin saberlo.

¿Los skills instalados cuestan tokens cuando no se usan? Solo la descripción de activación, típicamente de 30 a 60 tokens por skill y petición. El cuerpo se carga cuando el skill se dispara. Veinte skills instalados cuestan alrededor de 1.000 tokens de gasto fijo, y por eso una biblioteca grande de skills es barata mientras que un CLAUDE.md grande no lo es. El único modo de fallo son los skills con descripciones hinchadas; los señalamos en nuestras reseñas.

¿Cuánto contexto consume realmente un servidor MCP? Varía muchísimo, y por eso deberías medir el tuyo: ejecuta /context con el servidor conectado y luego desconectado. Los servidores pequeños y enfocados añaden de 1.000 a 3.000 tokens de esquemas. Los oficiales grandes pueden añadir de 15.000 a 25.000. El coste aplica a cada petición, llames o no a alguna herramienta.

¿Es mejor /compact que empezar una sesión nueva? Trabajos distintos. /compact es para continuar trabajo relacionado: resume el historial para que el contexto siga adelante más pequeño. Una sesión nueva es para cambiar de tema, y entonces es la opción más barata y mejor, porque el historial no relacionado no solo es caro, degrada activamente el output. Si estás compactando para continuar algo no relacionado, lo que querías era /clear.

¿El caché de prompts no resuelve esto automáticamente? Ayuda mucho y está activado por defecto en Claude Code, pero descuenta el desperdicio en lugar de eliminarlo. Los tokens cacheados siguen facturándose a alrededor del 10 por ciento, siguen llenando tu ventana de contexto y siguen empujándote a la compactación temprana. Y el caché se rompe en silencio: cualquier cambio en el prefijo estable, como un timestamp en tu configuración, y vuelves al precio completo sin aviso. Estructura bien tu contexto y el caché multiplica el ahorro; estructúralo mal y el caché esconde el problema hasta la factura.