Seu Time Gasta R$50K/Mês em AI Coding e Ninguém Sabe Onde o Token Vai? Dois Comandos Resolvem

Sua software house paga R$50K por mês em AI coding e ninguém sabe quanto cada modelo consome?

Vou ser direto: se você tem 20 devs usando Claude Code — seja via licenças Max a $200/mês cada ou API billing — você está gastando entre R$20K e R$60K por mês em tokens de IA.

E provavelmente não faz ideia de onde esse dinheiro vai.

Até a semana passada, o /cost do Claude Code mostrava um número total. Um. Um único número. “Total cost: $42.50”. Legal. Mas quanto disso foi Opus? Quanto foi Sonnet? Quanto foi cache hit a $0.30/MTok versus uncached a $3/MTok? Ninguém sabia.

A v2.1.92 mudou isso com duas features que, juntas, são o começo de um FinOps real dentro do terminal.

O problema: gasto invisível em escala

Vamos colocar em perspectiva.

A Anthropic divulga que o custo médio do Claude Code é $6 por dev por dia, com 90% dos usuários gastando menos de $12/dia. Parece razoável.

Mas essa é a média. A variância é absurda.

Um desenvolvedor que documentou 8 meses de uso acumulou 10 bilhões de tokens — mais de $15.000 em API pricing. Heavy users em billing por API chegam a $800+ por mês. Times rodando agent teams com 5 agentes paralelos queimam $50-100 por hora.

A Morph LLM analisou 42 sessões reais de coding agents e concluiu que 70% dos tokens são desperdício — processamento redundante, contexto desnecessário, retrabalho de compaction. Apenas 5-15% dos tokens vão para geração efetiva de código.

E o The Register reportou que a própria Anthropic admitiu que quotas do Claude Code estavam sendo consumidas “muito mais rápido que o esperado”.

Agora multiplica isso por 20 devs. Sem visibilidade. Sem breakdown. Sem alerta.

Na minha experiência com 300+ software houses, a maioria trata custo de IA como “a gente paga a licença e pronto”. Não existe FinOps. Não existe token economics. Não existe a pergunta: “quanto custa esse prompt?”.

O que mudou na v2.1.92: /cost com breakdown real

A v2.1.92 adicionou ao comando /cost o que deveria ter existido desde o dia um: breakdown por modelo e por cache hits.

Antes:

/cost
Total cost:            $42.50
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s

Agora, usuários de subscription (Teams/Enterprise/API) veem:

• Custo por modelo: quanto foi Opus 4.6, quanto foi Sonnet 4.6, quanto foi Haiku 4.5
• Cache hits separados: quanto do input foi servido pelo prompt cache (mais barato) versus uncached (preço cheio)
• Per-model + cache: a combinação que mostra exatamente onde está o gasto

Isso responde perguntas que antes eram impossíveis:

• “Esse dev está usando Opus para tarefas que Sonnet resolveria?” — Agora você vê
• “O prompt caching está realmente funcionando?” — A taxa de cache hit está ali
• “Quanto estou economizando com caching?” — A diferença entre o que pagou e o que pagaria sem cache

Para usar, basta digitar /cost no terminal do Claude Code. Sem configuração. Sem setup.

A segunda feature: cache expiry hint no footer

Essa é mais sutil, mas igualmente importante.

O prompt caching do Claude é o mecanismo que reduz custo de input tokens em até 90%. Quando você manda uma mensagem, o conteúdo estável (system prompt, CLAUDE.md, contexto do projeto) é cacheado. Nas mensagens seguintes, esse conteúdo é servido do cache a $0.30/MTok ao invés de $3/MTok.

Mas o cache tem TTL — time to live. Ele expira.

E quando expira? Silenciosamente. Você vai almoçar, volta 30 minutos depois, manda um prompt. Parece igual. Mas aquele turno acabou de enviar 50K tokens sem cache, custando 10x mais do que o anterior.

A v2.1.92 resolve isso: Pro users agora veem um hint no footer quando retornam a uma sessão após o prompt cache ter expirado. O hint mostra aproximadamente quantos tokens o próximo turno vai enviar uncached.

Na prática, quando você vê esse hint, você tem uma decisão:

