Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Cuando un desarrollador junior o con menos de un año de experiencia que trabaja en solitario integra Claude Code en una base de código heredada enorme, el presupuesto de tokens se agota en menos de una hora. Sin seniors en la empresa a quienes consultar y tras haber aprendido únicamente los comandos básicos de CLI, abre la terminal solo para seguir recibiendo notificaciones de cargos en su tarjeta.
Claude Code no almacena el estado de la conversación en el servidor. El aviso del sistema (system prompt), el archivo de configuración del proyecto CLAUDE.md, el historial acumulado de la conversación y los resultados de las llamadas a herramientas se empaquetan en una sola carga útil (payload) en cada turno y se envían de vuelta a la API de Anthropic. En los 1 o 2 turnos posteriores al inicio de la sesión, se mantiene en torno a los 15,000 tokens, pero en el momento en que el agente comienza a explorar y lee artefactos de compilación o registros de decenas de miles de líneas, la carga útil se infla hasta los 80,000 tokens. Si supera los 6 a 10 turnos, en cada turno circulan entre 120,000 y 200,000 tokens. Es una estructura en la que los costos se cobran de forma compuesta en cada turno.
Si observamos los precios oficiales de Anthropic para el almacenamiento en caché de prompts (prompt caching), la causa se vuelve aún más clara. Si se mantiene el mismo contexto de prefijo, solo es necesario pagar el 10% del costo en comparación con los tokens de entrada básicos. Por el contrario, si el agente lee de forma irregular decenas de miles de líneas de código y se rompe el prefijo de la caché, se aplica un costo nuevo de creación de caché de 1.25 veces con base en un TTL de 5 minutos. Esta es la razón por la cual, con solo realizar un par de búsquedas, se registran tarifas difíciles de asumir en solitario.
Son muchos los desarrolladores que se sienten tranquilos tras crear un archivo .claudeignore en el directorio raíz. Dicho sin rodeos: en el motor CLI oficial de Claude Code no existe un archivo de configuración de ese tipo. El método de escribir "No leer la carpeta de registros" en CLAUDE.md también es ignorado por el modelo si este determina que lo necesita.
Para cortar físicamente el acceso del agente a los archivos desde el nivel del motor, se debe utilizar la configuración permissions.deny del archivo .claude/settings.json.
Primero, agrupa los artefactos de compilación y los archivos de seguridad en .claude/settings.json en la raíz del proyecto.
json { "permissions": { "deny": [ "Read(./.env*)", "Read(./secrets/**)", "Read(**/node_modules/**)", "Read(**/dist/**)", "Read(**/build/**)", "Read(**/coverage/**)", "Read(**/target/**)", "Read(**/*.log)", "Read(**/*.map)", "Read(legacy-backups/**)", "Edit(**/dist/**)", "Write(**/dist/**)" ], "ask": [ "Bash(git push *)", "Bash(npm publish)", "Bash(rm -rf *)" ], "allow": [ "Read", "Edit", "Bash(npm test)", "Bash(npm run lint)", "Bash(git status)", "Bash(git diff *)" ] } }
Para evitar que se arrastre el código del frontend al retocar la lógica del backend, se deja por separado una configuración exclusiva para entorno local llamada .claude/settings.local.json.
json { "permissions": { "deny": [ "Read(apps/web/**)", "Read(frontend/**)", "Read(public/**)", "Edit(apps/web/**)", "Write(apps/web/**)" ] } }
También se debe evitar que el agente vuelque registros grandes completos en la terminal utilizando comandos de shell como cat o head. Se intercepta el comando de antemano configurando un gancho PreToolUse en .claude/settings.json.
json { "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [ { "type": "command", "command": "bash", "args": ["${CLAUDE_PROJECT_DIR}/.claude/hooks/block-large-reads.sh"] } ] } ] } }
Crea el archivo .claude/hooks/block-large-reads.sh y otórgale permisos de ejecución con chmod +x.
`bash
#!/usr/bin/env bash
PAYLOAD=(echo "$PAYLOAD" | jq -r '.tool_input.command // empty')
if echo "$COMMAND" | grep -Eq '(cat|head|tail|less)\s+.*(.log|.map|.lock|dist/|build/)'; then
echo "Se detectó la salida directa de un archivo grande y se detiene la ejecución." >&2
exit 2
fi
exit 0
`
Si se devuelve un código de salida (exit code) 2 a nivel de proceso del sistema operativo, la salida de archivos del agente se detiene de inmediato. Al bloquear el escaneo innecesario de archivos, el consumo de tokens en los turnos iniciales se reduce a menos de la mitad.
Si se permite que se reescriba por completo un archivo heredado de más de 1,000 líneas solo para cambiar una variable, surgirán errores y también se desperdiciarán tokens de salida. Dentro de Claude Code, se distinguen la herramienta Write, que sobrescribe archivos, y la herramienta Edit, que reemplaza únicamente un bloque de cadena específico.
Deben establecerse reglas de modificación dentro de CLAUDE.md en la raíz del proyecto.
`markdown
En lugar de pasar archivos grandes enteros al agente, es mejor extraer únicamente la función objetivo. Este es un script de shell (extract-func.sh) que utiliza la herramienta de análisis AST ast-grep.
`bash
#!/usr/bin/env bash
TARGET_FILE=2
if [ -z "FUNC_NAME" ]; then
echo "Uso: ./extract-func.sh " >&2
exit 1
fi
if command -v sg &> /dev/null; then
sg run --pattern "function TARGET_FILE"
else
LINE_START=TARGET_FILE" 2>/dev/null | grep -w "$FUNC_NAME" | awk '{print 3}')
if [ -n "LINE_START" ]; then
sed -n "((LINE_START + 100))p" "$TARGET_FILE"
else
grep -n -A 60 "function TARGET_FILE"
fi
fi
`
Pásale únicamente la función extraída o el git diff preparado en modo headless (claude -p) para solicitar modificaciones.
`bash
./extract-func.sh src/billing.js processRefund | claude -p "Imprime únicamente el bloque de código de reemplazo (new_string) para Edit que soluciona el error de cálculo de la función anterior."
git diff --staged src/services/OrderService.js | claude -p "Señala únicamente los posibles defectos de concurrencia o referencias nulas que puedan ocurrir en este diff."
`
Si en lugar de todo el código fuente se introducen como entrada únicamente porciones de 50 a 100 líneas, se puede reducir el consumo de tokens por turno cerca de un 90%.
No hay razón para alargar innecesariamente el trabajo en una sola sesión. Cuanto más se acumula el historial de conversaciones, más aumentan los costos básicos obligatorios por cada turno. El modelo Claude admite /autocompact, que resume por sí mismo el historial de conversaciones cuando alcanza unos 967,000 tokens, pero en el proceso en que el sistema reduce el código, es común que se descarten parámetros importantes o contextos de casos límite (edge cases). Es necesario vaciar el contexto manualmente.
Verifica el estado actual en la terminal con tres comandos integrados:
/context: Permite ver la proporción de memoria que ocupan el prompt del sistema y el historial de conversación./usage: Permite comprobar el uso de tokens de sesión y la tasa de consumo del límite del plan./cost: Revisa el costo acumulado real en dólares hasta la sesión actual.Si los tokens superan los 100,000 o se ha completado una unidad de trabajo específica, indícale a Claude Code que redacte un HANDOFF.md antes de cerrar la sesión.
text Registra el estado de trabajo de la sesión actual en HANDOFF.md en la raíz del proyecto con el siguiente formato: Goal: Objetivo de trabajo y módulo objetivo Current Progress: Archivos modificados y líneas específicas What Worked: Lógica cuya verificación se completó y pruebas superadas What Failed: Enfoques que fallaron y precauciones Immediate Next Step: Tarea única que debe ejecutarse inmediatamente al iniciar la próxima sesión
Una vez finalizado el registro, vacía la ventana de contexto con el comando /clear. Abre una nueva sesión y pasa únicamente el resumen de la sesión anterior.
`text
Lee el archivo HANDOFF.md y continúa el trabajo a partir del elemento Immediate Next Step. No intentes los métodos que fallaron anteriormente.
`
Si comienzas a dar vueltas en círculos con el mismo error más de 3 veces, debes presionar inmediatamente la tecla Escape para detenerlo. En una situación en la que no sea conveniente vaciar toda la sesión, regresa con /rewind al turno anterior en el que funcionaba correctamente. Como /rewind preserva la caché establecida del prompt de prefijo del sistema, puedes volver a la rama normal sin pagar costos adicionales de escritura en caché.
| Capa de defensa | Ubicación de configuración | Nivel de control | Efecto real de reducción de tokens |
|---|---|---|---|
| Filtrado de archivos harness | .claude/settings.json (permissions.deny) |
Forzado por CLI engine | Bloqueo del 50% al 80% de tokens de escaneo inicial por sesión |
| Cortafuegos de comandos shell | PreToolUse Hook (block-large-reads.sh) |
Bloqueo por proceso del SO (Exit 2) | Defensa del 100% ante volúmenes masivos de salida de registros y archivos bundle |
| Segmentación de contexto (Slicing) | Canalización de ast-grep, git diff |
Limitación de rango de entrada | Reducción del 90% de tokens por turno de análisis y modificación de archivos |
| Gestión de vida útil de la sesión | /context, /clear, HANDOFF.md |
Persistencia manual de estado | Reducción del 60% o más en cargos acumulados compuestos de tokens en la última fase de la sesión |
Es necesario bloquear rutas innecesarias con .claude/settings.json y seguir la regla de pasar únicamente código segmentado en lugar de archivos grandes para poder utilizar Claude Code como una herramienta de desarrollo real en un entorno de desarrollo unipersonal.