Passa al contenuto principale

La scelta dello stack è una leva di costo per gli agenti

Intermedio
What you'll learn
  • Leggere l'unico benchmark che ha messo numeri veri su «quale framework costa meno a un agente»
  • Individuare le tre cose che il titolo sbaglia — compresa una tariffa per token che va al contrario
  • Capire perché il conto dei token segue il LOOP dell'agente, non la dimensione del codice che scrive
  • Sapere quale singolo numero si compone davvero nel corso della vita del progetto (non è il costo per build)
  • Vedere il confondente non controllato che può spiegare diverse righe, e perché è una leva che possiedi
  • Ripetere la stessa misura sul tuo stack, con un protocollo che regge alla varianza degli LLM

Per vent'anni scegliere un framework frontend ha significato barattare esperienza di sviluppo e dimensione del bundle. Gli agenti hanno aggiunto un terzo asse di cui nessuno aveva numeri: quanto costa a un modello lavorare in questa codebase?

Il 28 ottobre 2026 Nolan Lawson ha pubblicato il primo tentativo serio di misurarlo. Il risultato è finito in prima pagina su Hacker News e ha generato una settimana di post «Angular costa l'86% in più». Il titolo è vero. È anche la cosa meno interessante del dataset.

Questa pagina è la lettura attenta. Tre risultati nei dati contraddicono il modo in cui viene citato, e la leva più azionabile di tutto l'esperimento è una che il benchmark non intendeva nemmeno testare.

L'esperimento​

Dodici stack, un'app, cinque esecuzioni ciascuno.

Guided walkthrough1 of 4
  1. Costruire un'app Pokémon su PokéAPI — ricerca, filtri, visualizzazione dei tipi e dati sulle mosse attraverso più versioni di gioco. L'autore la descrive come ricca di contenuto con interattività minima. Tienilo a mente: decide a cosa si generalizzano i risultati.

Ecco il risultato centrale — costo, token e dimensione del codice, ordinati per costo mediano:

StackCosto (mediana)Intervallo di costoTokenRighe di codiceJS spedito
Hono+htmx$2.67$2.23–$3.194.26 M1,37018 KiB
Astro$2.76$2.16–$3.634.13 M1,4610 KiB
Nuxt$2.82$2.39–$4.253.85 M1,41584 KiB
Vanilla (Vite)$2.98$2.24–$3.375.00 M1,4927 KiB
Next.js$3.14$2.58–$4.134.99 M1,539142 KiB
Qwik$3.27$2.35–$3.805.64 M1,74440 KiB
TanStack Start$3.54$3.11–$3.967.07 M1,697118 KiB
SolidStart$3.79$2.84–$4.817.13 M1,63040 KiB
React Router$3.81$2.82–$3.977.58 M1,564115 KiB
SvelteKit$4.28$3.59–$4.658.53 M1,61136 KiB
Gracile+Lit$4.65$3.92–$5.079.04 M1,7178 KiB
Angular$4.97$3.19–$6.829.76 M2,00993 KiB

Il wall-clock ha seguito da vicino il costo: Astro 8,2 min e Hono+htmx 8,6 min all'estremo veloce, Angular 17,2 min a quello lento.

Risultato 1: il conto dei token segue il loop, non l'artefatto​

Confronta le forbici:

  • Token: 3.85 M (Nuxt) → 9.76 M (Angular) = 2,54x
  • Righe di codice: 1,370 (Hono+htmx) → 2,009 (Angular) = 1,47x

Se i token fossero per lo più l'agente che scrive codice, questi due rapporti sarebbero vicini. Non lo sono — la forbice dei token è più del 70% più larga di quella del codice. I 5,9 milioni di token in più consumati da Angular non sono finiti nelle 639 righe in più che ha prodotto.

Sono finiti nel loop: leggere file, rileggerli dopo ogni modifica, eseguire la suite di conformità, interpretare i fallimenti e riprovare. Il conto dei token di un agente è dominato da quante volte deve girare in tondo e da quanto contesto si trascina dietro ogni volta. L'artefatto finale è un errore di arrotondamento.

Questo ribalta l'intera domanda. «Quale framework produce meno codice» è un proxy debole. La vera domanda è quale framework permette a un agente di convergere in meno turni — una funzione di quanto è prevedibile la struttura dei file, quanto sono leggibili i messaggi d'errore, quanta cerimonia richiede una modifica e quanto bene gli idiomi correnti del framework sono rappresentati nei dati di training.