1. Continuar na sessão — sabendo que o próximo turno será mais caro (mas o cache se reconstrói automaticamente)
2. Usar /clear — limpar o contexto e começar mais leve se a sessão anterior não é mais relevante
3. Usar /compact — comprimir o contexto antes de enviar, reduzindo tokens enviados

Antes dessa feature, a decisão não existia porque você não sabia que o cache tinha expirado.

Por que prompt caching importa tanto para software houses

Vamos aos números.

Um cache hit no Claude custa 10x menos que um input uncached. E 12.5x menos que um cache write no TTL de 5 minutos.

Tipo	Custo (Sonnet 4.6)
Input uncached	$3.00/MTok
Cache write (5min TTL)	$3.75/MTok
Cache hit	$0.30/MTok
Output	$15.00/MTok

Você quebra o investimento do cache write com apenas 1 cache hit subsequente.

Na prática, sessions típicas do Claude Code atingem 92% de cache hit rate, resultando em 81% de redução de custo em input tokens. Mais de 90% de todos os tokens processados são cache reads.

Mas se o cache expira e ninguém percebe?

20 devs × sessões de 8 horas × pausa para almoço = 20 cache misses por dia onde 50K+ tokens são enviados a preço cheio. Em API billing, isso pode significar $10-30/dia extras que ninguém vê.

Em um mês: R$1.500-4.500 desperdiçados silenciosamente.

O cache expiry hint transforma esse gasto invisível em decisão consciente.

FinOps para IA: por que sua SH precisa começar agora

O State of FinOps 2026 da FinOps Foundation revelou que 98% dos times de FinOps agora gerenciam gasto com IA — em 2024, eram apenas 31%. O salto é brutal.

Mas gerenciar não significa ter visibilidade.

Segundo dados de Shadow AI em 2026:

• Mais de 80% dos trabalhadores usam ferramentas de IA não aprovadas
• Organizações sem governance centralizada têm 5x mais subscriptions redundantes de IA
• 34% do gasto com Shadow AI duplica ferramentas já aprovadas
• Apenas 30% das organizações têm visibilidade total de uso de IA
• Empresas com governance forte de IA economizam $287K por ano

Para software houses, o cenário é ainda pior. Cada dev escolhe seu modelo (/model), seu nível de effort (/effort), quantos subagents spawna, quais MCP servers conecta. A variância de custo entre dois devs fazendo a mesma tarefa pode ser 10x — um usa Haiku com effort low, outro usa Opus com extended thinking de 32K tokens.

Sem visibilidade per-model, você não consegue:

• Identificar quem está usando Opus para tarefas simples
• Medir se a política de “Sonnet para código, Opus para arquitetura” está sendo seguida
• Comparar custo-benefício real entre modelos para os tipos de task da sua SH

Quanto custa AI coding na sua software house?

Vamos fazer a conta que ninguém faz.

Cenário 1: Licenças Max ($200/mês)

• 20 devs × $200 = $4.000/mês = ~R$24.000/mês
• Custo fixo, sem variância
• Zero visibilidade de uso (quota é consumida, você só vê que acabou)
• /cost não é relevante para billing, mas mostra padrões de consumo

Cenário 2: API billing (pay-as-you-go)

• Média $6/dev/dia × 20 devs × 22 dias = $2.640/mês = ~R$16.000/mês
• Mas a variância: heavy users a $20/dia = $8.800/mês = ~R$53.000/mês
• /cost com breakdown mostra exatamente para onde vai cada dólar

Cenário 3: Bedrock/Vertex (enterprise)

• Pay-per-use com pricing de cloud
• Prompt caching até 90% savings
• AWS Cost Explorer + CloudTrail para auditoria
• /cost breakdown complementa com visão per-session

Em todos os cenários, a pergunta é a mesma: você sabe onde o dinheiro está indo?

Como usar na prática

1. Verifique sua versão

claude --version
# Precisa ser v2.1.92 ou superior

2. Use /cost durante a sessão

/cost

Agora mostra breakdown por modelo e cache hits. Rode no meio e no final de cada sessão para construir intuição de custo.

3. Observe o footer hint de cache

