
Lo scenario caotico del tooling JavaScript
Runtime, package manager, bundler, test runner, linter: ogni categoria ha tre o quattro candidati e sempre più toolchain che le riuniscono. Una mappa per orientarsi, e qualche criterio per scegliere pensando anche agli agenti.
Emanuele Nardi
Fino a qualche anno fa configurare un progetto JavaScript voleva dire aprire un webpack.config.js, scegliere a mano il transpiler (Babel), il test runner e il linter e far andare d'accordo tre file di configurazione. Era faticoso, ma le scelte erano poche, e il lavoro vero era far funzionare tutto.
Adesso le cose funzionano quasi da sole, e la fatica si è spostata. Gli strumenti sono tantissimi e si pestano i piedi a vicenda: capire cosa esiste, che problema risolve ciascuno e quando conviene cambiare porta via più tempo della configurazione. Qui provo a farmene una mappa.
Cosa è cambiato
Il primo cambiamento è il consolidamento: strumenti nati per un mestiere ora ne fanno quattro. Bun mette insieme runtime, package manager, bundler e test runner. Vite+, arrivato alla versione 1.0 il 28 settembre 2026 con licenza MIT, espone un solo comando, vp, sopra Vite 8, Vitest e Oxc. Secondo i suoi autori una sola dipendenza, vite-plus, prende il posto dei pacchetti di Vite, Vitest, ESLint, Prettier, tsup e Turborepo nel package.json.
Il secondo è la velocità. Molti strumenti sono stati riscritti in linguaggi nativi come Rust, Go e Zig. Il post di Vite+ riporta che Oxlint gira da 50 a 100 volte più veloce di ESLint e che Oxfmt è fino a 30 volte più veloce di Prettier, secondo i benchmark del progetto Oxc. Il compilatore nativo di TypeScript 7, scritto in Go, secondo l'annuncio del team è dieci volte più veloce: tra 8 e 12 volte sulle build complete, con il codice di VS Code che passa da 125,7 a 10,6 secondi. Sono numeri dei produttori, e li prendo come ordine di grandezza.
Il terzo, il più recente, sono gli agenti, che hanno cambiato il criterio con cui scelgo.
Agentic coding, loop e harness
Sono tre parole che ormai si incontrano ovunque, e io le uso così:
- Agentic coding: l'AI legge il repository, modifica i file, lancia comandi e ne interpreta il risultato.
- Agentic loop: il ciclo che l'agente ripete finché il lavoro non è finito.
- Harness: tutto ciò che sta attorno al modello e lo rende utile sul codice. Gli strumenti che può usare (shell, file, ricerca), i permessi, la gestione del contesto, gli hook, i sub-agenti, le istruzioni del progetto, i connettori. Claude Code, che uso ogni giorno, è un harness.
Un giro del loop va così:
- L'agente legge il codice e capisce cosa cambiare.
- Modifica i file.
- Lancia controllo dei tipi, lint e test.
- Legge l'output.
- Corregge e riparte, finché la verifica passa.
Il terzo passo è il più importante: gli strumenti del progetto sono i sensori dell'agente, l'unico modo che ha per accorgersi di aver sbagliato. Funzionano bene se sono veloci, ripetibili e se dicono in modo leggibile cosa non va. Un controllo dei tipi che impiega un minuto, o un test instabile, allungano ogni giro del loop e lo rendono più costoso. Così quando scelgo uno strumento penso anche all'agente che dovrà usarlo.
AGENTS.md o CLAUDE.md) scrivi i comandi da lanciare e cosa vuol dire "finito", per esempio lint senza avvisi, tipi corretti e test verdi. È il modo più semplice per dare all'agente i suoi sensori.La mappa
Lo schema divide la catena degli strumenti in sette categorie, con i nomi principali di ciascuna. A sinistra, le toolchain tutto in uno: scegline una per vedere in quali categorie prende il posto di qualcosa, e con quale comando.
- Runtime
- Node.js, Deno, Bun
- Package manager
- npm, Yarn, pnpm
- Bundler e dev server
- Webpack, esbuild, Rspack, Vite
- Test runner
- Jest, node:test, Vitest
- Lint e formattazione
- ESLint, Prettier, Biome, Oxlint
- Compilatore e tipi
- Babel, SWC, tsc, TypeScript 7
- Monorepo e task
- Script a mano, Turborepo, Nx
Lo schema è un componente Vue Flow: puoi aprirlo a schermo intero e scegliere la toolchain da evidenziare.
Ogni categoria risponde a un problema:
| Categoria | Che problema risolve |
|---|---|
| Runtime | Esegue JavaScript fuori dal browser |
| Package manager | Installa le dipendenze e ne risolve le versioni |
| Bundler e dev server | Trasforma il codice, lo serve in sviluppo e lo impacchetta |
| Test runner | Esegue i test e dice cosa si è rotto |
| Lint e formattazione | Trova errori e uniforma lo stile |
| Compilatore e tipi | Controlla i tipi e trasforma TypeScript in JavaScript |
| Monorepo e task | Orchestra più pacchetti e riusa il lavoro con la cache |
Le toolchain tutto in uno
Nello schema ne ho messe tre, e ognuna la pensa a modo suo.
Bun è un unico eseguibile: bun run esegue il codice, bun install installa i pacchetti, bun test lancia i test e bun build impacchetta. Esegue TypeScript direttamente, ma senza controllare i tipi. A dicembre 2025 Anthropic ha annunciato di averlo acquisito, dichiarando che resta open source con licenza MIT. Lo segnalo perché Anthropic produce anche Claude Code.
Deno è un runtime con molto già dentro: test (deno test), lint e formattazione (deno lint, deno fmt), controllo dei tipi (deno check) e un lanciatore di task.
Vite+ sta sopra gli strumenti che già esistono: gli autori precisano che non è un framework né un package manager e che non sostituisce Vite, su cui si appoggia. vp env gestisce la versione di Node.js, vp install usa il package manager che hai scelto, vp dev e vp build usano Vite 8 con Rolldown, vp check formatta, fa il lint e controlla i tipi in un solo passaggio (con Oxfmt e Oxlint), vp test lancia Vitest e vp run gestisce i task.
Come scegliere senza impazzire
Una scelta giusta per tutti non c'è. Io mi faccio queste domande:
- Che problema ho davvero? Uno strumento nuovo non è un motivo sufficiente. Se i test girano in pochi secondi, cambiare test runner non mi dà niente.
- Quanto costa uscirne? Un linter con regole e plugin scritti per il progetto è difficile da sostituire. Un package manager si cambia in un pomeriggio.
- Quanto è maturo, e chi lo mantiene? Versione stabile, licenza, un team che non sparisca. Anche le acquisizioni e i cambi di mano vanno messi nel conto.
- Quanto costa un giro del loop? Se lavori con un agente, misura quanto ci mette ad accorgersi di aver sbagliato.
- Uno alla volta. Cambio una cosa, guardo cosa succede, poi passo alla successiva. Cambiandone tre insieme non saprei più cosa ha migliorato o rotto il progetto.
Il mio stack, oggi
Per i progetti nuovi parto sempre da Nuxt e Vite, con pnpm come package manager, Vitest per i test unitari e Playwright per i pochi flussi che meritano un test end-to-end. Uso ESLint, perché è lì che esistono i plugin che mi servono, per esempio quello per le classi di Tailwind, e Fallow per trovare codice inutilizzato e duplicati. Con Claude Code come harness, i comandi di controllo li scrivo nel file di istruzioni del progetto.
La conosco bene, costa poco abbandonarla, e ci aggiungo una novità alla volta.
I nomi e i numeri di questo articolo sono aggiornati a novembre 2026, e in questo campo invecchiano in fretta.
Fonti
- Announcing Vite+ 1.0, VoidZero, 28 settembre 2026
- Anthropic acquires Bun, Anthropic, 3 dicembre 2025
- Announcing TypeScript 7.0, TypeScript DevBlog (Daniel Rosenwasser), 8 luglio 2026