AIDiveA JetBrains diz não, minha máquina diz 11,6 milhões
Em julho de 2026 a JetBrains gastou cerca de US$ 320 em crédito de API — 425 execuções cobradas — para avaliar o rtk, um proxy de shell que dezenas de milhares de desenvolvedores instalam para economizar tokens no Claude Code. O veredito: as sessões saíram 7,6 % mais caras por tarefa. Duas semanas antes, o mesmo time havia medido o caveman, a skill anunciada como um corte de 65 % dos tokens, e obteve 8,5 %. Na minha própria máquina, o rtk gain reporta 11,6 milhões de tokens economizados em 25 599 comandos.
Os dois conjuntos de números são reais. Eles não medem a mesma coisa: um é o custo por tarefa concluída, o outro são bytes de saída do bash.
| Número | O que mede | Fonte |
|---|---|---|
| +7,6 % por tarefa (p=0,004) | Custo ponta a ponta de uma tarefa com o rtk instalado | JetBrains, 425 execuções, ~US$ 320 |
| 8,5 % dos tokens de saída | Economia medida do caveman em trabalho agêntico | JetBrains, 82 tarefas pareadas |
| 65 % | Economia anunciada pelo caveman | README do caveman |
| 11,6 M economizados (41,6 %) | Bytes de saída do bash comprimidos pelo rtk | rtk gain, 25 599 comandos |
Esta é a stack, quatro ferramentas: graphify, rtk, Superpowers e caveman, 575 612 estrelas no GitHub somadas em 2026-09-02. Cada uma mexe numa fatia diferente da conta.
| Ferramenta | Estrelas (2026-09-02) | Linguagem | Licença |
|---|---|---|---|
| Superpowers | 280 792 | Skills em Markdown | MIT |
| graphify | 113 946 | Python | Apache-2.0 |
| caveman | 102 548 | Go | MIT (skill) |
| rtk | 78 326 | Rust | Apache-2.0 |
Pra onde os tokens vão de verdade
A conta do Claude Code tem dois lados. Tokens de entrada são tudo que o modelo lê: a saída de cada comando de shell, o seu prompt, o prompt de sistema e todo o histórico da conversa reenviado a cada chamada. Tokens de saída são tudo que o modelo escreve.
A própria documentação do rtk desenha exatamente essa árvore e acrescenta uma frase que o post de lançamento não tinha: "Um comando que mostra 90 % menos bytes de saída não deixa sua sessão 90 % mais barata."
A JetBrains colocou números no lado da leitura reproduzindo 83 sessões de referência, 1,9 milhão de caracteres de saída de ferramentas.
| Fatia do que o modelo lê | Caracteres | Parcela |
|---|---|---|
| Saída de shell que o rtk consegue comprimir | 373 339 | 19,7 % |
| Saída de shell para a qual o rtk não tem regra | 879 326 | 46,3 % |
| Ferramentas de leitura e busca que passam longe do rtk | 646 613 | 34,0 % |
Só um quinto do que o modelo lê é comprimível por um proxy de shell — as ferramentas nativas Read, Grep e Glob do Claude Code nunca passam pelo hook do Bash.
Daí sai o mapa das quatro ferramentas: o graphify reduz o que o agente lê, o rtk reduz o que o shell devolve, o Superpowers reduz o histórico que cada tarefa carrega e escolhe qual modelo a carrega, e o caveman reduz o que o agente fala. A leitura é a metade maior da conta, então é por aí que o ranking começa.
graphify: percorrer nós, não linhas
graphify é uma skill que transforma uma base de código — com docs, esquemas SQL, configs e PDFs — num grafo de conhecimento consultável. Você digita /graphify . no Claude Code, Cursor, Codex ou Gemini CLI, e o projeto é mapeado uma vez para que o agente consulte o grafo em vez de dar grep nos arquivos.
O código é parseado com AST do tree-sitter em cerca de 40 linguagens: determinístico, sem chamada de LLM, nada sai da máquina. A construção custa zero créditos de LLM. Ela gera três arquivos: graph.html para navegar clicando, GRAPH_REPORT.md e graph.json — o grafo em si, consultável sem reler seus arquivos. Cada nó é um conceito (um arquivo, uma função, uma classe), e cada aresta é marcada como EXTRACTED quando estava explícita no código ou INFERRED quando o graphify a resolveu. Os nós são agrupados em subsistemas pelo algoritmo de Leiden.
O benchmark embutido, rodado em um projeto nosso:
| Métrica | Valor |
|---|---|
| Nós | 34 031 |
| Arestas | 56 865 |
| Comunidades detectadas | 967 |
| Origem das arestas | 76 % EXTRACTED · 24 % INFERRED |
| Leitura ingênua do corpus completo | 1 701 550 palavras ≈ 2 268 733 tokens |
| Consulta média ao grafo | ~24 702 tokens |
| Redução | 91,8× menos tokens por consulta |
Por pergunta a variação é grande: 679,1× em "what is the main entry point", 34,0× em "what connects the data layer to the api".
Dois limites. A comparação é contra ler tudo, e uma sessão guiada por grep nunca custou isso, então o ganho real é menor. E o grafo desatualiza — atualize com graphify update <path>, --watch ou os hooks do git — enquanto a passagem semântica sobre docs, PDFs e imagens realmente chama um modelo e realmente gasta tokens.
Instalação: uv tool install graphifyy (o nome do pacote tem dois y), depois graphify install.
rtk: o proxy de shell em julgamento
rtk é um proxy de CLI entre o Claude Code e o seu shell. Comandos comuns como ls, cat ou git status devolvem ruído que o agente precisa ler como tokens de entrada: permissões de arquivo, barras de progresso, cem linhas de testes passando. O rtk roda o mesmo comando e devolve uma versão compacta: um único binário em Rust, mais de 100 comandos suportados, menos de 10 ms de overhead. Um hook PreToolUse reescreve toda chamada de Bash elegível (git status → rtk git status) antes de executar, então o agente nunca precisa lembrar disso.
O post de lançamento do autor afirmava 10,2 M de tokens economizados em duas semanas, 89,2 %, com exemplos como cargo test indo de 155 linhas para 3. Nosso próprio painel após 25 599 comandos:
| Comando | Chamadas | Tokens economizados | Taxa |
|---|---|---|---|
rtk find |
354 | 2,2 M | 46,6 % |
rtk read |
3 504 | 2,2 M | 10,4 % |
rtk grep |
2 760 | 1,9 M | 47,7 % |
rtk ps aux |
24 | 1,1 M | 98,0 % |
rtk diff |
39 | 541,1 K | 92,2 % |
| Total | 25 599 | 11,6 M | 41,6 % |
Aí vem o julgamento. A JetBrains instalou o rtk exatamente como ele é distribuído e rodou 86 tarefas duas vezes no claude-sonnet-5.
| Achado da JetBrains | Valor |
|---|---|
| Comandos de shell que o rtk consegue reescrever | 349 de 1 056 (1 em 3) |
| Teto da economia total | ~3 % da conta |
| Custo por tarefa, esforço de raciocínio baixo | +7,6 % (p=0,004) |
| Turnos por tarefa | +13,8 % (p=0,03) |
| Custo por tarefa, esforço alto | ±0 % |
| Qualidade das tarefas | Inalterada |
O README do rtk agora diz sem rodeios: até 90 % da saída do bash, "o que não é a mesma coisa que cortar sua conta em 90 %", e suas próprias contagens são estimadas como bytes / 4.
Veredito: é grátis, a compressão é real e, nas palavras da JetBrains, "muitas vezes elegante". Mantenha para sessões pesadas em bash; não espere que mexa na conta.
Superpowers: enquadrar primeiro, depois tarefas pequenas demais pra falhar
Superpowers é o plugin de Jesse Vincent para o Claude Code — 280 792 estrelas, quatorze skills, um único comando de instalação (/plugin install superpowers@claude-plugins-official). Ele economiza tokens sem comprimir nada.
Tudo começa pela skill de brainstorming, que abre com uma barreira dura: nada de código, nada de scaffolding, nenhuma skill de implementação enquanto uma intenção explícita não for aprovada. Quando a skill carrega, o agente vira um parceiro de brainstorming e, na prática, partes do projeto são repensadas antes de qualquer construção. É o estágio que mais importa, porque os tokens mais caros são os gastos construindo a coisa errada.
A skill classifica o trabalho como spike, mudança delimitada ou mudança arquitetural, e a regra está escrita no arquivo: "Na dúvida entre dois caminhos, pegue o mais pesado." Ela até nomeia o modo de falha, com uma seção anti-padrão chamada "Too Simple To Need Approval". O caminho arquitetural produz uma spec que você valida e depois um plano de implementação.
O plano é de onde vem a confiabilidade. A skill writing-plans corta o trabalho em passos de uma ação só, de 2 a 5 minutos: escrever o teste que falha, rodar para confirmar a falha, escrever o código mínimo que faz passar, rodar os testes de novo, commitar. Os planos são escritos assumindo que o engenheiro não tem contexto nenhum. Uma tarefa desse tamanho cabe numa janela de contexto nova com folga, então o agente nunca chega ao fim de uma tarefa com a janela saturada — e é a saturação que produz código alucinado.
O limite é a cerimônia. O arquivo diz que ela escala com a tarefa, mas a barreira dispara mesmo num ajuste de uma linha, e isso também são tokens.
Superpowers: uma tarefa, um subagent, um modelo sob medida
Então o plano roda, e a matemática dos tokens muda. Uma tarefa, um subagent. Cada subagent começa com um contexto novo que contém apenas a sua tarefa, nunca o histórico da sessão, então a janela do orquestrador fica pequena e a do subagent fica limpa. Depois de cada tarefa o orquestrador revisa o resultado: OK, próxima tarefa; não OK, a correção volta para um subagent. Cinco rodadas no máximo por tarefa — as rodadas 1 a 3 retomam o implementador original, a rodada 4 passa o trabalho para um implementador novo num modelo mais capaz, e na rodada 5 o próprio orquestrador decide.
A regra que paga todo o resto é a seleção de modelo: "Use o modelo menos poderoso capaz de dar conta de cada papel, para economizar." O orquestrador avalia a dificuldade de cada tarefa e escolhe o modelo correspondente.
| Tipo de tarefa | Nível de modelo |
|---|---|
| Mecânica, bem especificada; o plano já traz o código | Modelo mais barato / pequeno |
| Coordenação multiarquivo, depuração | Modelo padrão |
| Arquitetura, revisão final do branch | Modelo mais capaz |
| Modelo omitido | Herda o modelo da sessão |
Uma nuance do mesmo arquivo: "Contagem de turnos vence preço por token." Um modelo barato que leva três turnos não é barato. Na prática, é isso que torna Opus e Fable usáveis num plano Pro de US$ 20: o modelo caro toca um punhado de tarefas em vez da sessão inteira.
O último ganho é documentação. Cada spec e cada plano é um arquivo markdown salvo em docs/superpowers/specs/ e docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md, commitado ao fim do trabalho. No pipeline deste canal, a migração para o nosso motor de vídeo atual é uma spec mais um plano de quatorze tarefas que você ainda pode abrir, mencionar numa sessão nova e ampliar. Nada do que os agentes fizeram fica sem rastro.
caveman e o estilo Concise: falar menos
A última fatia é o que o agente fala. Agentes narram — "claro", "fico feliz em ajudar", "o problema que você está enfrentando provavelmente vem de" — e isso são tokens de saída à toa.
caveman é uma skill de Julius Brussee, 102 548 estrelas, que faz o agente falar como homem das cavernas: cortar artigos, enchimento, gentilezas e ressalvas, e seguir o padrão [coisa] [ação] [motivo]. [próximo passo]. Código, comandos, caminhos de arquivo e mensagens de erro exatas nunca são cavernizados; só a prosa em volta. Ela traz três níveis (/caveman lite|full|ultra) e um hook SessionStart que a liga na inicialização.
A tabela dela, dez prompts pela API da Claude, dá média de 1 214 tokens de saída sem a skill e 294 com — 65 %, com melhor caso de 87 % e pior caso de 22 %.
O README traz o próprio banho de realidade: a skill só encurta a saída, tokens de entrada e de raciocínio não mudam, e as regras dela custam cerca de 1 a 1,5 k tokens de entrada a cada turno. A JetBrains mediu em 82 tarefas agênticas pareadas, por volta de US$ 106 de crédito.
| caveman | Anunciado | Medido (JetBrains) |
|---|---|---|
| Economia de tokens de saída | 65 % | 8,5 % (592 k → 542 k) |
| Impacto na qualidade | — | Nenhuma degradação detectável (teste de sinais p=0,82) |
A diferença é estrutural: a saída de um agente é sobretudo código e chamadas de ferramenta, que o caveman corretamente deixa em paz. Recomendação da JetBrains: "use se você gostar. É divertido e não custa nada mensurável em qualidade."
Desde o Claude Code v2.1.237 existe um equivalente nativo, o estilo de saída Concise: o Claude "começa pelo resultado, pula preâmbulo e narração, e mantém respostas curtas por padrão". Escolha em /config → Output style; ele é salvo em .claude/settings.local.json e passa a valer depois de /clear ou numa sessão nova. Um limite comum aos dois: estilos de saída valem só para a conversa principal — um subagent roda o próprio prompt de sistema.
Veredito: o que mexe na conta, o que mexe nas margens
Ranking pelo que cada ferramenta realmente move, com o custo que cada uma carrega.
| Posição | Ferramenta | O que move | Efeito medido | O custo |
|---|---|---|---|---|
| 1 | Superpowers | O histórico por tarefa + qual modelo o lê | O modelo caro em um punhado de tarefas em vez da sessão | Uma barreira em toda tarefa, até em ajustes de uma linha |
| 2 | graphify | O que o agente lê | 91,8× menos tokens por consulta que uma leitura ingênua do corpus (nosso projeto) | O grafo desatualiza; a passagem semântica gasta tokens |
| 3 | rtk | Bytes de saída do bash | Teto ~3 % da conta; +7,6 % por tarefa em esforço baixo no teste da JetBrains | Só 1 em 3 comandos de shell tem regra |
| 4 | caveman / Concise | A prosa que o agente escreve | 8,5 % dos tokens de saída, sem perda de qualidade | ~1 a 1,5 k tokens de entrada a cada turno |
O Superpowers vence, e não por compressão alguma: um contexto novo por tarefa e o modelo mais barato que dê conta mudam o que é lido e quem lê. O graphify fica em segundo porque ler menos é a metade maior da conta. O rtk é real, grátis e inofensivo, mas dois terços dos comandos de shell e todas as leituras de arquivo passam longe dele. O caveman, ou o estilo Concise que o Claude Code já traz, apara a menor fatia.
Todas as quatro são grátis de instalar — graphify e rtk sob Apache-2.0, Superpowers sob MIT, a skill caveman sob MIT. Mais de 570 000 estrelas dizem que as pessoas querem um milagre. A versão honesta é um ranking.