Quando voltar a uma sessão após pausa, preste atenção ao footer. Se aparecer o hint de tokens uncached, decida:

• /clear se a sessão não é mais relevante
• /compact para comprimir antes de continuar
• Continuar sabendo que o cache se reconstrói em 1-2 turnos

4. Configure o status line para custo contínuo

No settings.json:

{
  "statusLine": {
    "enabled": true,
    "items": ["context", "cost"]
  }
}

Isso mostra custo no status line permanentemente — sem precisar digitar /cost.

5. Otimize por modelo

Baseado no que o breakdown revelar:

Tarefa	Modelo recomendado	Por quê
Code generation, edits, tests	Sonnet 4.6	$3/$15 per MTok — bom equilíbrio
Arquitetura, planning complexo	Opus 4.6	$5/$25 per MTok — raciocínio superior
Subagents, tarefas simples	Haiku 4.5	Mais rápido e barato para delegação

Use /model para trocar mid-session. Configure default no /config.

6. Maximize prompt caching

O cache funciona melhor quando:

• System prompts e CLAUDE.md são estáveis — mudanças frequentes invalidam cache
• Sessões são contínuas — pausas curtas mantêm TTL, pausas longas perdem cache
• Conteúdo repetido vem primeiro — cache opera sequencialmente

Mantenha CLAUDE.md conciso (<200 linhas) e mova instruções específicas para skills (carregadas sob demanda).

Stack completa de otimização de custos

As features de visibilidade da v2.1.92 são parte de uma stack maior de otimizações recentes:

Feature	Versão	O que faz
Read compact format	v2.1.86	Reduz tokens de leitura de arquivo
Hook output cap 10K	v2.1.89	Limita output de hooks
SSE linear time	v2.1.90	Elimina degradação quadrática
SDK session fix	v2.1.90	Fix performance em sessões longas
Edit shorter anchors	v2.1.91	Menos output tokens por edit
Write diff 60% faster	v2.1.92	Menos tokens em escrita
Per-model /cost breakdown	v2.1.92	Visibilidade por modelo e cache
Cache expiry hint	v2.1.92	Alerta de cache expirado
Prompt caching nativo	Automático	Até 90% economia em input tokens
Auto-compaction	Automático	Comprime contexto quando necessário

Combinadas, essas otimizações podem entregar 55-70% de redução em custo de tokens versus versões antigas.

Artigos anteriores cobriram cada peça dessa stack: Write tool 60% mais rápido, Edit com anchors menores, sessões longas sem degradação. As features de hoje completam a stack com a camada que faltava: visibilidade.

Os dados que deveriam te preocupar

Organizações sem cost management estruturado desperdiçam 32-40% dos seus budgets de cloud em recursos ociosos e não monitorados.

AI tools para desenvolvedores custam $200-500 por dev por mês all-in, incluindo licenças, MCP infrastructure e governance. Para 1.000 devs, são $200K-500K/mês. O ROI só existe se produtividade aumentar pelo menos 10% — e mesmo assim, você precisa medir para provar.

Para uma software house com 20 devs, a diferença entre FinOps ativo e passivo pode ser R$5.000-15.000 por mês. Em um ano, R$60K-180K. É o salário de um dev senior.

O que eu penso

Token economics é P&L. Não é infraestrutura.

Cada token que seu dev consome é uma decisão financeira. Opus versus Sonnet não é preferência pessoal — é custo. Sessão com cache versus sem cache não é detalhe técnico — é margem.

O /cost com breakdown e o cache expiry hint não são features glamourosas. Não vão virar post no LinkedIn. Ninguém vai twittar “uau, agora eu vejo meus cache hits”. Mas são as features que transformam gasto cego em investimento mensurável.

Na minha experiência com 300+ software houses, as que crescem mais rápido não são as que gastam mais em tecnologia — são as que sabem exatamente quanto cada decisão tecnológica custa.

Sua software house sabe quanto custa cada prompt? Cada modelo? Cada sessão?

Se não sabe, digita /cost. E começa a medir.

Sou Thulio, mentoro 300+ SHs desde 2016. Se você quer implementar FinOps de IA na sua software house e transformar gasto em investimento mensurável, fale comigo na Software House Exponencial.