Cómo reduje los tokens de Codex de 245M a 28M por día gratis (con la misma velocidad)

Después de que terminó el promo de Codex y empezaron las cuotas reales, comencé a quemar mis límites diarios de Codex más rápido.

Así que encontré un sistema para reducir la cantidad de tokens que gasto sin afectar la velocidad.

Un día: 245 millones de tokens

Al día siguiente, después de afinar mi sistema: 28 millones

Esto es exactamente lo que cambié:

Paso 1: Nunca alimentes datos crudos, compáctalos primero

Codex no necesita tu archivo de 40 MB de trades, un dump masivo de JSON del mercado o el repo completo en cada turno. Ahora hago que genere scripts de una sola vez que crean "mapas de agujas":

• compact_logs.py → filtra por timestamp/símbolo/palabra clave y devuelve solo las N anomalías principales
• summarize_data.py → extrae las columnas relevantes, conteos de filas, muestras y estadísticas clave
• repo_map.py → construye una visión general limpia de puntos de entrada, configuración, flujos principales (saltando venv, node_modules, builds, etc.)

Aliméntalo con 200‑500 tokens de información destilada en lugar de 10k+ de ruido.

Constrúyelo una vez, úsalo para siempre.

Paso 2: Limita agresivamente la salida de cada comando

La salida por defecto es letal:

• git status
• ls -la
• cat file
• python script.py

puede explotar el contexto al instante.

Ahora pongo límites en cada instrucción:

1head -n 50, tail -n 50, grep "ERROR" | head -n 30
2
3Write full results to temp files and only inspect ranges
4
5Add --limit 100 flags everywhere

Paso 3: Construye un archivo de traspaso vivo (el cerebro de tu proyecto)

Deja que los agentes redescubran todo en cada sesión.

Mantengo un HANDOFF.md ajustado (menos de 1k tokens) que contiene:

• Objetivo actual + métricas de éxito
• Archivos clave y decisiones recientes
• Comandos ya ejecutados + resultados
• Problemas conocidos y lista "no releer"
• Próximos pasos

Termina cada sesión con: "Compacta los hallazgos actuales en HANDOFF.md, elimina callejones sin salida, conserva solo los hechos accionables."

Paso 4: Instrucciones explícitas de "no hacer" ahorran tokens masivos

A los agentes les encanta divagar, así que pongo límites duros:

• "Saltar node_modules, .venv, dist, logs/archive, archivos generados y cualquier directorio de caché"
• "Resumir antes de abrir cualquier archivo nuevo"
• "Nunca pegar el código fuente completo a menos que yo lo diga explícitamente"
• "Solo inspeccionar archivos necesarios para esta tarea exacta"

Ponlos en tu AGENTS.md una vez y mira cómo se reducen las relecturas.

Paso 5: Exige resúmenes, diffs y fragmentos

Prompt malo:

1Read this file and explain it.

Prompt bueno:

1Locate the risk engine’s position sizing logic. Show only that function + 3 lines above/below. Explain the edge case in one paragraph.

O

1Build a 1-page repo map: entry points, config, main data flows and backtest commands. Skip vendor dirs.

Preguntas específicas = ventanas de contexto pequeñas

Paso 6: Haz que Codex compacte su propio contexto periódicamente

Cada 4‑5 turnos suelto:

1Summarize our progress into a tight handoff note. Remove repetitions and failed paths. Keep only what’s needed to continue.

La conversación se mantiene ligera incluso cuando crece.

Paso 7: Elimina la verbosidad por defecto

1Be concise. Output only the patch + one-sentence reason. No restating the plan unless it changed. No fluff.

Solo esta regla ya reduce drásticamente los tokens de salida.

Comandos y scripts útiles que uso a diario

Estos son los comandos de una línea y scripts exactos que copio‑pego o pido a Codex que genere el primer día de cualquier proyecto.

Comandos limitantes que fuerzo en cada llamada a la herramienta:

1# Safe file inspection
2head -n 80 somefile.py | cat
3tail -n 80 somefile.py | cat
4grep -n "KEYWORD" file.py | head -n 40
5
6# Git without the firehose
7git status --porcelain | head -n 30
8git log --oneline -15
9git diff --name-only | head -n 20
10
11# Data & logs (trading-specific)
12tail -n 200 market_log.json | jq '.[-50:]' | head -n 100
13python -c "import pandas as pd; df = pd.read_csv('trades.csv'); print(df.head(20).to_string())" | head -n 150
14
15# Write-then-inspect pattern
16python analyze_backtest.py > temp_results.txt 2>&1
17head -c 8000 temp_results.txt   # byte cap for safety

Scripts auxiliares que siempre pido a Codex que cree primero (y luego los ejecuto yo):

• compact_logs.py → python compact_logs.py --symbol BTC --hours 24 > summary.txt
• repo_map.py → python repo_map.py > HANDOFF.md (actualiza el archivo cerebro)
• scan_errors.py → python scan_errors.py --limit 30 > errors.txt
• summarize_json.py → python summarize_json.py market_snapshot.json > needle.txt

Una regula matadora de AGENTS.md por la que vivo (limitación por bytes para todo lo desconocido):

1## Command Output Protection
2Any command with unknown or potentially large output MUST be byte-capped.
3Default: COMMAND 2>&1 | head -c 6000
4If more is needed, write to temp file and I will inspect ranges only.

Plantilla de prompt que reutilizo para tareas con muchos datos:

1First run compact_logs.py or summarize_data.py to create a <500-token needle map. Then analyze only that. Never read the raw file directly.

Estos comandos y scripts por sí solos reducen mi consumo diario otro 30‑40% además de los grandes cambios en el flujo de trabajo.

**Mi nueva regla general

No dejes que Codex lea datos crudos si un resumen de 50 líneas sería suficiente**

Los ayudantes que construí en la primera semana se pagan solos cada hora.

La eficiencia de tokens no fue un problema de modelo, sino un problema de sistemas. Solo domina la disciplina de contexto y lograrás 8‑10 veces más dentro de la misma cuota.

También construyo www.RedLeads.app para encontrar usuarios más rápido para lo que publico. Únete a mí para acelerar hasta los $10k MRR codeando sistemas y herramientas chéveres con vibecoding.

Gracias :)