Como reduzi os tokens do Codex de 245M para 28M por dia gratuitamente (mantendo a mesma velocidade)

Depois que a promoção do Codex terminou e os limites reais começaram, eu vi meus limites de consumo diário do Codex reduzirem rapidamente.

Então encontrei um sistema para reduzir a quantidade de tokens que gasto sem afetar a velocidade.

Um dia: 245 milhões de tokens

No dia seguinte, depois de ajustar meu sistema: 28 milhões

Aqui está exatamente o que mudei:

Passo 1: Nunca Alimente Dados Brutos, Sempre Pré-Compacte Primeiro

O Codex não precisa do seu log de trades de 40 MB, de um dump massivo de JSON de mercado ou do repositório completo a cada iteração. Agora eu faço com que ele gere scripts auxiliares únicos que criam "mapas de agulhas":

• compact_logs.py → filtra por timestamp/símbolo/palavra-chave e exibe apenas as N principais anomalias
• summarize_data.py → extrai colunas relevantes, contagens de linhas, amostras e estatísticas chave
• repo_map.py → constrói uma visão geral limpa dos pontos de entrada, configuração, fluxos principais (pulando venv, node_modules, builds, etc.)

Alimente com 200-500 tokens de insight destilado em vez de 10k+ de ruído.

Construa uma vez, reutilize para sempre.

Passo 2: Limite Agressivamente Cada Saída de Comando

A saída padrão é letal:

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

pode explodir o contexto instantaneamente.

Agora eu incorporo limites em cada instrução:

1head -n 50, tail -n 50, grep "ERROR" | head -n 30
2
3Escreva os resultados completos em arquivos temporários e inspecione apenas intervalos
4
5Adicione --limit 100 em todos os lugares

Passo 3: Construa um Arquivo de Transferência Vivo (O Cérebro do Seu Projeto)

Pare de deixar os agentes redescobrirem tudo a cada sessão.

Eu mantenho um HANDOFF.md enxuto (abaixo de 1k tokens) que contém:

• Objetivo atual + métricas de sucesso
• Arquivos chave e decisões recentes
• Comandos já executados + resultados
• Problemas conhecidos e lista de "não releia"
• Próximos passos

Termine cada sessão com: "Compacte as descobertas atuais no HANDOFF.md, remova becos sem saída, mantenha apenas fatos acionáveis."

Passo 4: Instruções Explícitas de "Não Fazer" Economizam Muitos Tokens

Agentes adoram vagar, então eu estabeleço limites rígidos:

• "Pule node_modules, .venv, dist, logs/archive, arquivos gerados e qualquer diretório de cache"
• "Resuma antes de abrir qualquer arquivo novo"
• "Nunca cole o código fonte completo a menos que eu peça explicitamente"
• "Inspecione apenas os arquivos necessários para esta tarefa exata"

Coloque isso no seu AGENTS.md uma vez e veja as releituras despencarem.

Passo 5: Exija Resumos, Diffs e Snippets

Prompt ruim:

1Leia este arquivo e explique-o.

Prompt bom:

1Localize a lógica de dimensionamento de posição do motor de risco. Mostre apenas essa função + 3 linhas acima/abaixo. Explique o caso extremo em um parágrafo.

Ou

1Construa um mapa de repositório de 1 página: pontos de entrada, configuração, principais fluxos de dados e comandos de backtest. Pule diretórios de fornecedores.

Perguntas direcionadas = janelas de contexto pequenas

Passo 6: Faça o Codex Compactar Seu Próprio Contexto Periodicamente

A cada 4-5 iterações, eu coloco:

1Resuma nosso progresso em uma nota de transferência enxuta. Remova repetições e caminhos com falha. Mantenha apenas o necessário para continuar.

A conversa permanece enxuta mesmo enquanto cresce.

Passo 7: Elimine a Verbosidade por Padrão

1Seja conciso. Produza apenas o patch + uma frase de motivo. Não repita o plano a menos que tenha mudado. Sem enrolação.

Só esta regra já reduz drasticamente os tokens de saída.

Comandos Úteis e Scripts Auxiliares que Uso Diariamente

Estes são exatamente os one-liners e scripts que copio e colo ou peço ao Codex para gerar no primeiro dia de qualquer projeto.

Comandos de limitação essenciais que forço em toda chamada de ferramenta:

1# Inspeção segura de arquivos
2head -n 80 somefile.py | cat
3tail -n 80 somefile.py | cat
4grep -n "PALAVRA_CHAVE" file.py | head -n 40
5
6# Git sem excesso de informações
7git status --porcelain | head -n 30
8git log --oneline -15
9git diff --name-only | head -n 20
10
11# Dados e logs (específico para trading)
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# Padrão escreva-depois-inspecione
16python analyze_backtest.py > temp_results.txt 2>&1
17head -c 8000 temp_results.txt   # limite de bytes para segurança

**

Scripts auxiliares que sempre peço ao Codex para criar primeiro (e depois executo eu mesmo):**

• compact_logs.py → python compact_logs.py --symbol BTC --hours 24 > summary.txt
• repo_map.py → python repo_map.py > HANDOFF.md (atualiza o arquivo cérebro)
• scan_errors.py → python scan_errors.py --limit 30 > errors.txt
• summarize_json.py → python summarize_json.py market_snapshot.json > needle.txt

Uma regra matadora do AGENTS.md pela qual vivo (limite por bytes tudo que for desconhecido):

1## Proteção de Saída de Comando
2Qualquer comando com saída desconhecida ou potencialmente grande DEVE ter limite de bytes.
3Padrão: COMMAND 2>&1 | head -c 6000
4Se precisar de mais, escreva em arquivo temporário e inspecionarei apenas intervalos.

Modelo de prompt que reutilizo para tarefas com muitos dados:

1Primeiro execute compact_logs.py ou summarize_data.py para criar um mapa de agulhas com <500 tokens. Depois analise apenas isso. Nunca leia o arquivo bruto diretamente.

Esses comandos e scripts, por si só, reduzem meu consumo diário em mais 30-40%, além das grandes mudanças no fluxo de trabalho.

**Minha Nova Regra Geral

Não deixe o Codex ler dados brutos se um resumo de 50 linhas for suficiente**

Os auxiliares que construí na primeira semana se pagam a cada hora.

Eficiência de tokens não era um problema do modelo, mas sim um problema de sistemas. Basta acertar a disciplina de contexto e você fará 8 a 10 vezes mais dentro do mesmo limite.

Também construí www.RedLeads.app para encontrar usuários para as coisas que entrego mais rápido. Junte-se a mim na corrida para $10k MRR criando sistemas e ferramentas legais com vibecoding.

Obrigado :)