Como reduzir tokens no Claude Code pedindo o diff em vez do arquivo inteiro

O caro não é o que você digita, é o que o Claude te devolve

Fala aí, beleza? Se liga nisso: no Claude Sonnet 5 o token de saída custa 5x o token de entrada, US$ 2 por milhão na entrada contra US$ 10 por milhão na saída

Ou seja: o pedido é barato, a RESPOSTA é cara

E a mesma tarefa pode sair barata ou cara dependendo só do formato que você pede de volta. Quando você diz "me devolve o arquivo completo já corrigido", o modelo reescreve 300 linhas pra mudar 4, e você paga cada uma dessas linhas no preço de saída

É o pior formato possível, e é justamente o que a maioria pede sem pensar

Bora ver como formular o pedido pra receber só o que mudou?

Antes de começar: como enxergar seu gasto de saída

Antes de mexer em qualquer configuração, tenha na mão de onde vem o número. Sem isso tu muda dez coisas e não sabe qual delas funcionou

São três lugares:

• /cost mostra o gasto acumulado da sessão atual no Claude Code (disponível quando você usa chave de API)
• /usage, no bloco Session do topo, traz o detalhamento de tokens da sessão atual
• na API, o campo usage.output_tokens_details.thinking_tokens separa quanto da saída faturada foi raciocínio interno

Tome cuidado com um detalhe do /usage: a cifra em dólar ali é uma estimativa calculada localmente, e pode divergir da fatura. A cobrança oficial fica na página Usage do Claude Console

E por que o campo de thinking importa tanto aqui?

Porque os tokens de raciocínio são faturados como tokens de SAÍDA, mesmo quando o texto do raciocínio não volta pra você. Eles também contam dentro do max_tokens, que é um teto duro sobre a saída total (raciocínio mais texto da resposta, tudo no mesmo balde)

Então "resposta curta" não é só o que aparece na tela, beleza? 🙂

Pré-inscrição Formação Claude Code

Domine o Claude Code do básico ao avançado

Você vai aprender a criar sistemas completos com Claude Code, sem precisar ser programador. Inscreva-se para ter acesso a um desconto de lançamento e bônus especiais!

Quero minha vaga

Passo a passo: como pedir só o que mudou

1. Seja específico no pedido. Pedido vago dispara varredura ampla: o Claude sai lendo arquivo atrás de arquivo pra descobrir o que você quis dizer. A própria documentação de custos contrasta os dois extremos, "improve this codebase" (vago) contra "add input validation to the login function in auth.ts" (específico)

# vago: vira varredura no projeto todo
melhora esse projeto

# específico: leitura mínima, resposta mínima
adicione validação de entrada na função de login em auth.ts

O erro comum deste passo: achar que ser vago "dá liberdade pro modelo". Dá liberdade pra ele ler o que não precisava, e leitura vira contexto que você carrega no resto da sessão

2. Peça edição cirúrgica em vez de reescrita. A ferramenta Edit do Claude Code faz substituição exata de trecho: recebe old_string e new_string, troca um pelo outro e preserva o resto do arquivo. Já o Write sobrescreve o arquivo inteiro. Pra mudança pontual em arquivo que já existe, a orientação é usar o Edit, que envia apenas o diff

Altere só o trecho necessário com Edit, sem reescrever o arquivo
Não me devolva o arquivo completo na resposta

O erro comum deste passo: old_string ambíguo. Quando o trecho aparece mais de uma vez no arquivo, o Edit exige contexto extra pra fixar a ocorrência certa, ou o parâmetro replace_all: true pra trocar todas de uma vez. Vale a mesma lógica de pedir refatoração sem reescrita completa: quanto mais preciso o alvo, menos texto volta

3. Entenda o read-before-edit. O Claude Code exige a leitura do arquivo na conversa atual antes de editar: sem um Read prévio na mesma conversa, o Edit fica bloqueado

Isso significa que sempre vai ter leitura, a pergunta é QUANTA. Se você aponta o caminho exato, ele lê um arquivo. Se você diz "acha onde está o bug do login", ele lê meia dúzia até achar

O erro comum deste passo: brigar com a regra em vez de usar ela a favor. Diga o arquivo, e a leitura para de ser exploração

