Um bilhão de tokens queimados em um dia? A conta de IA dos programadores está punindo os "preguiçosos"

Público-alvo: Desenvolvedores que estão usando ferramentas de programação com IA (como Cursor, Windsurf, trae...) e gerentes técnicos que não têm consciência dos custos da IA.

Ponto principal: Token não é apenas uma unidade simples de cobrança, mas um "recurso de atenção" e uma "moeda de poder computacional". Abusar do modo Agente e negligenciar o gerenciamento de contexto é, na verdade, usar a diligência tática (deixar a IA fazer bagunça) para mascarar a preguiça estratégica (não pensar por si mesmo).

Sua "despesa com IA" pode ser maior que seu salário

Alguns dias atrás, verifiquei minha conta de tokens. Quando vi o número, fiquei um pouco surpreso: 10 milhões de tokens. Atenção, isso não é o consumo de um mês, é de um dia.

Achei que isso era muito absurdo. Depois, postei um vídeo curto relacionado ao cálculo de tokens.

O resultado: os comentários me mostraram o que é "há sempre alguém melhor".

A imagem abaixo é um print do registro de consumo de 200 milhões de tokens em um dia do usuário "A rotina do Lao K":

No começo, pensei que poderia ser um caso isolado, mas quando muitos usuários comentaram dizendo que consomem 100 milhões por dia, entendi que é um fenômeno bastante comum.

O que significa 100 milhões de tokens? Se considerarmos o nível de cobrança comum de "alguns modelos comerciais principais" (entrada/saída cobrados separadamente, juntos estimados grosseiramente como US$ 10 / milhão de tokens), isso queima US$ 1000 em um dia. Queima 7000 yuans em um dia. O salário mensal de muitos programadores juniores pode não ser suficiente para a IA "pensar" por um dia.

(Observação: os preços variam muito entre diferentes modelos/fornecedores, e os preços unitários de entrada e saída também costumam ser diferentes. O objetivo aqui não é calcular com precisão até a segunda casa decimal, mas primeiro estabelecer a "sensação de magnitude".)

Se você quiser recalcular por conta própria, geralmente é esta fórmula (ignorando regras especiais como cache/descontos): custo ≈ (tokens de entrada / 1.000.000) × preço_in + (tokens de saída / 1.000.000) × preço_out

Isso é muito contra-intuitivo. Sempre achamos que a IA é barata, a OpenAI até vai reduzir preços. Mas por que, na engenharia prática, o consumo de tokens explode exponencialmente?

Hoje, vamos desmontar profundamente a lógica por trás desse "buraco negro de tokens" e como podemos parar as perdas.

1. Por que os tokens "explodem exponencialmente"?

Muitos colegas não têm ideia do volume de tokens. Pensam: "Ah, é só enviar algumas linhas de código, quanto pode ser?"

1.1 Faça as contas claramente

Primeiro, vamos estabelecer uma percepção quantitativa suficiente para a engenharia. Vamos ser diretos: Token não é número de palavras, nem número de caracteres. É um "fragmento de codificação" após o modelo dividir o texto. Diferentes modelos usam tokenizers diferentes, então só podemos dar um intervalo, não uma constante "universal".

Considere os números abaixo como uma "régua de estimativa" (o objetivo é julgar a magnitude, estimar custos e tomar decisões para parar perdas):

• 1 caractere chinês: geralmente entre 1–2 tokens (caracteres de alta frequência mais próximos de 1, caracteres raros/combinações mais fáceis de chegar a 2–3)
• 1 palavra em inglês: geralmente em torno de 1,2–1,5 tokens (pode usar 1,3 para estimativas grosseiras)
• 1 linha de código ≈ 10–50 tokens (incluindo indentação, comentários, declarações de tipo)
• Lógica de negócios concisa ≈ 12–20 tokens
• Com anotações de tipo, interface, JSDoc, indentação de 4 espaços ≈ 20–35 tokens
• Com muitos imports / decoradores / comentários ≈ 30–50+ tokens
• 1 arquivo fonte (400–600 linhas, projeto moderno TS/Java) ≈ 4.000–24.000 tokens é comum (mediana ≈ 12.000–18.000)
• 1 projeto de médio porte (100–200 arquivos fonte, apenas src/, excluindo node_modules/ / código gerado)
• "Ler completamente" o código-fonte principal frequentemente começa em um milhão de tokens
• Se adicionarmos testes, configurações, scripts, declarações de dependência, logs, não é estranho ultrapassar dezenas de milhões de tokens

