Se non vedi l'ora di leggere questo post, copia/incolla subito questo prompt in Claude Code / Codex / Grok per ottenerlo immediatamente:
Installa XERJ (documentazione:
https://xerj.org/llms.txt ), indicizza le sorgenti di questo progetto e configura il reference coding: clona e indicizza i repository open-source più vicini a ciò che stiamo costruendo, e cerca come hanno risolto un problema prima di scrivere codice.
molte persone usano Claude Code come se fosse un tirocinante costoso, ecco come renderlo più intelligente a ogni iterazione (davvero)
gli affidi un compito. fa qualche domanda. esamina il repository, fa supposizioni su come funziona il tuo codice, scrive un'implementazione, qualcosa si rompe. incolli l'errore. riscrive. qualcos'altro si rompe.
ognuna di queste iterazioni sono token che hai pagato.
e di solito Claude non è bloccato perché il problema è difficile. è bloccato perché gli hai fatto riscoprire una risposta che esiste già da qualche parte, o nel tuo repository o in un progetto open-source dove migliaia di sviluppatori hanno già trovato i casi limite.
XERJ lo ha testato correttamente. 8 compiti di codifica, 4 linguaggi, 16 esecuzioni per configurazione, conteggi di token presi direttamente da Claude -p.
a memoria: 260.916 token in output con un riferimento: 9.982 token in output
a memoria ha risolto 11 dei 16. con riferimento ha risolto tutti e 16.
quindi concentrati e leggi davvero questo ↓↓↓
il ciclo per cui stai pagando
una sessione normale funziona così.
descrivi cosa vuoi. Claude esplora. fa un'ipotesi sui tuoi pattern, sulla gestione degli errori, sulla struttura dei tuoi dati. scrive codice basandosi su quell'ipotesi. l'ipotesi era sbagliata da qualche parte, quindi la cosa si rompe, spieghi l'errore, riscrive, e si ricomincia finché l'output non corrisponde a ciò che avevi in mente all'inizio.
la gente interpreta questo ciclo come se Claude fosse scarso nella codifica. è il contrario. Claude è molto bravo a prendere un esempio funzionante e adattarlo a una nuova situazione. Il ciclo si verifica quando non c'è nessun esempio nella stanza, quindi passa la prima metà della sessione a ricostruirne uno.
i token di output sono quelli costosi, con un prezzo circa 5 volte superiore rispetto agli input sui modelli Claude. quindi ogni giro di questo ciclo viene fatturato alla tariffa massima.
un prompt e un riferimento non sono la stessa cosa
un prompt è un'istruzione. un riferimento è una prova.
puoi scrivere duemila parole descrivendo esattamente come dovrebbe comportarsi la cosa, e Claude deve comunque tradurre quella descrizione in un'implementazione, per poi indovinare tutto ciò che hai tralasciato.
un'implementazione funzionante contiene già le parti che non scriveresti mai
l'architettura, la gestione degli errori, la logica di retry, il caso limite che qualcuno ha incontrato in produzione due anni fa, il motivo per cui una funzione è suddivisa in quel modo
non hai menzionato quelle cose nel prompt perché non sapevi che fossero importanti.
ecco la versione più tagliente di questo concetto. un compilatore alla fine farà trapelare un nome di metodo. ti dirà che la funzione si chiama absorb e non push, e ti addebiterà da 20 a 25 volte i token per arrivarci. un compilatore non farà mai trapelare un contratto. Niente nel tuo toolchain ti dirà che questa struttura deve essere sigillata prima di poter essere letta. Quella regola vive nella testa di chi ha scritto la libreria e nel corpo della funzione, e nessuna quantità di scrittura di prompt la recupererà, perché non sai che esiste.
ecco perché questo riduce i token e aumenta la qualità allo stesso tempo. Più contesto utile in ingresso, meno ipotesi, meno tentativi.
cosa hanno mostrato i test
rispetto alla configurazione basata su grep, il reference coding ha utilizzato 2,7 volte meno token in output sugli stessi 8 compiti. Il costo totale tra le varianti è passato da $11,18 a memoria, $3,27 con grep, $1,58 con un riferimento.
grep sembra la soluzione, ma il più delle volte non lo è. grep dice all'agente dove guardare, poi l'agente deve comunque leggere il file nel contesto per capirlo. Un corpus in questo studio ha richiesto 1,06 milioni di token in input facendo proprio questo. Token più economici, ma una quantità enorme, più ogni iterazione dell'agente a cui hai assistito.
Poi c'è l'esecuzione più grande. 13 librerie scritte da zero per lo studio in 5 linguaggi, ognuna compilata e superata dai propri test, ognuna con una regola runtime che il compilatore non può segnalare. Costruite appositamente in questo modo, perché non puoi testare il recupero su codice che il modello ha già memorizzato.
a memoria: 1 su 21 con recupero: 21 su 21
$21,90 contro $3,38.
Questo è un risultato completamente diverso, non solo più economico.
L'esempio più chiaro in assoluto è un compito in Java. Costruire un registro append-only, sigillare prima della riproduzione, troncare a un checkpoint. A memoria lo ha reinventato da capo, 503 righe, circa 36.000 token, semantica di troncamento sbagliata, test fallito. Con il riferimento ha scritto quattro righe. 103 token. Superato.
La differenza per linguaggio mostra dove risiede il valore. Python da 14.752 a 214. C da 18.792 a 988. Java da 27.108 a 98. JavaScript è passato solo da 4.300 a 646, perché un prefix trie è una struttura nota e il modello conosceva già metà della risposta.
gli sviluppatori che usano XERJ nel lavoro quotidiano normale riportano circa 5 volte meno token. Questo è auto-dichiarato e non basato su benchmark, quindi consideralo come il minimo e non il dato principale.
perché un prompt più lungo non risolve il problema
Per un po', la risposta a un output scadente è stata sempre la stessa. Scrivi un prompt migliore. Aggiungi più contesto. Spiega l'architettura.
E a volte funziona.
Ma un prompt è la descrizione di una soluzione che non hai ancora scritto. Un riferimento è una soluzione che qualcuno ha già rilasciato e debuggato. Non puoi descrivere fino ad arrivare alla logica di retry che esiste solo perché un manutentore è stato limitato dal rate limiting alle 3 di notte e l'ha corretta in fretta e furia.
Il codice è già lì. Non devi spiegare le decisioni che ci sono dietro.
trovare il riferimento è il vero lavoro
Qui è dove le cose si complicano.
Farlo a mano significa aprire GitHub, leggere repository che corrispondono solo in parte, frugare tra vecchie pull request, poi aprire il tuo codice di otto mesi fa e cercare di ricordare come hai chiamato il file. Nel tempo in cui hai trovato qualcosa di utilizzabile, avresti potuto scrivere la funzionalità.
Quindi la ricerca deve essere economica, altrimenti nessuno la fa due volte.
Ecco a cosa serve XERJ. Indicizza il codice e ti permette di cercare in base al problema che stai risolvendo invece che per nome file o parola chiave, poi estrae l'implementazione corrispondente come riferimento che puoi passare direttamente a Claude. https://xerj.org
come eseguirlo
1) copia/incolla il prompt di installazione nella sessione di Claude Code
Installa XERJ (documentazione:
https://xerj.org/llms.txt ), indicizza le sorgenti di questo progetto e configura il reference coding: clona e indicizza i repository open-source più vicini a ciò che stiamo costruendo, e cerca come hanno risolto un problema prima di scrivere codice.
2) controlla la risposta del tuo agente di codifica e suggerisci progetti da clonare come riferimenti
qualunque cosa tu stia costruendo, sai sempre chi altro sta facendo la stessa cosa. Alcuni progetti saranno già trovati da Claude Code in questa fase, e puoi aggiungerne altri a tua scelta. 5-10 di solito sono sufficienti, ma dipende da cosa stai programmando
3) crea la prossima funzionalità del prodotto e verifica i risultati
lascialo fare e goditi (o meno) i nuovi risultati. Puoi sempre tornare alla codifica dispendiosa, ma sono sicuro che vedrai la differenza immediatamente
4) mantienilo funzionante e aiuta la community con il tuo feedback
ogni compito che completi in questo modo diventa il riferimento per il successivo. La libreria si accumula. Ogni volta che
quando saltarlo
se il modello conosce già il codice, questo è solo un costo aggiuntivo e nient'altro. Tuttavia, non è un caso frequente.
hanno misurato anche quello, su Valkey e Memcached, codice pubblico reale su cui Claude si è sicuramente addestrato. A memoria ha ottenuto 6 su 6 per $1,49. Con recupero ha ottenuto 5 su 6 per $4,40. È arrivato ultimo ed è costato tre volte di più che non fare nulla.
Quindi la linea di demarcazione è: codice privato, proprietario o genuinamente sconosciuto da un lato, e tutto ciò che il modello ha già assimilato dall'altro.
se la cosa che stai costruendo non è mai stata costruita prima, non c'è nulla a cui puntare e torni a descriverla.
se il riferimento è scritto per una versione del framework che non stai usando, costa più di quanto risparmia.
e se il compito è lungo quattro righe, scrivilo e basta.
cosa rimane aperto
le 13 librerie sono state costruite per lo studio, il che le rende sconosciute per costruzione e anche piccole. Nessuno ha ancora eseguito il test su un codice privato veramente grande. L'aspettativa è che il divario si allarghi lì, poiché il costo di grep aumenta con la dimensione dell'albero mentre il recupero rimane piatto, ma è un'ipotesi finché qualcuno non lo misura.
Ogni numero sopra proviene dal benchmark pubblicato di XERJ, con dati grezzi per esecuzione nel loro repository. https://xerj.org/case-studies/reference-coding
il messaggio finale
non hai bisogno di un modello diverso e non hai bisogno di lasciare Claude Code.
devi smettere di iniziare ogni compito da zero, perché la cosa che stai costruendo probabilmente esiste già da qualche parte nel tuo repository o in un progetto open-source che l'ha risolta due anni fa.
se qualcuno l'ha già risolta, passa a Claude il loro codice e lascia che lavori da lì. E non ti costa nulla, solo un prompt