What you'll learn
  • I due fallimenti netti di Angular sono un fallimento di loop, non di qualità del codice. In entrambe le esecuzioni l'agente ha costruito un'app SSR che rifiutava connessioni non-localhost, nonostante le istruzioni specificassero un deploy dietro reverse proxy. È l'agente che interpreta male un vincolo di deploy — il tipo di cosa che un CLAUDE.md più preciso risolve, e un motivo per classificare i fallimenti invece di limitarsi a contarli.

Risultato 2: la tariffa effettiva per token va al contrario​

È il risultato assente da ogni riassunto che ho letto, e salta fuori dividendo due colonne che nessuno ha diviso.

Prendi costo mediano ÷ token mediani per ogni riga:

StackTokenCosto$/Mtok effettivo
Nuxt3.85 M$2.82$0.73
Astro4.13 M$2.76$0.67
Hono+htmx4.26 M$2.67$0.63
Next.js4.99 M$3.14$0.63
Vanilla5.00 M$2.98$0.60
Qwik5.64 M$3.27$0.58
SolidStart7.13 M$3.79$0.53
Gracile+Lit9.04 M$4.65$0.51
Angular9.76 M$4.97$0.51

La tariffa scende al salire del numero di token, quasi in modo monotono. I framework che bruciano più token pagano meno per token.

Perché? Opus 5.5 ha un listino di $4 per MTok di input fresco, $20 di output e $0,20 per le letture da cache — un moltiplicatore del 5% per le cache read dove lo standard di piattaforma è il 10%. Una tariffa mista tra $0,51 e $0,73 sta appena sopra il pavimento di $0,20 delle cache read e circa sei volte sotto la tariffa dell'input fresco. C'è un solo mix che produce quei numeri: la stragrande maggioranza dei token contati sono letture da cache. Abbina cache read pure a circa l'11% di traffico fresco e output e arrivi a $0,62; portalo all'8% e arrivi a $0,50 — il numero di Angular.

Il meccanismo è questo. Ogni passo in più in una lunga sessione agentica riproduce lo stesso contesto crescente. Quella riproduzione sono cache read a $0,20. Il token marginale in un framework pesante costa un ventesimo del primo token, ed è per questo che i 2,54x di token di Angular diventano solo un conto di 1,86x.

Due conseguenze che contano più della classifica:

  1. Il prompt caching fa il lavoro pesante in ogni riga. Questo benchmark è in buona parte una misura del volume di cache read. Qualunque setup di agente senza caching efficace vedrebbe le stesse forbici di token tradursi in un conto fino a 20x più caro — e il divario tra framework si allargherebbe invece di comprimersi. Se vuoi sapere la tua vera esposizione a uno stack verboso, controlla prima il tuo cache hit rate. Vedi prompt caching tra i provider e economia del prompt caching.
  2. Il costo per build sottostima sistematicamente la penalità di uno stack pesante, perché il caching assorbe esattamente ciò che gli stack pesanti generano. Il che porta al numero che davvero si compone.
Watch out
  • Questa aritmetica è mia, non dell'autore. Costo mediano ÷ token mediani non è la mediana dei rapporti per singola esecuzione, e le mediane di due colonne possono venire da esecuzioni diverse — quindi trattale come cifre approssimative e direzionali, non come verità per singola esecuzione. La direzione è coerente su tutte e dodici le righe, ed è ciò che la rende degna di essere riportata.

Risultato 3: gli intervalli si sovrappongono, quindi la maggior parte delle coppie adiacenti non prova nulla​

L'esecuzione più economica di Angular è costata $3,19. L'esecuzione più cara di Hono+htmx è costata $3,19. Identiche.

Nuxt andava da $2,39 a $4,25; Astro da $2,16 a $3,63; SolidStart da $2,84 a $4,81. Su cinque esecuzioni stocastiche, la varianza dentro il framework è paragonabile — e spesso maggiore — alle differenze tra framework. Le affermazioni difendibili da questo dataset sono grossolane:

  • Difendibile: il cluster MPA snello (Hono+htmx, Astro, Nuxt) costa meno del cluster pesante (SvelteKit, Gracile+Lit, Angular), di circa 1,5–1,9x.
  • Non difendibile: «Astro batte Nuxt», «SolidStart batte React Router» o qualunque altra coppia vicina. Quei divari sono dentro il rumore.

