Se você não pode esperar e ler este post, apenas copie/cole este prompt no 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. outra coisa 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 dos 16. a referência resolveu todos os 16.
então preste atenção e leia isso ↓↓↓
o ciclo pelo qual você está pagando
uma sessão normal acontece 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 baseado 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 na cabeça no início.
as pessoas leem esse ciclo como se o claude fosse ruim em codificação. é o oposto. o claude é muito bom em pegar um exemplo funcional e adaptá-lo a uma nova situação. o ciclo acontece quando não há exemplo na sala, 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 ciclo é 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 terá que 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 da maneira que é
você não mencionou essas coisas no prompt porque não sabia que elas importavam.
aqui está a versão mais aguda 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 25 vezes 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 repetições.
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, então o agente ainda tem que 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ê esperou.
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 livro-razão somente de acréscimo, selar antes de reproduzir, truncar para um ponto de verificação. 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 é auto-relatado, não comparado, 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 seu caminho até a lógica de repetição que só existe porque um mantenedor foi limitado por taxa às 3h da manhã e corrigiu às pressas.
o código já está lá. você não precisa explicar as decisões que o criaram.
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 seu próprio 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 pesquisa tem que 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 neste estágio, 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ê termina 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 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, ela 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