Os projetos front-end atuais são em TypeScript, cheios de definições complexas de Interface; ou em Java, com dezenas de linhas de Import. Esses "códigos boilerplate" são verdadeiros assassinos de tokens. Um projeto de médio porte, com 100 arquivos, apenas para fazer a IA "ler o código uma vez", pode facilmente consumir 1 milhão de tokens.

1.2 O efeito "bola de neve" dos tokens

O mais assustador no consumo de tokens não é uma única conversa, mas a acumulação de contexto em conversas com múltiplas interações.

O mecanismo do LLM é stateless. Para fazer a IA lembrar o que você disse anteriormente, o sistema geralmente empacota e envia ao modelo "instruções do sistema + histórico da conversa + trechos de arquivos/código que você referenciou + saídas de chamadas de ferramentas (por exemplo, resultados de pesquisa, logs de erro)". Você acha que fez apenas uma pergunta, mas na verdade está pagando repetidamente pelo "pacote de contexto inteiro".

• Rodada 1: envia 10 mil tokens, a IA responde 1 mil.
• Rodada 2: envia (10 mil + 1 mil + nova pergunta), a IA responde...
• Rodada 10: seu Contexto pode ter inflado para 200 mil tokens.

Nesse ponto, mesmo que você apenas pergunte "ajude-me a mudar o nome de uma variável", o custo consumido é de 200 mil tokens. É por isso que você sente que não fez nada, mas a conta dispara.

Pior ainda: o modo Agente "lê arquivos ativamente". Com um comando "ajude-me a otimizar o módulo de usuários", ele pode primeiro escanear o diretório relevante, depois seguir para dependências, configurações, testes... Ele não está sendo preguiçoso, está "cumprindo seu dever conforme a estratégia padrão", e a estratégia padrão geralmente é: ler mais, tentar mais, iterar mais.

2. Dois tipos de "preguiça" estão destruindo sua capacidade de engenharia

Após analisar os casos daqueles "irmãos de 100 milhões" nos comentários, descobri que a raiz da explosão de tokens não está apenas no mecanismo de consumo da IA, mas também está intimamente relacionada à preguiça das pessoas.

Abaixo estão dois tipos típicos de "preguiça mental".

Preguiça um: o tipo "delegador total"

Você também tem essa mentalidade?

• "Esse projeto antigo está muito bagunçado, estou com preguiça de entender a lógica, vou jogar para a IA."
• "O Cursor lançou o modo Agente, ótimo, deixe ele consertar os bugs sozinho."

Então, você joga toda a pasta src para o Agente e dá uma instrução vaga: "Ajude-me a otimizar o módulo de usuários." O Agente começa a trabalhar:

• Ele lê 50 arquivos (consome 500 mil).
• Ele descobre referências a utils, vai ler as classes utilitárias (consome 200 mil).
• Ele tenta modificar, dá erro, lê os logs de erro (consome 100 mil).
• Ele tenta corrigir, dá erro novamente...

Ele está tentando loucamente, consumindo tokens loucamente. E você? Está no celular, achando que sua eficiência é alta. A verdade é: você está trocando dinheiro por "pseudo-eficiência", produzindo um monte de código que não poderá manter depois.

De forma mais profissional, há duas camadas de perda aqui:

• Camada de custo: tokens de entrada aumentam, número de iterações aumenta, custos se somam linearmente
• Camada de engenharia: você perde contexto e poder de decisão, sobrando apenas um sistema incontrolável que "funciona, tá bom"

