### Respuesta Rápida: Cómo hacer que Claude consuma menos tokens
Para reducir el consumo de tokens en Claude Code hasta en un 75%, implementa cuatro optimizaciones clave: configura un archivo
.claudeignoreestricto para descartar artefactos de compilación y lockfiles, aprovecha el 90% de descuento en lectura de prompt caching de Anthropic mediante prefijos estáticos, aísla subtareas con subagentes Scout para evitar la degradación del contexto (Context Rot), y priorizaclaude-3-7-sonnetoclaude-3-5-haikupara inspección de código antes de recurrir a Opus.
1. Introducción: El drenaje invisible de tokens en agentes de terminal
Los agentes autónomos de codificación en terminal, como Claude Code de Anthropic, han transformado radicalmente el flujo de desarrollo. A diferencia de las extensiones de autocompletado en IDEs, Claude Code opera dentro de un bucle de razonamiento autónomo: examina árboles de directorios, lee archivos de miles de líneas, ejecuta comandos en la shell, analiza registros del compilador y aplica parches precisos en el código fuente.
Sin embargo, esta autonomía conlleva un elevado coste en la API. Sin una configuración previa rigurosa, una solicitud en apariencia sencilla como "Refactoriza el middleware de autenticación para soportar rotación de tokens JWT" puede consumir entre 1,5 y 3,5 millones de tokens en una sola sesión. Esta inflación se debe a cuatro causas críticas:
- Acumulación y degradación del contexto (Context Rot): La salida de comandos bash, coincidencias de grep, trazas de depuración y volcados completos de archivos permanecen atrapados en la ventana de contexto activa del agente.
- Reingesta sin caché: Modificar inadvertidamente los primeros mensajes de la conversación invalida el límite de 5 minutos del almacenamiento efímero en caché (Prompt Caching) de Anthropic.
- Escaneo de artefactos redundantes: Durante búsquedas recursivas con regex, Claude Code lee directorios de compilación (
dist/,target/,.next/), enormes archivos de dependencias (package-lock.json,pnpm-lock.yaml) y volcados de bases de datos. - Sobredimensionamiento de modelos: Utilizar modelos insignia de razonamiento masivo (
claude-3-opuso Sonnet con Extended Thinking al máximo) para tareas triviales como listar directorios o buscar rutas de archivos.
Mediante restricciones sistemáticas de arquitectura —uso estricto de .claudeignore, aprovechamiento de prompt caching, delimitación de tareas con subagentes y ajuste fino de la CLI— los equipos de ingeniería reducen habitualmente su consumo diario de tokens en Claude Code entre un 70% y un 80%, mejorando al mismo tiempo la tasa de éxito de cada tarea.
2. Economía cuantitativa: Tarifas de tokens y arquitectura de caché
Para diagnosticar las pérdidas de tokens, analizamos las tarifas de la API de Anthropic y sus niveles de caché (precios base 2026):
| Variante de Claude | Input Base ($/1M) | Escritura en Caché ($/1M) | Lectura de Caché ($/1M) | Output ($/1M) | SWE-bench Verified | Rol Óptimo en Terminal |
|---|---|---|---|---|---|---|
| Claude 3.5 / 3.7 Haiku | $0.80 | $1.00 | $0.08 | $4.00 | 41.2% | Búsqueda de símbolos, filtros regex, mensajes de commit |
| Claude 3.7 Sonnet (Estándar) | $3.00 | $3.75 | $0.30 | $15.00 | 70.3% | Refactorización principal, edición multifichero, tests |
| Claude 3.7 Sonnet (Extended Thinking) | $3.00 (in) | $3.75 (write) | $0.30 | $15.00 (pensamiento+out) | 72.8% | Errores arquitectónicos complejos, condiciones de carrera |
| Claude 3 Opus / Opus 4.6 | $15.00 | $18.75 | $1.50 | $75.00 | 74.1% | Auditorías de seguridad críticas, rediseño completo |
Desglose matemático: Ahorro del 75% en costes y tokens
Consideremos una sesión típica de 15 turnos refactorizando un endpoint REST en un repositorio TypeScript de 150.000 líneas de código:
[Sesión ingenua sin optimizar]
Turno 1: Carga mapa del repo + package-lock.json + esquema de BD (180.000 tokens)
Turnos 2-5: Volcados de grep, registros de build, lecturas completas (acumulado: 240.000 tokens/turno)
Tasa de fallos en caché: 45% (invalidación frecuente por cabeceras dinámicas)
Tokens de entrada totales procesados: 3.250.000
Coste efectivo (Sonnet): ~$9.75
[Sesión optimizada: .claudeignore + Prompt Cache + Subagentes]
Turno 1: Resumen AST limpio (18.000 tokens) -> Guardado en caché en el Turno 1
Turnos 2-5: Diffs incrementales, subagente Scout devuelve informe condensado (22.000 tokens/turno)
Tasa de acierto en caché: 92% (lecturas con tarifa con descuento de $0.30/1M)
Tokens de entrada totales procesados: 410.000 (87.3% de reducción física de tokens)
Coste efectivo (Sonnet): ~$0.82 (91.5% de ahorro económico real)3. Pilar 1: Configurar .claudeignore para eliminar contexto residual
La acción individual de mayor impacto que puedes aplicar en cualquier repositorio es crear un archivo .claudeignore riguroso para producción.
Claude Code respeta las directivas de .gitignore por defecto, pero los .gitignore convencionales suelen ignorar archivos masivos que envenenan el contexto del LLM. Archivos lock de dependencias, documentación estática, salidas de compilación y bundles minificados nunca deben entrar en la ventana del agente.
Plantilla de producción de .claudeignore
Coloca este archivo en la raíz de tu proyecto:
# ==============================================================================
# .claudeignore - Matriz de exclusión para ahorro de tokens en producción
# Evita que Claude Code ingiera artefactos masivos durante glob y grep
# ==============================================================================
# Lockfiles de paquetes (Enormes bloques JSON/YAML sin utilidad para el AST)
package-lock.json
pnpm-lock.yaml
yarn.lock
bun.lockb
composer.lock
Gemfile.lock
Cargo.lock
poetry.lock
# Artefactos de compilación y bundles generados
dist/
build/
out/
.next/
.nuxt/
.astro/
.svelte-kit/
storybook-static/
target/
*.min.js
*.min.css
*.map
# Cobertura de pruebas, logs y perfiles de rendimiento
coverage/
.nyc_output/
*.lcov
*.log
npm-debug.log*
yarn-debug.log*
pnpm-debug.log*
*.heapsnapshot
*.cpuprofile
# Archivos multimedia, imágenes y binarios
public/assets/
public/images/
*.png
*.jpg
*.jpeg
*.gif
*.svg
*.webp
*.avif
*.ico
*.pdf
*.zip
*.tar.gz
*.wasm
# Documentación interna y especificaciones externas de APIs
docs/
*.mdx
specs/swagger/
*.postman_collection.json
# Variables de entorno y certificados de seguridad
.env*
!.env.example
*.pem
*.key
*.cert
# Migraciones de base de datos y volcados SQL
*.sql
*.dump
prisma/migrations/El impacto medido de .claudeignore
Cuando Claude Code ejecuta una búsqueda recursiva, un package-lock.json no ignorado (con frecuencia entre 25.000 y 80.000 líneas) consumirá instantáneamente más de 120.000 tokens en una sola lectura. Al excluir lockfiles y código compilado, el contexto inicial cae de ~180k tokens a menos de ~15k tokens.
4. Pilar 2: Arquitectura de Prompt Caching y el descuento del 90%
El sistema de almacenamiento en caché de prompts de Anthropic retiene los tokens de entrada en los servidores hasta por 5 minutos (renovándose con cada acierto de caché). La lectura de tokens en caché cuesta solo el 10% del precio base de entrada ($0.30/1M frente a $3.00/1M en Sonnet).
+-------------------------------------------------------------------------+
| Ciclo de vida de Prompt Caching en Anthropic |
+-------------------------------------------------------------------------+
|
v
+-------------------------------------------------------------------------+
| [System Prompt y Definición de Herramientas] (Prefijo estático en caché)|
+-------------------------------------------------------------------------+
|
v
+-------------------------------------------------------------------------+
| [Arquitectura del Repo y Reglas de Codificación] (Punto de control) |
+-------------------------------------------------------------------------+
|
v (¡Punto de ruptura de caché!)
+-------------------------------------------------------------------------+
| [Instrucciones dinámicas del usuario e historial] (Cola no almacenada) |
+-------------------------------------------------------------------------+Reglas clave para preservar la caché de prompts
- Nunca incluyas marcas de tiempo dinámicas en el contexto del sistema: Evita fechas o IDs de sesión dinámicos en
CLAUDE.md. Si cambia un solo carácter al inicio del prefijo, se invalidan todos los tokens cacheados posteriores. - Encadena solicitudes dentro de la ventana de 5 minutos: El TTL de la caché es de 300 segundos. Si pausas 6 minutos revisando código, la siguiente solicitud incurrirá en la tarifa completa de escritura ($3.75/1M).
- Ordena las directivas de más estáticas a más dinámicas: El motor de Claude Code sitúa las reglas estáticas al principio de la carga útil de la API. Mantén deterministas las normas de
CLAUDE.md.
5. Pilar 3: Uso de subagentes y aislamiento de subtareas
Una de las trampas más costosas en agentes de terminal es la trampa de la sesión monolítica. En un único hilo, el desarrollador solicita reproducir un error, redactar pruebas, refactorizar código, ejecutar suites de integración y documentar cambios.
Para el turno 12, la ventana de contexto contiene cientos de líneas de pruebas fallidas, registros del compilador y versiones viejas de archivos. Cada petición posterior reenvía todo este volumen innecesario a la API.
Arquitectura de agentes en dos niveles: Scout y Worker
Desacopla la fase de exploración y lectura de la modificación activa de código:
[Solicitud del usuario]
|
v
+---------------------------------------------+
| Nivel 1: Subagente Scout (Solo Lectura) |
| - Ejecutado en claude-3-5-haiku o similar |
| - Emplea Glob, Grep y lecturas por rangos |
| - Condensa 500.000 tokens en 2KB de datos |
+---------------------------------------------+
|
v (Traspaso de contexto comprimido)
+---------------------------------------------+
| Nivel 2: Agente Ejecutor Principal (Worker)|
| - Ejecutado en claude-3-7-sonnet |
| - Recibe RUTAS EXACTAS y símbolos clave |
| - Aplica parches quirúrgicos por líneas |
+---------------------------------------------+Implementación del aislamiento en Claude Code
Divide el trabajo complejo en pasos separados en la terminal:
# Ineficiente: Monolito que infla el contexto
claude "Busca todos los endpoints con autenticación obsoleta, pásalos a OAuth2, arregla los tests y documenta"
# Eficiente: Exploración aislada -> Ejecución focalizada
# Paso 1: Exploración económica
claude --model claude-3-5-haiku -p "Lista únicamente las rutas de archivos y números de línea que usen el middleware de auth obsoleto en formato JSON." > auth-audit.json
# Paso 2: Modificación quirúrgica con contexto limpio
claude --model claude-3-7-sonnet "Refactoriza los endpoints listados en auth-audit.json para usar OAuth2. No toques ningún otro archivo."6. Pilar 4: Selección de modelos — ¿Qué modelo de Claude consume menos tokens?
No todos los modelos consumen la misma cantidad de tokens ante un mismo problema:
- Presupuesto de Thinking (Razonamiento): Los modelos con Extended Thinking generan miles de tokens internos de razonamiento facturados como tokens de salida ($15.00/1M en Sonnet).
- Verbosidad en llamadas a herramientas: Algunos modelos emiten largas explicaciones preliminares antes de ejecutar herramientas, inflando la generación.
- Eficiencia en búsquedas: Modelos más inteligentes localizan símbolos con 1 o 2 llamadas a grep bien dirigidas, mientras que modelos inferiores pueden leer archivos enteros a ciegas.
Comparativa de consumo de tokens por tipo de tarea
| Tipo de Tarea | Claude 3.5 Haiku | Claude 3.7 Sonnet (Normal) | Claude 3.7 Sonnet (8k Thinking) | Claude 3 Opus |
|---|---|---|---|---|
| Localizar símbolo en el repo | 12k tokens / $0.01 | 14k tokens / $0.04 | 24k tokens / $0.18 | 18k tokens / $0.27 |
| Corrección de bug puntual | 28k tokens / $0.03 | 22k tokens / $0.07 | 35k tokens / $0.24 | 30k tokens / $0.45 |
| Refactorización de 5 archivos | Alta tasa de fallos | 140k tokens / $0.48 | 190k tokens / $1.25 | 220k tokens / $3.30 |
| Condición de carrera compleja | No lo resuelve | 320k tokens (falla) | 240k tokens (resuelve) / $1.60 | 280k tokens / $4.20 |
Criterio de selección estratégica
- Caballo de batalla por defecto: Utiliza
claude-3-7-sonneten modo normal para el 80% de las tareas diarias de desarrollo. - Exploración y scripts: Emplea
claude-3-5-haikupara descubrimiento de archivos, generación de regex, scripts sencillos y clasificación de logs. - Modo de pensamiento profundo reservado: Activa el razonamiento extendido (
thinking: { budget_tokens: 4000 }) únicamente cuando enfrentes errores algorítmicos complejos o fallos de compilación persistentes.
7. Configuración avanzada y optimización de .claude/config.json
Claude Code permite parametrizar su comportamiento mediante archivos de configuración en ~/.claude.json o en .claude/config.json.
Configuración de alta eficiencia en .claude/config.json
{
"$schema": "https://json.schemastore.org/claude-code-config.json",
"model": "claude-3-7-sonnet",
"maxThinkingTokens": 2048,
"autoCompactContext": true,
"contextCompactionThreshold": 0.65,
"allowedTools": [
"Edit",
"Bash",
"Glob",
"Grep",
"Read"
],
"toolLimits": {
"bashOutputMaxLines": 150,
"readFileMaxLines": 300
},
"enableTelemetry": false
}Parámetros destacados
maxThinkingTokens: 2048: Acota el presupuesto de razonamiento extendido. Sin este límite, tareas sencillas pueden consumir entre 8k y 16k tokens de salida ($0.12 - $0.24) por turno.autoCompactContext: true: Ejecuta un resumen automático del historial cuando el contexto alcanza el 65% de capacidad (contextCompactionThreshold: 0.65), liberando espacio ocupado por herramientas antiguas.bashOutputMaxLines: 150: Evita que suites de tests o gestores de paquetes vuelquen 5.000 líneas de stdout directamente en el contexto del modelo.
8. Patrones tácticos de prompting en la terminal
Tus hábitos de interacción determinan hasta el 40% del gasto de tokens en cada sesión:
Patrón 1: Lectura acotada por rangos de líneas
En lugar de permitir la lectura íntegra de archivos grandes, especifica las líneas relevantes:
# Ineficiente: Lee 1.800 líneas (14.000 tokens)
"Lee src/auth/session.ts y revisa por qué falla la verificación del token de usuario"
# Eficiente: Lee solo 60 líneas (450 tokens)
"Inspecciona las líneas 120-180 de src/auth/session.ts donde está declarada la función verifyJwt()"Patrón 2: Contención y filtrado de salidas de shell
Al solicitar pruebas o compilaciones, exige un formato conciso:
# Ineficiente: Vuelca miles de líneas de tests superados
"Ejecuta npm test y corrige el fallo"
# Eficiente: Contiene la salida
"Ejecuta npm test -- --reporter=dot o filtra por grep solo los fallos. No muestres los tests que pasen."Patrón 3: Limpieza y compactación activa (/compact y /clear)
Aprovecha los comandos internos de Claude Code:
/compact: Fuerza de inmediato la compactación del historial, transformándolo en un breve resumen técnico./clear: Limpia por completo la memoria de contexto antes de iniciar una tarea no relacionada, sin necesidad de reiniciar la terminal.
9. Matriz comparativa de estrategias de ahorro de tokens
| Estrategia de Optimización | Ahorro Típico de Tokens | Dificultad de Implementación | Riesgo para la Calidad del Código | Mecanismo Central |
|---|---|---|---|---|
.claudeignore riguroso |
40% – 60% | Baja (5 min) | Cero | Bloquea lockfiles, multimedia y carpetas de build |
Compactación (/compact) |
30% – 50% | Inmediata (comando) | Bajo | Elimina salidas caducadas de shell y código previo |
| Exploración con subagentes | 35% – 55% | Media | Muy bajo | Separa la lectura masiva de la edición de precisión |
| Límite de presupuesto Thinking | 20% – 35% | Baja (configuración) | Bajo-Medio | Evita bucles innecesarios de razonamiento extenso |
| Parches anclados por líneas | 15% – 25% | Baja (indicación) | Bajo | Sustituye la reescritura total por parches diff |
| Alineación de Prompt Cache | 10% – 20% (Coste) | Media | Cero | Congela prefijos estáticos para lograr el 90% de descuento |
10. Conclusión y lista de verificación en 5 pasos
Reducir el consumo de tokens en Claude Code un 75% no implica comprometer la calidad del código. De hecho, un contexto limpio y enfocado previene la pérdida de atención y las alucinaciones, mejorando la precisión del modelo.
Lista de acción inmediata en 5 pasos:
- [ ] Implementa
.claudeignore: Añade la plantilla de producción a la raíz de tu proyecto para descartar lockfiles y builds. - [ ] Ajusta
config.json: Limita los tokens de pensamiento a2048y activaautoCompactContexten0.65. - [ ] Selecciona el modelo idóneo: Utiliza
claude-3-7-sonnetpara programar,claude-3-5-haikupara explorar y reserva el razonamiento extendido para bugs críticos. - [ ] Restringe salidas de consola: Añade flags como
--reporter=mino filtrado con grep para que los logs de shell no superen las 100 líneas. - [ ] Limpia el contexto con regularidad: Emplea
/compacto/clearentre tareas para erradicar el Context Rot.
Al adoptar estas prácticas en tu rutina en la terminal, mantendrás todo el potencial de los agentes autónomos reduciendo drásticamente tus facturas mensuales de la API.