Se você não pode esperar e ler este post, apenas copie/cole este prompt para o seu claude code / codex / grok agora mesmo para obtê-lo imediatamente:
Instale o XERJ (docs:
https://xerj.org/llms.txt ), indexe as fontes deste projeto e configure a codificação por referência: clone e indexe os repositórios open-source mais próximos do que estamos construindo e pesquise como eles resolveram um problema antes de escrever código.
a maioria das pessoas usa o claude code como um estagiário caro, e aqui está como torná-lo mais inteligente a cada rodada (de verdade)
você entrega uma tarefa. ele faz algumas perguntas. ele vasculha o repositório, adivinha como seu código funciona, escreve uma implementação, algo quebra. você cola o erro. ele reescreve. algo mais quebra.
cada uma dessas rodadas são tokens que você pagou.
e o claude geralmente não está travado porque o problema é difícil. ele está travado porque você o fez redescobrir uma resposta que já existe em algum lugar, seja no seu próprio repositório ou em um projeto open-source onde alguns milhares de desenvolvedores já encontraram os casos extremos.
O XERJ testou isso adequadamente. 8 tarefas de codificação, 4 linguagens, 16 execuções por configuração, contagens de tokens extraídas diretamente do claude -p.
da memória: 260.916 tokens de saída de uma referência: 9.982 tokens de saída
a memória resolveu 11 das 16. a referência resolveu todas as 16.
então preste atenção e leia isso ↓↓↓
o loop pelo qual você está pagando
uma sessão normal é assim.
você descreve o que quer. o claude explora. ele faz uma suposição sobre seus padrões, seu tratamento de erros, a forma dos seus dados. ele escreve código com base nessa suposição. a suposição estava errada em algum lugar, então a coisa quebra, você explica o erro, ele reescreve, e vocês ficam nesse ciclo até que a saída corresponda ao que você tinha em mente no início.
as pessoas interpretam esse loop como o claude sendo ruim em codificação. é o oposto. o claude é muito bom em pegar um exemplo funcional e adaptá-lo a uma nova situação. o loop acontece quando não há nenhum exemplo no ambiente, então ele gasta a primeira metade da sessão reconstruindo um.
tokens de saída são os caros, precificados cerca de 5x acima dos de entrada nos modelos claude. então cada volta desse loop é cobrada na tarifa máxima.
um prompt e uma referência não são a mesma coisa
um prompt é uma instrução. uma referência é evidência.
você pode escrever duas mil palavras descrevendo exatamente como a coisa deve se comportar e o claude ainda precisa traduzir essa descrição em uma implementação, e então adivinhar tudo o que você deixou de fora.
uma implementação funcional já contém as partes que você nunca escreveria
a arquitetura, o tratamento de erros, a lógica de repetição, o caso extremo que alguém encontrou em produção há dois anos, a razão pela qual uma função é dividida daquela forma
você não mencionou essas coisas no prompt porque não sabia que elas importavam.
aqui está a versão mais afiada disso. um compilador eventualmente vazará um nome de método. ele dirá que a função se chama absorb e não push, e cobrará de 20 a 25x os tokens para chegar lá. um compilador nunca vazará um contrato. nada na sua ferramenta vai te dizer que essa estrutura precisa ser selada antes de ser lida. essa regra vive na cabeça de quem escreveu a biblioteca e no corpo da função, e nenhuma quantidade de escrita de prompt a recupera, porque você nem sabe que ela existe.
é por isso que isso corta tokens e aumenta a qualidade ao mesmo tempo. mais contexto útil entra, menos adivinhação, menos retentativas.
o que os testes mostraram
contra a configuração baseada em grep, a codificação por referência usou 2,7x menos tokens de saída nas mesmas 8 tarefas. o custo total entre os braços foi de $11,18 da memória, $3,27 com grep, $1,58 com uma referência.
o grep parece a solução e na maioria das vezes não é. o grep diz ao agente onde procurar, mas o agente ainda precisa ler o arquivo no contexto para entendê-lo. um corpus neste estudo puxou 1,06 milhão de tokens de entrada fazendo exatamente isso. tokens mais baratos, uma pilha enorme deles, além de cada rodada do agente que você teve que esperar.
depois tem a execução maior. 13 bibliotecas escritas do zero para o estudo em 5 linguagens, cada uma compilando e passando seus próprios testes, cada uma carregando uma regra de tempo de execução que o compilador não pode avisar. construídas assim de propósito, porque você não pode testar a recuperação em código que o modelo já memorizou.
puro, da memória: 1 de 21 com recuperação: 21 de 21
$21,90 contra $3,38.
isso é um resultado diferente, não apenas mais barato.
o exemplo mais limpo lá é uma tarefa em Java. construir um ledger somente de acréscimo, selar antes de reproduzir, truncar para um checkpoint. da memória ele reinventou a coisa toda, 503 linhas, aproximadamente 36.000 tokens, semântica de truncamento errada, falhou no teste. com a referência ele escreveu quatro linhas. 103 tokens. passou.
a distribuição por linguagem mostra onde está o valor. Python de 14.752 para 214. C de 18.792 para 988. Java de 27.108 para 98. JavaScript foi apenas de 4.300 para 646, porque uma trie de prefixo é uma estrutura conhecida e o modelo já sabia metade da resposta.
desenvolvedores usando o XERJ no trabalho diário normal relatam aproximadamente 5x menos tokens. esse é autorrelatado e não benchmarkado, então trate como o piso e não o destaque.
por que um prompt mais longo não resolve isso
por um tempo, a resposta para uma saída ruim era sempre a mesma. escreva um prompt melhor. adicione mais contexto. explique a arquitetura.
e às vezes funciona.
mas um prompt é você descrevendo uma solução que ainda não escreveu. uma referência é uma solução que alguém já enviou e depurou. você não consegue descrever até chegar à lógica de repetição que só existe porque um mantenedor foi limitado por taxa às 3h da manhã e aplicou um patch às pressas.
o código já está lá. você não precisa explicar as decisões que foram tomadas para criá-lo.
encontrar a referência é o trabalho real
é aqui que a coisa desanda.
fazer manualmente significa abrir o github, ler repositórios que correspondem parcialmente, vasculhar pull requests antigos, depois abrir sua própria base de código de oito meses atrás e tentar lembrar como você nomeou o arquivo. quando você encontra algo utilizável, já poderia ter escrito a funcionalidade.
então a busca precisa ser barata, ou ninguém faz isso duas vezes.
é para isso que serve o XERJ. ele indexa código e permite que você pesquise pelo problema que está resolvendo, em vez de pelo nome do arquivo ou palavra-chave, e então puxa a implementação correspondente como uma referência que você pode passar diretamente para o claude. https://xerj.org
como executar
1) copie/cole o prompt de instalação na sessão do claude code
Instale o XERJ (docs:
https://xerj.org/llms.txt ), indexe as fontes deste projeto e configure a codificação por referência: clone e indexe os repositórios open-source mais próximos do que estamos construindo e pesquise como eles resolveram um problema antes de escrever código.
2) verifique a resposta do seu agente de codificação e sugira projetos para você clonar como referências
seja o que for que você está construindo, você sempre sabe quem mais está fazendo o mesmo. alguns projetos já serão encontrados pelo claude code nesta fase, e você pode adicionar mais por sua escolha. 5 a 10 geralmente é suficiente, mas depende do que você está codificando
3) crie o próximo recurso do produto e verifique os resultados
apenas deixe rolar e aproveite (ou não) os novos resultados. Você sempre pode voltar à codificação desperdiçadora, mas tenho certeza que você verá a diferença instantaneamente
4) mantenha-o funcionando e ajude a comunidade com seu feedback
cada tarefa que você conclui dessa forma se torna a referência para a próxima. a biblioteca se acumula. a qualquer momento
quando pular
se o modelo já conhece o código, isso é um custo extra e nada mais. no entanto, não é um caso frequente.
eles mediram isso também, no valkey e memcached, código público real no qual o claude definitivamente treinou. da memória pontuou 6 de 6 por $1,49. a recuperação pontuou 5 de 6 por $4,40. ficou em último lugar e custou três vezes mais do que não fazer nada.
então a linha é: código privado, proprietário ou genuinamente desconhecido de um lado, e tudo o que o modelo já consumiu do outro.
se a coisa que você está construindo nunca foi construída antes, não há nada para apontar e você volta a descrevê-la.
se a referência foi escrita contra uma versão de framework que você não está usando, custa mais do que economiza.
e se a tarefa tem quatro linhas, apenas escreva.
o que ainda está em aberto
as 13 bibliotecas foram construídas para o estudo, o que as torna desconhecidas por construção e também as torna pequenas. ninguém executou isso contra uma base de código privada genuinamente grande ainda. a expectativa é que a lacuna aumente lá, já que o custo do grep aumenta com o tamanho da árvore enquanto a recuperação permanece estável, mas isso é um palpite até que alguém meça.
todos os números acima vieram do benchmark publicado do próprio XERJ, dados brutos por execução no repositório deles. https://xerj.org/case-studies/reference-coding
a conclusão
você não precisa de um modelo diferente e não precisa sair do claude code.
você precisa parar de começar cada tarefa do zero, porque a coisa que você está construindo provavelmente já existe em algum lugar no seu repositório ou em um projeto open-source que a resolveu há dois anos.
se alguém já resolveu, entregue o código deles ao claude e deixe-o trabalhar a partir daí. e não te custou nada, apenas um prompt