Preguiça dois: o tipo "jogar tudo junto"

Quando encontra um Bug, como você joga para a IA? Copia todo o console de erro com Ctrl+A, ou simplesmente usa @Codebase para a IA procurar sozinha?

Isso se chama "jogar tudo junto". Você tem preguiça de localizar o núcleo do problema, de filtrar os trechos de código-chave. Você joga 99% de informações inúteis (ruído) e 1% de informações úteis (sinal) para a IA de uma vez.

A IA é como um amplificador.

• Se você der lógica clara (sinal), ela amplifica sua inteligência, usa poucos tokens, resultado bom.
• Se você der confusão e ambiguidade, ela amplifica sua confusão, tokens disparam, produz lixo.

3. Solução: como usar a IA com eficiência e reduzir o consumo de tokens

Para proteger sua carteira e, mais importante, seu controle de engenharia, devemos mudar o modo de colaboração com a IA.

3.1 Princípio do contexto mínimo

Este é o primeiro princípio da programação com IA. Sempre dê à IA apenas o conjunto mínimo de código necessário para resolver o problema atual.

No Cursor, use bem estes operadores:

• @File: referencie apenas os arquivos relevantes, não a pasta inteira.
• Ctrl+L para selecionar código: envie para o Chat apenas as 50 linhas de código selecionadas com o cursor, não o arquivo inteiro.
• @Docs: para bibliotecas de terceiros, referencie a documentação em vez de deixá-la adivinhar.

Este é o SOP (Procedimento Operacional Padrão) estruturado e reutilizável que uso frequentemente (seguindo isso, você verá o consumo de tokens cair visivelmente):

O significado deste parágrafo é: ao colaborar com a IA, preste atenção à eficiência e precisão. As práticas específicas são as seguintes:

• Primeiro, defina o objetivo: diga à IA de forma concisa e clara o problema atual e o resultado desejado, não deixe ela adivinhar sozinha.
• Simplifique a reprodução do problema: se puder reproduzir o problema da maneira mais simples, não use métodos complexos; cole o código mínimo e crucial, não empilhe um monte de conteúdo irrelevante.
• Forneça as informações mínimas necessárias: apenas 1-3 arquivos relevantes, funções-chave e as primeiras linhas do stack trace de erro, não informações completas.
• Peça para retornar os pontos de modificação: faça a IA apenas dizer onde modificar e por quê, não peça para reescrever todo o código extensivamente.
• Por fim, você mesmo valida: faça uma verificação breve para garantir que as alterações não afetem outros lugares.

Em resumo, use as informações mínimas e mais cruciais para fazer a IA trabalhar, e mantenha o controle final e o poder de julgamento.

3.2 E o mais importante: pense primeiro, depois faça o Prompt, planeje primeiro, depois aja

Antes de pressionar Enter, force-se a fazer uma pausa de 10 segundos e pergunte a si mesmo três questões:

• Que problema estou resolvendo? (definir limites)
• Quais módulos centrais este problema envolve? (filtrar Contexto)
• Se eu fosse escrever sozinho, como faria? (fornecer linha de pensamento)

Você é o 1, a IA são os zeros depois. Se o 1 não se sustentar, não importa quantos zeros venham depois, será apenas consumo sem sentido.

Algumas palavras sinceras

A história de "100 milhões de tokens em um dia" talvez não aconteça com todos. Mas o comportamento de desperdiçar tokens é algo que quase todo programador que usa IA para programação já experimentou.

A IA tornou a programação mais fácil, mas ainda há barreiras. Apenas quem sabe usar realmente terá uma vantagem poderosa.

Antes, seu código ruim apenas "incomodava" os colegas. Agora, sua preguiça se transforma diretamente em números na conta, punindo você mesmo com custos disparados.

Portanto, não seja um "delegador total". Seja um arquiteto de IA que pensa profundamente, se expressa com precisão, planeja antes de agir. Esta também é nossa maior irreplaceabilidade nesta era.