4. Controle o formato da resposta com output style. Os output styles injetam instruções no system prompt do Claude Code e servem exatamente pra isso: mudar verbosidade e formato da resposta, sem mexer no que o Claude pode fazer

Um estilo customizado é um arquivo Markdown com frontmatter, salvo em ~/.claude/output-styles (nível usuário) ou em .claude/output-styles (nível projeto). O nome do arquivo vira o nome do estilo, a não ser que você preencha o campo name

---
name: Diff Only
description: Respostas enxutas, sem reescrever arquivo inteiro
keep-coding-instructions: true
---

Ao alterar código existente, use edição pontual e não reescreva o arquivo
Na resposta, mostre apenas o trecho alterado e uma linha de justificativa
Não repita na mensagem o conteúdo que já foi gravado no arquivo
Não narre o passo a passo do seu raciocínio

O campo keep-coding-instructions preserva as instruções de engenharia de software embutidas do Claude Code e vem desligado por padrão (false). Os outros campos do frontmatter são name, description e force-for-plugin (esse último só para estilos de plugin)

Pra ativar: use o /config ou edite o campo outputStyle no arquivo de settings. O comando /output-style foi descontinuado na v2.1.73 e removido na v2.1.91, então esquece ele

O erro comum deste passo: esperar efeito imediato. O output style faz parte do system prompt, que é lido uma única vez no início da sessão, então a mudança só vale depois de um /clear ou de uma sessão nova

E já que estamos falando de verbosidade por opção: o estilo embutido Explanatory faz o Claude narrar decisões e explicar padrões enquanto trabalha, e o Learning conduz você pela mudança. São ótimos pra aprender, mas geram MAIS texto, e texto gerado é token de saída

5. Corte o raciocínio quando ele não paga. Pra modelos com orçamento fixo de raciocínio, dá pra baixar o teto por variável de ambiente. E existe variável própria pra limitar o tamanho da saída de ferramentas MCP, que costuma ser um despejo generoso de JSON

export MAX_THINKING_TOKENS=8000
export MAX_MCP_OUTPUT_TOKENS=8000

Atenção na migração: o Claude Sonnet 5 vem com raciocínio adaptativo (adaptive thinking) ligado por padrão, então carga que rodava sem thinking no Sonnet 4.6 precisa ter o max_tokens revisto

E o teto de saída por resposta muda por modelo: 128.000 tokens no Sonnet 5, 64.000 no Sonnet 4.6 e no Haiku 4.5. Se você já se perguntou por que a resposta para antes da janela, é esse teto agindo

O erro comum deste passo: cortar raciocínio em tarefa difícil e pagar duas vezes, porque aí vem resposta ruim e você reformula tudo de novo

6. Limpe a conversa ao trocar de tarefa. Uma sessão longa em que o Claude leu muitos arquivos e produziu muitos diffs carrega tudo isso a cada nova mensagem, e é daí que vem tanto o custo quanto o estouro de contexto

/clear

A orientação oficial é direta: limpar a conversa ao trocar de tarefa é a alavanca mais eficaz pra custo E pra qualidade

O erro comum deste passo: manter a sessão da manhã inteira aberta "porque ele já conhece o projeto". Ele não conhece, ele relê tudo, toda vez

Quando o diff resolve e quando ainda vale pedir o arquivo inteiro

Diff não é dogma, é escolha por cenário

Mudança pontual em arquivo existente: o Edit vence sem discussão. Troca exata de trecho, o resto do arquivo nem aparece na resposta

Arquivo novo do zero: aqui o Write é o caminho mesmo. Não existe "só o que mudou" quando tudo é novo, e forçar diff nesse caso só complica

Refatoração ampla: antes de disparar, limpe o contexto e pense em qual modelo vai carregar a tarefa. Contexto sujo em tarefa grande é o combo mais caro que existe

Lote assíncrono: a Message Batches API cobra 50% do preço padrão da API, e esse desconto empilha com o do cache de prompt. Se o trabalho não precisa de resposta agora, é dinheiro na mesa

Falando em cache: ele barateia SÓ a entrada. A leitura de cache custa 0,1x o preço base do token de entrada e a escrita de cache de 5 minutos custa 1,25x. Repara no efeito colateral: quanto melhor seu cache, MAIOR fica a distância entre o custo do pedido e o custo da resposta

