Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Quando um desenvolvedor júnior ou iniciante que cria produtos sozinho conecta o Claude Code a uma base de código legado gigantesca, o orçamento de tokens se esgota em menos de uma hora. Não há desenvolvedores seniores na empresa para consultar e, após aprender apenas os comandos básicos de CLI, você abre o terminal e continua recebendo notificações de cobrança no cartão.
O Claude Code não armazena o estado da conversa no servidor. O prompt do sistema, o arquivo de configuração do projeto CLAUDE.md, o histórico de conversas acumulado e os resultados de chamadas de ferramentas são empacotados em um único payload a cada turno e reenviados para a API da Anthropic. Logo no início da sessão, nos primeiros 1 ou 2 turnos, o consumo fica em torno de 15.000 tokens, mas assim que o agente começa a explorar e lê artefatos de build ou dezenas de milhares de linhas de log, o payload dispara para 80.000 tokens. Passando de 6 a 10 turnos, cada turno oscila entre 120.000 e 200.000 tokens. É uma estrutura onde o custo é cobrado de forma composta a cada turno.
Olhando para os custos oficiais de cache de prompt da Anthropic, a causa fica ainda mais clara. Se o mesmo contexto de prefixo for mantido, você paga apenas 10% do custo em comparação com os tokens de entrada básicos. Por outro lado, se o agente ler de forma irregular dezenas de milhares de linhas de código e quebrar o prefixo do cache, um custo de criação de cache de 1,25x com base em um TTL de 5 minutos será aplicado novamente. Essa é a razão pela qual, após apenas algumas buscas, tarifas difíceis de arcar sozinho começam a aparecer.
Muitos desenvolvedores criam um arquivo .claudeignore no diretório raiz e ficam tranquilos. Começando pela conclusão, tal arquivo de configuração não existe no motor CLI oficial do Claude Code. A abordagem de escrever "Não leia a pasta de logs" no CLAUDE.md também é ignorada pelo modelo caso ele decida que precisa da informação.
Para cortar fisicamente o acesso do agente a arquivos a nível de motor, você deve usar a configuração permissions.deny no arquivo .claude/settings.json.
Primeiro, agrupe os artefatos de build e arquivos de segurança no .claude/settings.json na raiz do projeto.
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 o comportamento de coletar código de frontend aconteça ao ajustar a lógica de backend, mantenha uma configuração exclusiva local chamada .claude/settings.local.json separadamente.
json { "permissions": { "deny": [ "Read(apps/web/**)", "Read(frontend/**)", "Read(public/**)", "Edit(apps/web/**)", "Write(apps/web/**)" ] } }
Você também deve impedir que o agente despeje logs grandes inteiros no terminal usando comandos de shell como cat ou head. Adicione um gancho PreToolUse no .claude/settings.json para interceptar os comandos antecipadamente.
json { "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [ { "type": "command", "command": "bash", "args": ["${CLAUDE_PROJECT_DIR}/.claude/hooks/block-large-reads.sh"] } ] } ] } }
Crie o arquivo .claude/hooks/block-large-reads.sh e dê permissão de execução com 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 "A saída direta de arquivos grandes foi detectada e a execução foi interrompida." >&2
exit 2
fi
exit 0
`
Retornar o código de saída 2 no nível de processo do SO interrompe imediatamente a saída de arquivos do agente. O bloqueio de varreduras de arquivos desnecessárias reduz o consumo de tokens dos turnos iniciais em mais da metade.
Se você permitir que o arquivo inteiro seja reescrito só para alterar uma variável em um arquivo legado com mais de 1.000 linhas, bugs surgirão e os tokens de saída serão desperdiçados. Dentro do Claude Code, há uma divisão entre a ferramenta Write, que sobrescreve arquivos, e a ferramenta Edit, que substitui apenas blocos específicos de texto.
As regras de modificação devem ser gravadas no CLAUDE.md na raiz do projeto.
`markdown
Em vez de passar arquivos grandes inteiros para o agente, é melhor extrair apenas a função alvo. Este é um script de shell (extract-func.sh) que usa a ferramenta de análise 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
`
Envie apenas a função extraída ou o git diff em staging no modo headless (claude -p) para solicitar modificações.
`bash
./extract-func.sh src/billing.js processRefund | claude -p "Exiba apenas o bloco de código alternativo (new_string) para o Edit que corrigiu o erro de cálculo na função acima."
git diff --staged src/services/OrderService.js | claude -p "Aponte apenas falhas de concorrência ou potenciais referências nulas que possam ocorrer neste diff."
`
Ao inserir apenas fatias de 50 a 100 linhas como entrada em vez de todo o código-fonte, você pode reduzir o consumo de tokens por turno em quase 90%.
Não há motivo para prolongar o trabalho por muito tempo em uma única sessão. Quanto mais o histórico de conversas se acumula, maior se torna a tarifa básica cobrada a cada turno. O modelo Claude oferece suporte a /autocompact, que resume automaticamente o histórico de conversas ao atingir cerca de 967.000 tokens, mas é comum que o sistema elimine parâmetros importantes ou contextos de casos de borda durante o processo de enxugamento do código. Você mesmo deve limpar o contexto.
Verifique o estado atual no terminal usando três comandos integrados:
/context: Visualiza a proporção de memória ocupada pelo prompt do sistema e pelo histórico de conversas./usage: Confere o uso de tokens da sessão e a taxa de esgotamento do limite do plano./cost: Verifica o custo real em dólares acumulado até a sessão atual.Se os tokens ultrapassarem 100.000 ou se uma unidade específica de trabalho for concluída, instrua o Claude Code a criar o HANDOFF.md antes de fechar a sessão.
text Registre o estado de trabalho da sessão atual no HANDOFF.md na raiz do projeto com o seguinte formato: Goal: Objetivo do trabalho e módulo alvo Current Progress: Arquivos modificados e linhas específicas What Worked: Lógica cuja validação foi concluída e testes aprovados What Failed: Abordagens que falharam e precauções Immediate Next Step: Tarefa única que deve ser executada imediatamente no início da próxima sessão
Assim que o registro for concluído, limpe a janela de contexto com o comando /clear. Abra uma nova sessão e repasse apenas o resumo da sessão anterior.
text Leia o arquivo HANDOFF.md e continue o trabalho a partir do item Immediate Next Step. Não tente as abordagens que falharam anteriormente.
Se começar a girar em círculos com o mesmo erro 3 vezes ou mais, você deve pressionar imediatamente a tecla Escape para parar. Se for uma situação em que é difícil limpar totalmente a sessão, volte para o turno anterior que funcionava normalmente usando /rewind. Como o /rewind preserva o cache do prompt de prefixo do sistema estabelecido, você retorna à ramificação normal sem pagar custos adicionais de gravação de cache.
| Camada de Defesa | Local de Configuração | Nível de Controlo | Efetividade Prática na Redução de Tokens |
|---|---|---|---|
| Filtragem de arquivos do harness | .claude/settings.json (permissions.deny) |
Forçado pelo motor CLI | Bloqueio de 50% a 80% dos tokens de varredura inicial por sessão |
| Barreira de comandos de shell | Hook PreToolUse (block-large-reads.sh) |
Bloqueio de processos do SO (Exit 2) | Defesa de 100% contra grandes saídas de logs e arquivos de bundle |
| Fatiamento de contexto | Pipeline ast-grep, git diff |
Limitação do escopo de entrada | Redução de 90% dos tokens por turno de análise e modificação de arquivos |
| Gestão da vida útil da sessão | /context, /clear, HANDOFF.md |
Persistência manual de estado | Redução de mais de 60% nas cobranças de tokens compostos acumulados no final da sessão |
Bloquear caminhos desnecessários com .claude/settings.json e seguir a regra de passar apenas código fatiado em vez de arquivos grandes são práticas indispensáveis para rodar o Claude Code como uma ferramenta de desenvolvimento real em um ambiente de desenvolvedor solo.