AIDiveJetBrains dice no, la mia macchina dice 11,6 milioni
A luglio 2026 JetBrains ha speso circa 320 $ di credito API — 425 prove fatturate — per mettere alla prova rtk, un proxy per la shell che decine di migliaia di sviluppatori installano per risparmiare token in Claude Code. Il verdetto: le sessioni sono risultate più care del 7,6% per task. Due settimane prima lo stesso team aveva misurato caveman, la skill che promette di tagliare il 65% dei token, ottenendo 8,5%. Eppure sulla mia macchina rtk gain riporta 11,6 milioni di token risparmiati su 25.599 comandi.
Entrambe le serie di numeri sono vere. Semplicemente non misurano la stessa cosa: una è il costo per task completato, l'altra sono byte di output di bash.
| Numero | Cosa misura | Fonte |
|---|---|---|
| +7,6% per task (p=0,004) | Costo end-to-end di un task con rtk installato | JetBrains, 425 prove, ~320 $ |
| 8,5% dei token di output | Risparmio misurato di caveman su lavoro agentico | JetBrains, 82 task appaiati |
| 65% | Risparmio dichiarato da caveman | README di caveman |
| 11,6 M risparmiati (41,6%) | Byte di output di bash compressi da rtk | rtk gain, 25.599 comandi |
Questo è lo stack, quattro strumenti: graphify, rtk, Superpowers e caveman, 575.612 stelle GitHub in tutto al 2026-09-02. Ognuno tocca una fetta diversa del conto.
| Strumento | Stelle (2026-09-02) | Linguaggio | Licenza |
|---|---|---|---|
| Superpowers | 280.792 | Skill in Markdown | MIT |
| graphify | 113.946 | Python | Apache-2.0 |
| caveman | 102.548 | Go | MIT (skill) |
| rtk | 78.326 | Rust | Apache-2.0 |
Dove finiscono davvero i token
Un conto di Claude Code ha due lati. I token di input sono tutto ciò che il modello legge: l'output di ogni comando shell, il tuo prompt, il prompt di sistema e l'intera cronologia della conversazione rispedita a ogni chiamata. I token di output sono tutto ciò che il modello scrive.
La documentazione di rtk disegna esattamente quest'albero e aggiunge una frase che il post di lancio non aveva: «Un comando che mostra il 90% di byte di output in meno non rende la tua sessione più economica del 90%.»
JetBrains ha messo numeri sul lato lettura rigiocando 83 sessioni di riferimento, 1,9 milioni di caratteri di output degli strumenti.
| Fetta di ciò che il modello legge | Caratteri | Quota |
|---|---|---|
| Output shell che rtk può comprimere | 373.339 | 19,7% |
| Output shell per cui rtk non ha regole | 879.326 | 46,3% |
| Strumenti di lettura e ricerca che saltano del tutto rtk | 646.613 | 34,0% |
Solo un quinto di ciò che il modello legge è comprimibile da un proxy per la shell: gli strumenti integrati Read, Grep e Glob di Claude Code non passano mai dal hook di Bash.
Da qui la mappa dei quattro strumenti: graphify riduce ciò che l'agente legge, rtk riduce ciò che la shell restituisce, Superpowers riduce la cronologia che ogni task si porta dietro e sceglie quale modello se la porta, caveman riduce ciò che l'agente dice. Il lato lettura è la metà più grande del conto, quindi la classifica parte da lì.
graphify: percorrere nodi, non righe
graphify è una skill che trasforma una codebase — con documenti, schemi SQL, config e PDF — in un grafo di conoscenza interrogabile. Digiti /graphify . in Claude Code, Cursor, Codex o Gemini CLI, il progetto viene mappato una volta e da lì in poi l'agente interroga il grafo invece di grepparsi i file.
Il codice viene analizzato con AST di tree-sitter su circa 40 linguaggi: deterministico, nessuna chiamata a un LLM, nulla lascia la macchina. La build costa zero crediti LLM. Produce tre file: graph.html da esplorare a clic, GRAPH_REPORT.md e graph.json — il grafo stesso, interrogabile senza rileggere i tuoi file. Ogni nodo è un concetto (un file, una funzione, una classe) e ogni arco è etichettato EXTRACTED quando era esplicito nel sorgente o INFERRED quando è stato risolto da graphify. I nodi vengono raggruppati in sottosistemi con l'algoritmo di Leiden.
Il benchmark integrato, eseguito su un nostro progetto:
| Metrica | Valore |
|---|---|
| Nodi | 34.031 |
| Archi | 56.865 |
| Community rilevate | 967 |
| Provenienza degli archi | 76% EXTRACTED · 24% INFERRED |
| Lettura ingenua dell'intero corpus | 1.701.550 parole ≈ 2.268.733 token |
| Query media sul grafo | ~24.702 token |
| Riduzione | 91,8× token in meno per query |
Domanda per domanda la forbice è ampia: 679,1× su «what is the main entry point», 34,0× su «what connects the data layer to the api».
Due limiti. Il confronto è contro il leggere tutto, e una sessione guidata da grep non è mai costata tanto, quindi il guadagno reale è minore. E il grafo invecchia — aggiornalo con graphify update <path>, --watch o gli hook git — mentre il passaggio semantico su documenti, PDF e immagini chiama davvero un modello e spende davvero token.
Installazione: uv tool install graphifyy (il nome del pacchetto ha due y), poi graphify install.
rtk: il proxy per la shell sotto processo
rtk è un proxy CLI tra Claude Code e la tua shell. Comandi comuni come ls, cat o git status restituiscono un mucchio di rumore che l'agente deve leggere come token di input: permessi dei file, barre di avanzamento, cento righe di test superati. rtk esegue lo stesso comando e restituisce una versione compatta: un solo binario Rust, oltre 100 comandi supportati, meno di 10 ms di overhead. Un hook PreToolUse riscrive ogni chiamata Bash idonea (git status → rtk git status) prima dell'esecuzione, così l'agente non deve ricordarsene.
Il post di lancio dell'autore rivendicava 10,2 M di token risparmiati in due settimane, 89,2%, con esempi come cargo test che passa da 155 righe a 3. La nostra dashboard dopo 25.599 comandi:
| Comando | Chiamate | Token risparmiati | Tasso |
|---|---|---|---|
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% |
| Totale | 25.599 | 11,6 M | 41,6% |
Poi il processo. JetBrains ha installato rtk esattamente com'è distribuito e ha eseguito 86 task due volte su claude-sonnet-5.
| Risultato JetBrains | Valore |
|---|---|
| Comandi shell che rtk può riscrivere | 349 su 1.056 (1 su 3) |
| Tetto del risparmio totale | ~3% del conto |
| Costo per task, reasoning effort basso | +7,6% (p=0,004) |
| Turni per task | +13,8% (p=0,03) |
| Costo per task, effort alto | ±0% |
| Qualità dei task | Invariata |
Il README di rtk ora lo dice chiaramente: fino al 90% dell'output di bash, «che non è lo stesso che tagliare il conto del 90%», e i suoi conteggi sono stimati come bytes / 4.
Verdetto: è gratis, la compressione è reale e, nelle parole di JetBrains, «spesso di buon gusto». Tienilo per le sessioni cariche di bash; non aspettarti che sposti il conto.
Superpowers: prima il quadro, poi task troppo piccoli per fallire
Superpowers è il plugin per Claude Code di Jesse Vincent — 280.792 stelle, quattordici skill, un solo comando di installazione (/plugin install superpowers@claude-plugins-official). Risparmia token senza comprimere nulla.
Tutto inizia dalla skill di brainstorming, che si apre con un cancello rigido: niente codice, niente scaffolding, nessuna skill di implementazione finché non è approvata un'intenzione esplicita. Quando la skill si carica, l'agente diventa un compagno di brainstorming e, in pratica, alcuni pezzi del progetto vengono ripensati prima di costruire qualsiasi cosa. È la fase più importante, perché i token più cari sono quelli spesi a costruire la cosa sbagliata.
La skill classifica il lavoro come spike, modifica circoscritta o modifica architetturale, e la regola è scritta nel file: «Nel dubbio tra due strade, prendi quella più pesante.» Nomina persino la modalità di fallimento, con una sezione anti-pattern intitolata «Too Simple To Need Approval». La strada architetturale produce una spec che convalidi e poi un piano di implementazione.
L'affidabilità viene dal piano. La skill writing-plans taglia il lavoro in passi da una sola azione, di 2-5 minuti: scrivi il test che fallisce, eseguilo per verificare che fallisca, scrivi il codice minimo che lo fa passare, riesegui i test, committa. I piani sono scritti presupponendo che l'ingegnere abbia zero contesto. Un task così piccolo entra in una finestra di contesto fresca con margine, quindi l'agente non arriva mai alla fine di un task con la finestra satura — ed è dalla finestra satura che nasce il codice allucinato.
Il limite è la cerimonia. Il file dice che scala con il task, ma il cancello scatta anche su una correzione di una riga, e anche quelli sono token.
Superpowers: un task, un subagent, un modello su misura
Poi il piano parte, e la matematica dei token cambia. Un task, un subagent. Ogni subagent parte con un contesto fresco che contiene solo il suo task, mai la cronologia della sessione, così la finestra dell'orchestratore resta piccola e quella del subagent resta pulita. Dopo ogni task l'orchestratore rivede il risultato: OK, task successivo; non OK, la correzione torna a un subagent. Massimo cinque round per task — i round da 1 a 3 riprendono l'implementatore originale, il round 4 passa il lavoro a un implementatore nuovo su un modello più capace, al round 5 decide l'orchestratore stesso.
La regola che paga tutto è la scelta del modello: «Usa il modello meno potente in grado di gestire ciascun ruolo, per contenere i costi.» L'orchestratore valuta la difficoltà di ogni task e sceglie il modello corrispondente.
| Tipo di task | Livello di modello |
|---|---|
| Meccanico, ben specificato; il piano contiene già il codice | Modello più economico / piccolo |
| Coordinamento su più file, debugging | Modello standard |
| Architettura, revisione finale del branch | Modello più capace |
| Modello non indicato | Eredita il modello della sessione |
Una sfumatura dallo stesso file: «Il numero di turni batte il prezzo del token.» Un modello economico che impiega tre turni non è economico. In pratica è questo che rende Opus e Fable utilizzabili su un piano Pro da 20 $: il modello costoso tocca una manciata di task invece dell'intera sessione.
L'ultimo vantaggio è la documentazione. Ogni spec e ogni piano è un file markdown salvato in docs/superpowers/specs/ e docs/superpowers/plans/YYYY-MM-DD-<feature-name>.md, committato a fine lavoro. Nella pipeline di questo canale, la migrazione all'attuale motore video è una spec più un piano da quattordici task che si può ancora aprire, citare in una nuova sessione e ampliare. Nulla di ciò che gli agenti hanno fatto resta fuori dal tracciamento.
caveman e lo stile Concise: dire meno
L'ultima fetta è ciò che l'agente dice. Gli agenti narrano — «certo», «felice di aiutarti», «il problema che stai riscontrando è probabilmente dovuto a» — e sono token di output per niente.
caveman è una skill di Julius Brussee, 102.548 stelle, che fa parlare l'agente come un cavernicolo: via articoli, riempitivi, convenevoli e cautele, e si segue lo schema [cosa] [azione] [motivo]. [passo successivo]. Codice, comandi, percorsi di file e messaggi d'errore esatti non vengono mai toccati; solo la prosa attorno. Ha tre livelli (/caveman lite|full|ultra) e un hook SessionStart che la attiva all'avvio.
La sua tabella, dieci prompt attraverso l'API di Claude, dà in media 1.214 token di output senza la skill e 294 con — 65%, con un caso migliore all'87% e un peggiore al 22%.
Il bagno di realtà lo offre il README stesso: la skill accorcia solo l'output, i token di input e di ragionamento non cambiano, e le sue regole costano circa 1-1,5 k token di input a ogni turno. JetBrains l'ha misurata su 82 task agentici appaiati, per circa 106 $ di credito.
| caveman | Dichiarato | Misurato (JetBrains) |
|---|---|---|
| Risparmio sui token di output | 65% | 8,5% (592 k → 542 k) |
| Impatto sulla qualità | — | Nessun degrado rilevabile (test dei segni p=0,82) |
Lo scarto è strutturale: l'output di un agente è per lo più codice e chiamate a strumenti, che caveman giustamente lascia stare. La raccomandazione di JetBrains: «usala se ti piace. È divertente e non ti costa nulla di misurabile in qualità.»
E da Claude Code v2.1.237 esiste un equivalente integrato, lo stile di output Concise: Claude «parte dal risultato, salta preamboli e narrazione e mantiene le risposte brevi per impostazione predefinita». Si sceglie in /config → Output style; viene salvato in .claude/settings.local.json e ha effetto dopo /clear o in una nuova sessione. Un limite comune: gli stili di output valgono solo per la conversazione principale — un subagent esegue il proprio prompt di sistema.
Verdetto: cosa sposta il conto, cosa sposta i margini
Classifica in base a ciò che ogni strumento sposta davvero, con il costo che si porta dietro.
| Posizione | Strumento | Cosa sposta | Effetto misurato | Il costo |
|---|---|---|---|---|
| 1 | Superpowers | La cronologia per task + quale modello la legge | Modello costoso su una manciata di task invece che sull'intera sessione | Un cancello su ogni task, anche sulle correzioni di una riga |
| 2 | graphify | Ciò che l'agente legge | 91,8× token in meno per query rispetto a una lettura ingenua del corpus (nostro progetto) | Il grafo invecchia; il passaggio semantico spende token |
| 3 | rtk | Byte di output di bash | Tetto ~3% del conto; +7,6% per task a effort basso nel test JetBrains | Solo 1 comando shell su 3 ha una regola |
| 4 | caveman / Concise | La prosa che l'agente scrive | 8,5% dei token di output, nessuna perdita di qualità | ~1-1,5 k token di input a ogni turno |
Vince Superpowers, e non per merito di una compressione: un contesto fresco per task e il modello più economico in grado di fare il lavoro cambiano cosa viene letto e chi lo legge. graphify è secondo perché leggere meno è la metà più grande del conto. rtk è reale, gratuito e innocuo, ma due terzi dei comandi shell e tutte le letture di file gli passano accanto. caveman, o lo stile Concise ora incluso in Claude Code, rifila la fetta più piccola.
Tutti e quattro si installano gratis — graphify e rtk con Apache-2.0, Superpowers con MIT, la skill caveman con MIT. Più di 570.000 stelle dicono che la gente vuole un miracolo. La versione onesta è una classifica.
