AIDiveIntro: un repo, due pack, ne resta uno
Superpowers e le skill di Matt Pocock sono i due pack di skill che la maggior parte degli sviluppatori Claude Code mette a confronto, e questo video li misura sulla stessa feature, sullo stesso repo, con il conto letto fase per fase. Superpowers (v6.4.2) include quindici skill e un hook SessionStart che le impone; il pack di Pocock (v1.3.1) ne include ventisette, nessun hook, e un Main Flow in sette passi digitati come slash command. L'unico confronto pubblico misurato dice che Superpowers costa molto meno, e il blog di ogni persona che ha cambiato pack dice che Pocock spreca meno token. In queste run erano vere entrambe le cose: Superpowers lasciato al suo hook è costato un quarto del Main Flow, e Superpowers guidato lungo tutto il suo loop è costato quasi il doppio del Main Flow, con gli stessi cinque test nascosti su cinque ogni volta. La domanda a cui risponde il video è quale pack resta, e quale singola fase decide il conto.
Due scommesse opposte: un hook che forza le skill contro nessun hook
Superpowers è un plugin con quindici skill e un hook. A ogni avvio di sessione l'hook inietta nel contesto l'intera skill using-superpowers (492 parole), e quella skill dice al modello: "If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill." Il loop che vende passa per quattro skill: brainstorming, writing-plans, executing-plans e una review alla fine. Una volta installato, l'hook dovrebbe instradare da solo una richiesta dentro quel loop.
Il pack di Matt Pocock è la scommessa opposta: ventisette skill e nessun hook. Non viene iniettato nulla; ogni passo è uno slash command che digiti tu. Il Main Flow è grill-with-docs, to-spec, to-tickets, implement, code-review, pr, retro. La skill grill-with-docs è lunga trentacinque parole e si limita a richiamare altre due skill; implement è di centotré parole e porta il flag disable-model-invocation: true, quindi il modello non può caricarla da solo. La frase di Matt sul suo loop, dal changelog della v1.3: "The agent loop is worse than a deterministic loop. But it is a good way to start with AFK work before your software factory is dialled in."
Entrambi i pack si installano come plugin di Claude Code oppure come file copiati, e il readme di Pocock è netto: scegline uno per agent, perché installarli entrambi ti dà ogni skill due volte. Nessuno aveva chiuso il confronto perché l'unico testa a testa misurato aveva fatto girare il pack di Pocock con cinque worker di implementazione su otto che non ricevevano mai la skill implement, e il post di ogni persona che ha cambiato pack ha opinioni e nessun numero.
Il banco: ledgerly, una richiesta, cinque test nascosti e la base senza pack
Il repo è ledgerly, una API di fatturazione inventata in Node e TypeScript puri: un livello di dominio, uno store su file JSON con migrazioni di schema, un livello HTTP e trentaquattro test verdi. La richiesta di feature sono tre righe, scritte come le scrive uno sviluppatore: aggiungere i pagamenti parziali, esporre l'importo pagato e il saldo, far continuare a funzionare il vecchio endpoint /pay, e ricordarsi che nello store ci sono dati di produzione. Un senior che legge si aspetta cinque cose che la richiesta non dice: il calcolo del denaro, la validazione, la migrazione dei file di produzione, i codici di errore giusti e i test. Quelle cinque sono diventate test di accettazione nascosti che il worker non vede mai; la patch di riferimento li passa tutti e cinque e il repo intatto non ne passa nessuno.
Ogni run è una copia fresca del repo, un worker Sonnet 5.5 headless, la stessa allow list di tool e un product owner da copione: un secondo modello headless senza tool che legge solo i cinque requisiti in parole semplici, risponde in modo secco e dice "go on" quando non gli viene chiesto nulla. Ogni token e ogni chiamata a una skill è registrato per turno. Due limiti dichiarati in anticipo: headless significa che nessuno corregge la rotta durante la run, e l'hook di Superpowers scatta solo al primo turno.
Claude Code liscio, senza pack, è la base rispetto alla quale è misurata ogni barra.
| Config (feature 1) | Test nascosti | Costo per run | Tempo reale | Righe modificate |
|---|---|---|---|---|
| bare, 3 run | 5/5, 5/5, 5/5 | $0.34 in media ($0.47, $0.27, $0.29) | 84.5 s | 142 |
Superpowers: cosa lancia l'hook da solo e quanto costa il loop completo
Lasciato al suo hook, Superpowers si comporta così: la richiesta viene incollata, l'hook scatta, il modello apre brainstorming, fa una o due domande e scrive il codice. writing-plans non è mai partita in tre run ed executing-plans nemmeno. Il risultato è cinque su cinque per circa cinquanta centesimi e circa due minuti, una volta e mezza la base liscia per lo stesso punteggio, con il solo brainstorming che pesa circa ventidue centesimi di quella cifra. Sei probe da un turno hanno mostrato che l'instradamento è casuale e non è un guasto di cablaggio: con il cablaggio reale del plugin brainstorming è scattata una volta su tre, con il cablaggio del banco due volte su tre.
Guidato a mano, con brainstorming, writing-plans ed executing-plans digitati come slash command in modalità Native (il default dalla 6.4.1), ogni run ha eseguito il loop intero. Di nuovo cinque su cinque, a circa $3.74 e dieci minuti a run: undici volte la base liscia, sette volte e mezza la run instradata dall'hook, per lo stesso punteggio nascosto.
| Fase di Superpowers (medie feature 1) | Costo |
|---|---|
| brainstorming | $0.166 |
| writing-plans | $0.266 |
| executing-plans | $3.307 |
| di cui la build TDD in sé | $0.974 |
| di cui il subagent reviewer dell'intero branch | $2.192 |
Il reviewer è la fase che spiega il conto del loop. La skill executing-plans lo lancia, con le sue parole, "on the most capable available model", e in ogni run quel modello era quello di fascia più alta. La skill lo chiama l'unico contesto fresco che l'intera run compra e dice di non saltarlo; su questa feature non ha trovato nulla che i test non avessero già provato. Sulla seconda feature lo stesso reviewer ha preso $1.602 di una run da $3.21, quindi non è un caso isolato ma il modo in cui è scritta la skill.
Il Main Flow, fase per fase: piani economici, una build costosa
Il pack di Pocock si guida nell'unico modo possibile: grill-with-docs fa le sue domande una alla volta, circa sette per run contro una o due del brainstorming di Superpowers; to-spec scrive la spec; to-tickets la taglia in ticket; implement costruisce tutti i ticket in un solo turno e richiama da sé tdd e code-review; pr scrive il testo della pull request. Ogni run ha invocato le stesse quattro skill nello stesso ordine (grilling, domain-modeling, tdd, code-review): il pack è deterministico sul suo percorso. Dodici turni del driver era il tetto del banco, e due run su tre lo hanno raggiunto prima di pr; l'unica run completa è finita su un corpo di PR, cosa che nessun altro pack ha lasciato dietro di sé.
| Fase del Main Flow (medie feature 1) | Costo |
|---|---|
| grill-with-docs | $0.204 |
| to-spec | $0.118 |
| to-tickets | $0.143 |
| implement | $1.125 |
| code-review | $0.439 |
| pr | $0.041 |
La prima metà di pianificazione costa meno di cinquanta centesimi ($0.465); implement e code-review sono tre quarti del conto. Il totale è circa $2.04 e sette minuti a run, cinque su cinque ogni volta: quattro volte la run di Superpowers instradata dall'hook e il quarantacinque per cento in meno del loop guidato di Superpowers. Il diff è più grande, circa 372 righe contro 142 della base liscia, con circa 28 test aggiunti contro 5, e i totali di token seguono i dollari: circa 4,5 milioni di token a run contro mezzo milione della base liscia, in gran parte cache read di un contesto lungo. Ciò che il Main Flow lascia dietro di sé è una spec, dei ticket e un corpo di PR, che un team può apprezzare più dei quaranta centesimi che costano; e il tetto di dodici turni è del banco, un umano andrebbe avanti.
Una feature più difficile: note di credito e l'unico bug consegnato
Cinque su cinque ovunque non dice niente, quindi sullo stesso repo è andata una seconda richiesta: le note di credito, due righe con cinque regole implicite. Non accreditare mai più del fatturato e mantenere giusto il report; migrare i file di produzione; una sola sequenza di numeri senza buchi; i codici di errore giusti; e annullare una fattura pagata tramite una nota di credito, con il vecchio test riscritto invece che cancellato. Un primo candidato più difficile è stato scartato perché la base liscia faceva comunque cinque su cinque. Prima la validazione: la patch di riferimento li passa tutti e cinque, il repo intatto nessuno, e una smoke run della base liscia ha preso quattro su cinque, quindi stavolta l'oracolo aveva i denti.
| Config (feature 2) | Test nascosti | Costo per run | Test aggiunti |
|---|---|---|---|
| bare, 2 run | 4/5, 5/5 | $0.41 in media | 5 |
| Superpowers guidato, 2 run | 5/5, 5/5 | $3.21 in media | 33 |
| Main Flow, 2 run | 5/5, 5/5 | $2.07 in media | 31 |
L'unico errore: la prima run della base liscia ha preso il numero della nota di credito prima di validare la richiesta, come fa la route di emissione fatture esistente, così una richiesta rifiutata ha bruciato un numero ed è stata emessa CN-0004 dove era dovuta CN-0002. I revisori contabili segnalano i buchi. Entrambi i loop l'hanno preso allo stesso modo, con il passo TDD che scrive un test per la sequenza prima che il codice esistesse; anche la seconda run della base liscia l'ha fatto giusto, per quarantacinque centesimi. Un errore in due run della base liscia è un dato, non un tasso. Quello che i loop comprano qui sono i test che lasciano, non un punteggio.
Combinare i due e la trappola del marketplace
Il thread più rumoroso sul tema dice che due pack installati come router si scontrano su nomi di slash command, hook di sessione e skill in competizione per lo stesso intento. Installati insieme nello stesso progetto e fatti girare lungo il Main Flow, l'hook di Superpowers ha iniettato il suo testo, i sei comandi di Pocock sono stati digitati e nessuna skill di Superpowers è stata invocata: cinque su cinque, $2.33, dentro la fascia del Main Flow. Due motivi: le skill di Pocock invocate dall'utente portano un flag che impedisce al modello di caricarle da solo, e i due pack non condividono nessun nome di skill. È una sola run, però; in un'altra sessione l'hook potrebbe ancora tirare dentro una skill di Pocock invocabile dal modello.
La vera trappola è la versione che ottieni. Il marketplace ufficiale dei plugin di Claude fissa il pack di Pocock alla 1.2.3, settantun commit indietro rispetto all'upstream v1.3.1. Quella copia fissata non ha implement-spec, né pr, né retro; due issue sono aperte dal 5 ottobre, e l'8 ottobre Matt ha chiesto ad Anthropic su X di aggiornarla: "All my users are stuck on v1.2." Lo stesso marketplace fissa Superpowers una patch indietro (6.4.1 contro v6.4.2). L'installer ti dà la release vera; il plugin ti dà quello che è fissato il giorno in cui installi. Controlla la riga della versione, non questo video.
La mappa delle fasi e il verdetto: Superpowers resta
Superpowers resta. Lasciato al suo hook è il percorso guidato più economico misurato: circa cinquanta centesimi per cinque su cinque, una volta e mezza la base liscia. Il suo loop completo è la cosa più costosa misurata, circa $3.74, e quasi tutta la distanza dal Main Flow è una sola fase, il reviewer dell'intero branch che executing-plans manda al modello più capace. Cambia quella riga, o passa un modello più economico, e il loop atterra vicino a $1.55, sotto i $2.04 del Main Flow. La fase che decide il conto è la review, non la pianificazione: né il grill di nessuno né il brainstorming di nessuno hanno spostato il numero. Il percorso instradato dall'hook ha un suo problema, perché l'instradamento è casuale (una volta su tre con il cablaggio del plugin); se il brainstorming ti interessa, digitalo.
Il Main Flow ottiene lo stesso punteggio con più artefatti a quattro volte il conto instradato dall'hook. La sua prima metà di pianificazione, da grill-with-docs a to-tickets, costa meno di cinquanta centesimi ed è l'unica cosa da prendere in prestito: installa il pack di Pocock con l'installer invece del plugin fissato, e digita grill-with-docs quando una richiesta è vaga. Combinarli non è costato nulla nella run.
| Mappa delle fasi | Decisione |
|---|---|
| Superpowers instradato dall'hook (brainstorming, TDD) | tenere |
| grill-with-docs, to-spec, to-tickets di Pocock ($0.465) | prendere in prestito |
| riga del modello del reviewer di executing-plans | cambiare |
I limiti, in chiaro: Sonnet 5.5 headless, due feature, diciannove run, un product owner da copione, un bug in diciannove run, consegnato dalla base liscia. Una feature più grande o un team possono dare più peso alla spec e ai ticket. La risorsa gratuita è il banco stesso: il repo inventato, i test nascosti, il driver e lo script del ledger per fase, così puoi far girare entrambi i pack sulla tua feature prima di perdere un giorno a migrare.