Escolha de modelo: o Sonnet é o padrão do Claude Code e a escolha certa pra maior parte do trabalho de código. O Opus entra em problema mais difícil, com raciocínio mais profundo

A proporção de 5x entre saída e entrada se repete em todos eles, então a lógica do diff vale igual em qualquer um

Só fica esperto com o modo rápido (fast mode) do Opus 5: ele tem preço próprio, o dobro do padrão, US$ 10 na entrada e US$ 50 na saída. Nesse cenário, resposta verborrágica dói de verdade

Ah, e um detalhe que confunde muita gente: o preço de US$ 2 / US$ 10 do Sonnet 5 foi anunciado no lançamento como introdutório até 31/08/2026, mas virou o preço padrão

O que eu vi na prática ao apertar o gasto de saída

Agora o contraponto honesto, porque eu testei uma ferramenta que promete comprimir esse tráfego e o número que apareceu na MINHA tela foi bem mais modesto que o do título

A instalação já rendeu história: tentei pelo PowerShell e apareceu erro em várias tentativas, aí parti pro WSL e foi o caminho que funcionou (e o mais fácil pra mim). Rodei o comando de instalação por lá e vale o aviso: na primeira máquina de quem instala, a coisa demora mais que na minha, que já tinha tudo baixado

Depois de instalar, o comando não era reconhecido. Tive que fechar e reabrir o terminal, porque o atalho só é criado nesse momento, então não estranha se não pegar de primeira

Com tudo de pé, usei o modo que envolve a ferramenta (wrap) apontando pro Claude Code, e o Claude subiu já com a camada de compressão ativa

Pra gerar tráfego de verdade, mandei um prompt pesado de propósito: pedi uma varredura no projeto inteiro atrás de todos os lugares que lidam com autenticação

Detalhe prático: o terminal onde roda o wrap fica ocupado, então abri um segundo terminal só pra monitorar o consumo enquanto o agente trabalhava

Nesse segundo terminal rodei o comando de relatório de performance e li ali quantos tokens trafegaram e quantos foram economizados, com quebra por modelo

O número medido: cerca de 5%, quase 6% de redução

Longe do que o título prometia, né? 😅

Mas teve coisa interessante no meio. A economia não vem só do prompt inicial: as idas e vindas do agente, cada retorno de busca que volta pro modelo, também entram na conta comprimidas. É exatamente o tipo de tráfego que ninguém enxerga

Testei também o comando de aprendizado com a flag de tudo e, sem a flag de aplicar, ele só EXIBE o que escreveria: é uma prévia somente leitura. Rodei de novo com a flag de aplicar e mostrei o conteúdo escrito de fato no CLAUDE.md e no arquivo de memória do projeto, com os aprendizados extraídos da sessão

Minha leitura no fim: ferramenta promissora e fácil de acoplar ao Claude Code, mas a porcentagem depende da carga de uso e do tipo de conteúdo enviado. Um prompt isolado não representa o ganho real, e a economia relevante só aparece em sessões longas e com conteúdo que comprime bem, tipo JSON e imagem

Eu dei só uma introdução aos modos e componentes pra não deixar o vídeo pesado, então recomendo que cada um leia a documentação do projeto pra explorar o resto

E é isso que separa o marketing do resultado: o quanto você economiza depende do quanto você já estava gastando errado

No vídeo acima tu vê a instalação travando no Windows, o wrap ligado no Claude Code, o prompt pesado rodando e o relatório de tokens em tempo real no segundo terminal

Próximo passo: meça antes de mudar tudo

Não sai reconfigurando o mundo hoje, faz o teste na ordem:

1. rode /cost ou olhe o bloco Session do /usage na sua sessão atual, só pra ter um piso
2. pegue UMA tarefa e aplique só duas coisas: pedido específico (arquivo e função nomeados) e edição pontual com Edit, sem reescrita
3. compare o gasto com o piso que você anotou
4. só depois disso monte o seu output style próprio, lembrando que ele só vale após /clear ou sessão nova

O resto é consequência da mesma ideia: no Sonnet 5, no Opus 5 e no Haiku 4.5 a saída custa 5x a entrada, então quem manda na conta é o tamanho da resposta, não o capricho do seu prompt

O pedido é barato

A resposta é cara

Pede o diff 🙂

até o próximo post!