RTK — Economia de Tokens

O problema: tokens desperdiçados

Em uma sessão típica de 30 minutos com Claude Code, o agente executa dezenas de comandos CLI — git status, git diff, npm test, ls, grep, etc. Cada saída desses comandos consome tokens da janela de contexto.

O problema é que a maior parte dessa saída é ruído: barras de progresso, códigos ANSI, mensagens verbosas de sucesso, formatação decorativa. Em uma sessão com ~60 comandos, o agente pode gerar ~150K tokens de saída CLI — quase toda a janela de contexto de 200K.

Considere a diferença na saída de um simples git push:

# Sem RTK — saída padrão (~200 tokens)
Enumerating objects: 15, done.
Counting objects: 100% (15/15), done.
Delta compression using up to 10 threads
Compressing objects: 100% (8/8), done.
Writing objects: 100% (8/8), 2.34 KiB | 2.34 MiB/s, done.
Total 8 (delta 6), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (6/6), completed with 6 local objects.
To github.com:user/repo.git
   abc1234..def5678  main -> main

# Com RTK — saída filtrada (~10 tokens)
ok main

O LLM não precisa saber quantos objetos foram enumerados ou comprimidos — precisa apenas saber que o push foi bem-sucedido e para qual branch.

O que é o RTK

RTK (Rust Token Killer) é um proxy CLI open-source escrito em Rust que intercepta a saída de comandos e a filtra antes que chegue ao LLM. Em vez de o Claude Code receber a saída bruta de cada comando, recebe apenas a informação essencial para raciocinar.

Como funciona

O RTK opera como um proxy transparente entre o Claude Code e o shell. Quando o Claude executa um comando via Bash tool, o hook do RTK intercepta e reescreve o comando:

# Fluxo sem RTK:
Claude Code  --git status-->  shell  -->  git
     ^          ~2.000 tokens              |
     +-------------------------------------+

# Fluxo com RTK:
Claude Code  --git status-->  RTK  -->  git
     ^          ~200 tokens    |filter   |
     +---------(filtrado)------+---------+

O RTK aplica quatro estratégias de filtragem conforme o tipo de comando:

1. Smart Filtering — Remove ruído: comentários, whitespace, boilerplate, códigos ANSI, barras de progresso
2. Grouping — Agrupa itens similares: arquivos por diretório, erros por tipo, lint por regra
3. Truncation — Mantém contexto relevante, corta redundância
4. Deduplication — Colapsa linhas repetidas com contadores (ex: error x42)

Integração via Hook

A integração com Claude Code funciona via PreToolUse hook (veja Módulo 07 — Hooks). Quando o Claude Code invoca a ferramenta Bash com um comando como git status, o hook chama rtk rewrite "git status" que retorna rtk git status. O agente nunca vê a reescrita — recebe apenas saída comprimida.

Instalação

Via Homebrew (recomendado)

brew install rtk

Via script de instalação (Linux/macOS)

curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

Via Cargo (do fonte)

cargo install --git https://github.com/rtk-ai/rtk

Verificação

Após instalar, verifique que é o pacote correto:

# Deve mostrar a versão do RTK
rtk --version

# Deve funcionar (mostra analytics de economia)
rtk gain

Configuração com Claude Code

O comando rtk init automatiza toda a configuração:

# Instalação global com hook (recomendado)
rtk init -g

# Reinicie o Claude Code após a instalação

O comando rtk init -g executa as seguintes ações:

1. Instala o hook script em ~/.claude/hooks/rtk-rewrite.sh
2. Cria ~/.claude/RTK.md (referência de meta-comandos, ~10 linhas)
3. Adiciona @RTK.md no ~/.claude/CLAUDE.md
4. Registra o hook PreToolUse em ~/.claude/settings.json
5. Cria backup em ~/.claude/settings.json.bak

Modos de instalação

O que o hook faz na prática

Com o hook ativo, o Claude Code continua escrevendo comandos normais. O hook reescreve automaticamente:

# O Claude escreve:
git status

# O hook reescreve para:
rtk git status

# O Claude recebe saída comprimida:
M src/app.ts
M tests/app.test.ts
? src/utils/helper.ts

Comandos principais

O RTK suporta 100+ comandos organizados por ecossistema. Aqui estão os mais relevantes para uso diário:

Git

Testes

Arquivos e busca

Build e lint

Analytics e monitoramento

O RTK registra cada comando em um banco SQLite local, permitindo analisar a economia real de tokens:

rtk gain — relatório de economia

# Resumo geral
rtk gain

# Gráfico ASCII dos últimos 30 dias
rtk gain --graph

# Histórico recente com economia por comando
rtk gain --history

# Breakdown diário/semanal/mensal
rtk gain --daily
rtk gain --weekly
rtk gain --monthly

# Exportar para JSON ou CSV (dashboards)
rtk gain --all --format json
rtk gain --all --format csv

rtk discover — oportunidades perdidas

Analisa o histórico do Claude Code e identifica comandos que poderiam ter sido otimizados:

# Descobrir oportunidades no projeto atual
rtk discover

# Todos os projetos, últimos 7 dias
rtk discover --all --since 7

rtk session — adoção por sessão

# Ver taxa de adoção do RTK nas sessões recentes
rtk session

Comandos utilitários

# Bypass — executar comando sem filtros (debug)
rtk proxy git status

# Resumo heurístico de qualquer comando
rtk summary <comando>

# Leitura agressiva — apenas assinaturas de funções
rtk read file.ts -l aggressive

Economia real: números de uma sessão típica

Dados de uma sessão de 30 minutos em um projeto TypeScript/Rust médio:

Benefícios

• Sessões mais longas — Menos tokens por comando = mais espaço na janela de contexto para código e raciocínio
• Menor custo — Menos tokens consumidos = menor custo em plataformas pay-per-token
• Zero fricção — O hook reescreve comandos automaticamente; o LLM não sabe que está usando RTK
• Extremamente rápido — <10ms de overhead, binário Rust single-threaded, <5MB de memória
• Analytics integrados — rtk gain dá visibilidade total sobre economia real com exports em JSON/CSV
• Fail-safe — Se o filtro falhar, a saída bruta passa sem alteração; exit codes sempre preservados
• Multi-ferramenta — Funciona com Claude Code, Cursor, Copilot, Gemini CLI, Codex e mais 5 ferramentas
• Tee recovery — Quando comandos falham, o RTK salva a saída completa em log para o LLM ler sem re-executar

Tradeoffs e limitações

Como qualquer ferramenta de otimização, o RTK faz tradeoffs que você precisa conhecer:

Configuração avançada

O RTK pode ser customizado via arquivo de configuração TOML:

# macOS: ~/Library/Application Support/rtk/config.toml
# Linux: ~/.config/rtk/config.toml

[tracking]
database_path = "/path/to/custom.db"

[hooks]
# Comandos que o hook não deve reescrever
exclude_commands = ["curl", "playwright"]

[tee]
enabled = true          # Salvar saída bruta em caso de falha
mode = "failures"       # "failures", "always" ou "never"
max_files = 20          # Limite de rotação de arquivos

Desinstalação

# Remove hook, RTK.md e entrada no settings.json
rtk init -g --uninstall

# Remove o binário
brew uninstall rtk       # se instalou via Homebrew
cargo uninstall rtk      # se instalou via Cargo