Blog
Lo scenario caotico del tooling JavaScript
SviluppoToolingAI19 gen 2026 (aggiornato il 12 nov 2026) — 7 min di lettura

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

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ì:

  1. L'agente legge il codice e capisce cosa cambiare.
  2. Modifica i file.
  3. Lancia controllo dei tipi, lint e test.
  4. Legge l'output.
  5. 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.

Nel file di istruzioni del progetto (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
Bun: Runtime, package manager, test runner e bundler in un solo eseguibile. Linea continua: ne prende il posto. Tratteggiata: lo copre in parte o delega.

Lo schema è un componente Vue Flow: puoi aprirlo a schermo intero e scegliere la toolchain da evidenziare.

Ogni categoria risponde a un problema:

CategoriaChe problema risolve
RuntimeEsegue JavaScript fuori dal browser
Package managerInstalla le dipendenze e ne risolve le versioni
Bundler e dev serverTrasforma il codice, lo serve in sviluppo e lo impacchetta
Test runnerEsegue i test e dice cosa si è rotto
Lint e formattazioneTrova errori e uniforma lo stile
Compilatore e tipiControlla i tipi e trasforma TypeScript in JavaScript
Monorepo e taskOrchestra 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.

Che uno strumento possa sostituirne un altro non vuol dire che convenga farlo. Bun può fare da bundler, ma un'app Nuxt non cambia bundler per questo: usa Vite di default, con il suo server di sviluppo e i suoi plugin. Anche TypeScript 7 non va ancora bene per tutti. Secondo l'annuncio ufficiale la 7.0 non ha un'API programmatica (la 7.1 dovrebbe averla), quindi strumenti come Volar e i flussi con Vue, MDX, Astro e Svelte per ora restano su TypeScript 6. Le linee tratteggiate nello schema indicano questi casi.

Come scegliere senza impazzire

Una scelta giusta per tutti non c'è. Io mi faccio queste domande:

  1. 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.
  2. Quanto costa uscirne? Un linter con regole e plugin scritti per il progetto è difficile da sostituire. Un package manager si cambia in un pomeriggio.
  3. 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.
  4. Quanto costa un giro del loop? Se lavori con un agente, misura quanto ci mette ad accorgersi di aver sbagliato.
  5. 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

build 631 • 009a823

© 2026 Emanuele Nardi