L'autore lo dice lui stesso — l'obiettivo era «non scrivere il benchmark definitivo» ma mostrare che una selezione basata sulle evidenze è possibile. I post che hanno convertito le sue mediane in classifiche hanno lasciato cadere gli intervalli, e gli intervalli sono dove vive l'onestà. È la stessa disciplina che la nostra pagina leggere i benchmark AI applica alle classifiche dei modelli: una mediana senza dispersione è una sensazione travestita da numero.

Il confondente non controllato — e la leva che possiedi davvero​

Sepolta nella metodologia c'è la cosa più azionabile dell'esperimento. A ogni agente è stato offerto il server MCP o la skill ufficiale del framework. Se li abbia usati è variato enormemente:

StackEsecuzioni che hanno usato l'MCP / skill ufficiale
SvelteKit5 su 5
Next.js1–2 su 5 (hanno letto file di guida)
TanStack Start2 su 5 (hanno scoperto le skill)
Nuxt0 su 5 (MCP mai usato)

Fermati a pensarci. Su 60 esecuzioni, una frazione significativa della varianza potrebbe non essere «quanto costa questo framework» ma «l'agente ha notato la documentazione che stava lì a portata di mano?». SvelteKit ha usato il suo MCP ogni volta ed è comunque finito vicino all'estremo caro; Nuxt non ha mai toccato il suo MCP ed è arrivato terzo più economico. Questi due fatti da soli dovrebbero impedire a chiunque di leggere questa tabella come una classifica pulita dei framework.

L'inversione pratica: la scoperta della documentazione è una variabile che controlli completamente, mentre la scelta del framework è una che per lo più non puoi controllare. Prima di migrare una codebase per risparmiare $2 a build, rendi la documentazione impossibile da perdere:

  • Metti le convenzioni del framework direttamente in CLAUDE.md invece di sperare che una skill venga scoperta — vedi il nostro template CLAUDE.md e il generatore.
  • Dichiara esplicitamente i vincoli di deploy. I due fallimenti di Angular erano esattamente questa lacuna.
  • Se pubblichi un server MCP o una skill per il tuo framework o la tua libreria interna, misura se gli agenti la invocano davvero. Uno strumento usato in 0 esecuzioni su 5 è, economicamente, uno strumento che non esiste.

Il numero che si compone: costo di modifica, non costo di build​

Una build avviene una volta. Ogni task successivo paga una tassa proporzionale a quanto codice l'agente deve portare nel contesto per capire ciò che sta modificando.

Questo fa delle righe di codice la quantità duratura, e la forbice è più stretta di quella dei token ma permanente: 1,370 per Hono+htmx contro 2,009 per Angular — circa una tassa di contesto fissa più piccola del 32% su ogni task futuro, per sempre.

Combinalo col Risultato 2 e ottieni il modello mentale giusto. Al momento della build il caching comprime la differenza tra stack. Nell'arco della manutenzione paghi di nuovo la differenza di LOC a ogni task, e gran parte della lettura di base del repo è input fresco al primo turno di ogni nuova sessione, non un cache hit. Il divario una tantum di $2,30 è rumore; un terzo di codice in più da portarsi dietro per tre anni no.

Watch out
  • Non leggerlo come «scegli sempre lo stack più snello». Le righe di codice sono un termine della funzione di costo. Un framework che previene una classe di bug di sincronizzazione dello stato può far risparmiare molti più loop dell'agente di quanto costi in contesto — e un commento in cima a HN ha fatto esattamente questo ragionamento, sostenendo che htmx richiede test estesi per intercettare bug di stato sotto codegen AI mentre la forte presenza di React nei dati di training aiuta gli agenti su app davvero interattive. È un effetto reale che l'app di questo benchmark, ricca di contenuto, non può vedere.

Cosa questo non dimostra​

I limiti sono portanti. L'autore ne elenca la maggior parte; ho aggiunto quelli che la copertura mediatica ha lasciato cadere.

LimitePerché conta
Un solo tipo di appRicca di contenuto, interattività minima. Dashboard, editor, giochi e app real-time ribaltano i compromessi che qui favoriscono le MPA.
Lighthouse favorisce le MPAIn particolare l'LCP punisce il routing lato client. Che gli stack snelli vincano sia sul costo sia su Lighthouse è in parte un artefatto di misura, non due vittorie indipendenti.
Cinque esecuzioni, alta varianzaNon bastano a separare righe adiacenti. Lo stesso Lighthouse è stato incoerente tra le esecuzioni, scegliendo elementi LCP diversi.
Un modello, un livello di effortOpus 5.5 a effort alto. Un modello più economico o un effort più basso cambia sia il conto assoluto sia, plausibilmente, l'ordinamento.
Solo Chromium + throttling mobileCPU 4x, Slow 4G, un browser, un laptop.
Nessun task di manutenzione misuratoIl costo composto sostenuto sopra è un'inferenza dalla colonna LOC, non un risultato misurato. Nessuno ha ancora eseguito il benchmark di manutenzione.
Tempo umano non prezzatoLa mediana di 17,2 minuti di Angular contro gli 8,2 di Astro è un divario di ~9 minuti. Se un ingegnere supervisiona l'esecuzione, quei nove minuti di attenzione plausibilmente costano più dell'intero delta di $2,30 di token. Ottimizzare il conto API ignorando il wall-clock è la funzione obiettivo sbagliata.

Ripetilo sul tuo stack​

La cosa più forte di questo benchmark è che è riproducibile — sia l'harness sia i risultati grezzi sono pubblici. La tua codebase non è un'app Pokémon, quindi i numeri che dovrebbero guidare le tue decisioni sono i tuoi.

Guided walkthrough1 of 6
  1. Non una build da zero — è il caso che farai meno spesso. Scegli tre ticket chiusi di recente, di dimensione tipica, e usali come insieme di task. I benchmark greenfield misurano ciò che fai una volta sola.

Misura il costo per un agente di un task sul tuo stack

I want to measure how expensive a task is for you to complete in this codebase,
so I can compare stacks and tooling with evidence instead of vibes.

Task: <paste a real, closed ticket of typical size>

Rules:
1. Work only inside this repo. Do not install new dependencies.
2. Stop when the existing test suite passes for the changed behaviour.
3. Do not optimise for token use — work the way you normally would. I am
 measuring the honest cost, not a best case.

When you are done, report exactly:
- Files read, and how many times each was re-read
- Number of test/build invocations
- Lines added and removed
- Anything in the repo that made you go around an extra time: missing docs,
surprising file layout, an unclear error message, a convention you had to
infer. Be specific and name the file.

That last list is what I am really after. Rank it by how many turns each item cost you.

L'ultima domanda è quella che rende. L'agente è l'unica entità che sa quale delle tue convenzioni gli è costata tre loop in più, e te lo dirà se glielo chiedi. Quelle risposte si convertono in righe di CLAUDE.md, e una buona riga di CLAUDE.md vale più di una migrazione di framework.

Premi Invio o Spazio per girare la carta. Usa le frecce sinistra e destra per spostarti tra le carte.Termine mostrato.
1 / 8

Check yourself

0/5
  1. Il benchmark mostra che Angular ha consumato 2,54x i token di Nuxt, ma il suo conto è stato solo 1,86x. Cosa spiega la compressione?
  2. Quale confronto del dataset è davvero difendibile?
  3. Il tuo team vuole migrare da un framework che qui ha ottenuto un brutto punteggio. Prima di impegnarsi, qual è il controllo a più alta leva?
  4. Quale quantità dovrebbe pesare di più in una decisione di stack per un progetto di lunga durata nell'era degli agenti?
  5. Perché «gli stack snelli hanno vinto sia sul costo sia su Lighthouse» è un risultato più debole di come suona?
Key takeaways
  • Il costo in token di un agente segue il numero di loop, non le righe prodotte: una forbice di token di 2,54x su una forbice di codice di 1,47x.
  • La tariffa effettiva per token va al contrario ($0,73 → $0,51/Mtok) perché i passi extra dell'agente si fatturano come cache read da $0,20. Il caching assorbe la maggior parte della penalità — controlla il tuo hit rate prima di fidarti di qualunque cifra di costo per build.
  • Riporta gli intervalli o non riportare nulla. La migliore esecuzione di Angular ha eguagliato la peggiore di Hono+htmx, quindi sopravvive solo l'affermazione grossolana snello-vs-pesante.
  • La scoperta della documentazione non era controllata e può spiegare diverse righe. È anche gratis da sistemare e interamente tua da controllare — fallo prima di una migrazione.
  • Ottimizza la quantità che si compone: la dimensione del codice risultante, pagata a ogni task futuro, non il conto di build una tantum.
  • Un divario di ~9 minuti di wall-clock sotto supervisione umana plausibilmente costa più dell'intero delta di $2,30 di token. Non ottimizzare il conto API in isolamento.

Fonti e approfondimenti​

Avanti​