{"id":35820,"date":"2026-05-18T14:37:32","date_gmt":"2026-05-18T12:37:32","guid":{"rendered":"https:\/\/www.codemotion.com\/magazine\/?p=35820"},"modified":"2026-05-18T15:06:32","modified_gmt":"2026-05-18T13:06:32","slug":"framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando","status":"publish","type":"post","link":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/","title":{"rendered":"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all&#8217;era agentica?"},"content":{"rendered":"\n<figure class=\"wp-block-pullquote\"><blockquote><p>Convenzioni, compiler intelligence e server boundaries non sono dettagli ergonomici: sono la nuova interfaccia tra le codebase e gli agenti AI che ci lavorano dentro.<\/p><\/blockquote><\/figure>\n\n\n\n<p>Lo so, lo so\u2026 <strong>La domanda, cos\u00ec formulata, \u00e8 davvero provocatoria<\/strong>. Implica che esista una soglia oltre la quale gli agenti AI rendono superflua le astrazioni che chiamiamo &#8220;framework&#8221;. Inoltre, la domanda implica che la storia recente di <a href=\"https:\/\/react.dev\">React<\/a>, <a href=\"https:\/\/nextjs.org\">Next.js<\/a>, <a href=\"https:\/\/angular.dev\">Angular<\/a>, <a href=\"https:\/\/svelte.dev\">Svelte<\/a>, <a href=\"https:\/\/astro.build\">Astro<\/a>, <a href=\"https:\/\/solidjs.com\">Solid<\/a> e compagnia bella sia la storia di strumenti pensati per umani che ora dovrebbero farsi da parte.<\/p>\n\n\n\n<p>\u00c8 un framing comodo per produrre titoli, e quasi inutile per capire cosa stia davvero succedendo nell&#8217;ecosistema JavaScript.<\/p>\n\n\n\n<p>Fatta questa doverosa premessa, togliamoci il cappellino di stagnola e cominciamo ad osservare che quello che sta accadendo \u00e8 pi\u00f9 interessante che spettacolare. I framework non stanno arretrando. <strong>Stanno cambiando interlocutore<\/strong>. Per quindici anni hanno ottimizzato un&#8217;unica metrica, la <em>Developer Experience<\/em>, perch\u00e9 il loro utilizzatore principale era un essere umano davanti a un IDE.<\/p>\n\n\n\n<p><strong>Da circa due anni questa premessa ha smesso di essere vera<\/strong>. Una quota crescente del codice che entra in produzione viene generata, modificata o orchestrata da un agente AI: <a href=\"https:\/\/cursor.com\" target=\"_blank\" rel=\"noreferrer noopener\">Cursor<\/a>, <a href=\"https:\/\/claude.ai\/code\" target=\"_blank\" rel=\"noreferrer noopener\">Claude Code<\/a>, <a href=\"https:\/\/github.com\/features\/copilot\" target=\"_blank\" rel=\"noreferrer noopener\">GitHub Copilot<\/a>, <a href=\"https:\/\/devin.ai\">Devin<\/a>, <a href=\"https:\/\/windsurf.com\">Windsurf<\/a>, quello che preferite. L&#8217;utilizzatore del framework non \u00e8 pi\u00f9 solo un umano. \u00c8 un sistema software con i suoi limiti, i suoi bias, e le sue &#8220;preferenze&#8221; (se cos\u00ec vogliamo chiamarle).<\/p>\n\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"683\" src=\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/dx-vs-adx-1024x683.png\" alt=\"\" class=\"wp-image-35822\" srcset=\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/dx-vs-adx-1024x683.png 1024w, https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/dx-vs-adx-300x200.png 300w, https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/dx-vs-adx-768x512.png 768w, https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/dx-vs-adx-600x400.png 600w, https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/dx-vs-adx.png 1536w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p>I framework che sopravvivranno ai prossimi cinque anni sono quelli che stanno ridisegnando le proprie convenzioni <em>anche<\/em> per questo nuovo utilizzatore. Non devono sostituire l&#8217;umano ma devono far lavorare l&#8217;agente AI e l&#8217;umano <em>insieme<\/em>. Il punto centrale di questo articolo \u00e8 che il framework, nell&#8217;era agentica, smette di essere una &#8220;comodit\u00e0 per chi scrive&#8221; e diventa qualcosa di strutturalmente diverso: uno <strong>strato di compressione cognitiva<\/strong> tra l&#8217;intento (umano o agente) e la macchina.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-da-dx-a-adx\">Da DX a ADX<\/h2>\n\n\n\n<p>Per anni la metrica dominante \u00e8 stata la <em>Developer Experience<\/em> (<strong>DX<\/strong> per gli amici). Tempo di setup, ergonomia delle API, qualit\u00e0 degli errori, hot reload, autocomplete. Era una metrica calibrata su un cervello umano che leggeva codice un pezzo alla volta.<\/p>\n\n\n\n<p>Nell&#8217;ultimo anno (o gi\u00f9 di l\u00ec) sta emergendo una metrica parallela che, in mancanza di nomi migliori, possiamo chiamare <em>Agent Developer Experience<\/em> (abbreviamola in <strong>ADX<\/strong>). Cos&#8217;\u00e8 questa ADX?<\/p>\n\n\n\n<p>Riguarda quanto \u00e8 facile, per un agente AI:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>navigare una codebase<\/li>\n\n\n\n<li>capire cosa modificare<\/li>\n\n\n\n<li>fare la modifica giusta al primo tentativo<\/li>\n\n\n\n<li>non rompere quello che non vede o che ancora non &#8220;conosce&#8221;<\/li>\n<\/ul>\n\n\n\n<p>L&#8217;ADX non \u00e8 il contrario di DX: ne \u00e8 una derivata, se vogliamo usare termini matematici\u2026 Le caratteristiche che rendono un codice leggibile da un umano competente (convenzioni stabili, dipendenze esplicite, tipi end-to-end, side effect localizzati) sono le stesse che lo rendono manipolabile da un LLM. <strong>Ma con una differenza di scala<\/strong>: quando il codice viene generato in massa, anche piccole ambiguit\u00e0 si amplificano in errori enormi e poco controllabili.<\/p>\n\n\n\n<p>Sicuramente l&#8217;avete visto succedere: partite da una richiesta semplice tipo &#8220;creami un hook React&#8221; e dopo 20 minuti siete persi in test, linter che non passano e &#8220;spaghetti code&#8221; indecifrabile<\/p>\n\n\n\n<p>I framework moderni stanno reagendo a questa pressione in modo abbastanza coerente: file-based routing, server components, typed routing\u2026 Sono tutte risposte allo stesso problema: ridurre la variabilit\u00e0 dell&#8217;output. Far s\u00ec che, per un dato intento, esista un <em>piccolo numero di soluzioni plausibili<\/em>, possibilmente una sola.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-la-tesi-della-compressione-cognitiva\">La tesi della compressione cognitiva<\/h2>\n\n\n\n<p>Per capire perch\u00e9 questa convergenza non sia casuale, conviene fare un passo indietro. Un sistema software complesso \u00e8 caratterizzato dall&#8217;entropia delle decisioni che chi ci lavora deve prendere:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Dove va quel componente?<\/li>\n\n\n\n<li>Come si fa fetch dei dati?<\/li>\n\n\n\n<li>Dove inizia il server?<\/li>\n\n\n\n<li>Come si dichiara una rotta?<\/li>\n<\/ul>\n\n\n\n<p>Ogni domanda ammette molte risposte tecnicamente equivalenti ma cognitivamente onerose.<\/p>\n\n\n\n<p>Un framework opinionato risponde a queste domande prima ancora che vengano poste. Riduce la varianza. Comprime lo spazio delle decisioni. Per un team umano questo \u00e8 ergonomia. Per un agente AI \u00e8 qualcosa di pi\u00f9 cruciale: \u00e8 la condizione perch\u00e9 il suo output sia <strong>verificabile<\/strong>.<\/p>\n\n\n\n<p>Ripetiamolo come un mantra: <strong>un LLM non &#8220;comprende&#8221; il codice nel senso forte del termine<\/strong>. Un LLM ragiona su pattern, su distribuzioni statistiche di token, su strutture sintattiche apprese durante il training. Un LLM funziona meglio dove le strutture sono pi\u00f9 rappresentate e pi\u00f9 stabili.<\/p>\n\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"683\" src=\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/compressione-cognitiva-1024x683.png\" alt=\"\" class=\"wp-image-35821\" srcset=\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/compressione-cognitiva-1024x683.png 1024w, https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/compressione-cognitiva-300x200.png 300w, https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/compressione-cognitiva-768x512.png 768w, https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/compressione-cognitiva-600x400.png 600w, https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/compressione-cognitiva.png 1536w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p>Un App Router di Next.js, con la sua gerarchia <code>app\/[segment]\/page.tsx<\/code>, \u00e8 facile da rappresentare per un modello: a un percorso URL corrisponde un file, a un layout corrisponde un altro file, a un loading state un altro ancora. Una SPA React con <code>react-router<\/code> configurato a mano in un <code>App.tsx<\/code>, con lazy import sparsi e provider annidati, richiede al modello di ricostruire una mappa che il framework ha rifiutato di imporre. Il primo caso \u00e8 leggibile. Il secondo va interpretato.<\/p>\n\n\n\n<p><strong>La differenza, in produzione, non \u00e8 teorica<\/strong>. Si misura nel numero di file che l&#8217;agente tocca per implementare una feature, nella probabilit\u00e0 di modificare il file giusto al primo tentativo, nella quantit\u00e0 di codice che il senior deve riscrivere durante il review.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-anatomia-di-un-framework-ai-native\">Anatomia di un framework &#8220;AI-native&#8221;<\/h2>\n\n\n\n<p>Ora che abbiamo chiarito cosa sia l&#8217;ADX e perch\u00e9 sia utile, possiamo analizzare le cinque caratteristiche stanno emergendo come pattern comuni nei framework adatti all&#8217;era agentica.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-file-based-conventions-comprensibili-senza-documentazione\">File-based conventions comprensibili senza documentazione<\/h3>\n\n\n\n<p>Next.js App Router, <a href=\"https:\/\/nuxt.com\" target=\"_blank\" rel=\"noreferrer noopener\">Nuxt<\/a>, <a href=\"https:\/\/kit.svelte.dev\">SvelteKit<\/a>, <a href=\"https:\/\/start.solidjs.com\">SolidStart<\/a>, Astro, <a href=\"https:\/\/qwik.dev\">Qwik City<\/a>, <a href=\"https:\/\/tanstack.com\/start\">TanStack Start<\/a>: tutti convergono su filesystem dove la posizione del file \u00e8 essa stessa informazione. Questo non \u00e8 un dettaglio estetico. \u00c8 un&#8217;API leggibile da chi non ha letto il manuale (umano o macchina che sia). Una codebase con <code>app\/dashboard\/[id]\/page.tsx<\/code> e <code>app\/dashboard\/[id]\/layout.tsx<\/code> racconta la propria architettura senza bisogno di un file README.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-reattivita-esplicita-non-magica\">Reattivit\u00e0 esplicita, non magica<\/h3>\n\n\n\n<p>I compiler-first framework (come Svelte) hanno un vantaggio strutturale: il codice scritto ha una traduzione formale, deterministica, in qualcosa che l&#8217;analisi statica pu\u00f2 manipolare. Le runes di Svelte 5 e i signals di Solid e Angular sono modelli di reattivit\u00e0 <em>dichiarativi<\/em>: non dipendono dall&#8217;ordine di chiamata di una funzione (come gli hook React) o da regole di linting per essere corretti. Per un LLM che deve modificare la reattivit\u00e0 di un componente, la differenza \u00e8 enorme. Una closure stale in un <code>useEffect<\/code> \u00e8 un bug classico che gli agenti continuano a produrre. Una rune dichiarata con <code>$state<\/code> \u00e8 quasi impossibile da sbagliare allo stesso modo. \u00c8 esattamente questo tipo di prevedibilit\u00e0 che il lavoro sulla <em>memoization<\/em> <a href=\"https:\/\/react.dev\/learn\/react-compiler\" target=\"_blank\" rel=\"noreferrer noopener\">sta cercando di recuperare a livello di compilatore<\/a>.<\/p>\n\n\n\n<blockquote class=\"wp-block-quote is-layout-flow wp-block-quote-is-layout-flow\">\n<p>it automatically optimizes your React application by handling memoization for you, eliminating the need for manual <code>useMemo<\/code>, <code>useCallback<\/code>, and <code>React.memo<\/code><\/p>\n<\/blockquote>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-tipi-end-to-end\">Tipi end-to-end<\/h3>\n\n\n\n<p><a href=\"https:\/\/tanstack.com\/router\/latest\">TanStack Router<\/a> ha trasformato il routing tipizzato da curiosit\u00e0 a feature di prima classe: i parametri di percorso, i search params, i loader sono tipi che fluiscono attraverso l&#8217;app. Next.js sta arrivando allo stesso punto in modo diverso, con <a href=\"https:\/\/nextjs.org\/docs\/app\/api-reference\/config\/next-config-js\/typedRoutes\" target=\"_blank\" rel=\"noreferrer noopener\">typed routes<\/a> e Server Actions tipizzate attraverso il boundary.<\/p>\n\n\n\n<p>Per un agente, la tipizzazione end-to-end \u00e8 una rete di sicurezza che evita un&#8217;intera classe di output plausibili-ma-sbagliati.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-server-boundaries-esplicite\">Server boundaries esplicite<\/h3>\n\n\n\n<p>I React Server Components, le Server Actions di Next.js e React Router 7, i loader\/action di TanStack Start, le <code>+page.server.ts<\/code> di SvelteKit sono tutti tentativi di rendere <em>lessicalmente visibile<\/em> dove finisce il client e dove inizia il server.<\/p>\n\n\n\n<p>Senza questa &#8220;dichiarazione&#8221;, ogni componente \u00e8 potenzialmente tutto: un agente che genera codice deve indovinare. Con la separazione esplicita, il problema scompare.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-metadata-strutturati-e-introspezione\">Metadata strutturati e introspezione<\/h3>\n\n\n\n<p><a href=\"https:\/\/docs.astro.build\/en\/guides\/content-collections\/#defining-datatypes-with-zod\" target=\"_blank\" rel=\"noreferrer noopener\">Astro Content Collections con schema Zod<\/a>, frontmatter tipizzato, manifesti di build, route manifest\u2026 Sono tutti modi di esporre la struttura dell&#8217;app in un formato machine-readable. Su questo si innesta MCP, il <a href=\"https:\/\/modelcontextprotocol.io\" target=\"_blank\" rel=\"noreferrer noopener\">Model Context Protocol<\/a> che sta diventando lo standard di fatto per esporre contesto e capability agli agenti. Un MCP server che pubblica le rotte, i layout e le server functions di un&#8217;app Next.js \u00e8 la differenza tra un agente che fa <code>grep<\/code> e un agente che fa <code>query<\/code>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-framework-per-framework-senza-tifo\">Framework per framework, senza tifo<\/h2>\n\n\n\n<p>Vale la pena fare qualche esempio di quello che abbiamo appena detto. Per ognuno esploreremo lo stesso task minimale (una rotta che recupera una lista di utenti da un&#8217;API e la renderizza) perch\u00e9 \u00e8 il modo pi\u00f9 onesto di confrontare come i diversi framework si stanno adattando all&#8217;ADX. La domanda implicita \u00e8 sempre la stessa: <strong>se a un agente chiedo &#8220;aggiungi una pagina \/users che lista gli utenti&#8221;, quante decisioni deve prendere da solo, e quanto \u00e8 probabile che le prenda bene?<\/strong><\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-next-js-app-router\">Next.js (App Router)<\/h3>\n\n\n\n<p>Next.js \u00e8 l&#8217;esempio &#8220;principe&#8221; del framework che si sta trasformando in protocollo. App Router, Server Actions, integrazione nativa con l&#8217;AI SDK di Vercel, supporto MCP in espansione, generatori come <a href=\"https:\/\/v0.app\/\">v0<\/a> che producono direttamente codice Next.js: \u00e8 un sistema dove le scelte di runtime, build, edge e data fetching sono pre-confezionate per un certo modello mentale.<\/p>\n\n\n\n<p>Il rovescio della medaglia \u00e8 la concentrazione: <strong>scegliere Next.js significa scegliere, in larga misura, l&#8217;opinione di Vercel sul futuro del web<\/strong>. Per molti team \u00e8 un trade-off ragionevole. Per altri \u00e8 una preoccupazione legittima, e il dibattito ricorrente sull&#8217;utilizzabilit\u00e0 dei React Server Components fuori dal recinto Next ne \u00e8 il sintomo evidente.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-1\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\"><span class=\"hljs-comment\">\/\/ app\/users\/page.tsx<\/span>\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">default<\/span> <span class=\"hljs-keyword\">async<\/span> <span class=\"hljs-function\"><span class=\"hljs-keyword\">function<\/span> <span class=\"hljs-title\">UsersPage<\/span>(<span class=\"hljs-params\"><\/span>) <\/span>{\n  <span class=\"hljs-keyword\">const<\/span> users = <span class=\"hljs-keyword\">await<\/span> fetch(<span class=\"hljs-string\">'https:\/\/api.example.com\/users'<\/span>)\n    .then(<span class=\"hljs-function\">(<span class=\"hljs-params\">r<\/span>) =&gt;<\/span> r.json())\n\n  <span class=\"hljs-keyword\">return<\/span> (\n    <span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n      {users.map((u) =&gt; <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span> <span class=\"hljs-attr\">key<\/span>=<span class=\"hljs-string\">{u.id}<\/span>&gt;<\/span>{u.name}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>)}\n    <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span><\/span>\n  )\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-1\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: il path del file <em>\u00e8<\/em> l&#8217;URL, il componente \u00e8 server-side per default (\u00e8 un async server component), il fetch non richiede <code>useEffect<\/code>, n\u00e9 react-query, n\u00e9 uno store. Un agente che riceve &#8220;aggiungi una pagina \/users che lista gli utenti&#8221; sa esattamente dove creare il file, quale signature usare, e che il fetch \u00e8 server-side senza scelte da fare. Lo spazio delle soluzioni plausibili \u00e8 minuscolo.<\/p>\n\n\n\n<p>Modificare la pagina per aggiungere caching, streaming o revalidation richiede di toccare lo stesso file con primitive ben note (<code>fetch<\/code> con <code>next.revalidate<\/code>, <code>&lt;Suspense&gt;<\/code>, <code>revalidatePath<\/code>). Alta densit\u00e0 di convenzione per riga di codice.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-react-senza-framework\">React senza framework<\/h3>\n\n\n\n<p>React &#8220;nudo e crudo&#8221; \u00e8 la posizione che l&#8217;era agentica sta penalizzando di pi\u00f9. Non perch\u00e9 React sia obsoleto, ma perch\u00e9 la combinazione &#8220;React + Vite + react-router + tanstack-query + zustand + libreria di form + libreria di tabelle&#8221; \u00e8 una collezione di scelte locali ottime che non comunicano tra loro.<\/p>\n\n\n\n<p><strong>Ogni progetto \u00e8 quasi artigianale<\/strong>. Ogni agente, davanti a uno di questi progetti, deve ricostruire convenzioni che non esistono (o che sono nella test dello sviluppatore che ha creato il progetto) e lavorare con &#8220;quello che c&#8217;\u00e8&#8221;.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-2\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\"><span class=\"hljs-comment\">\/\/ src\/App.tsx<\/span>\n<span class=\"hljs-keyword\">import<\/span> { BrowserRouter, Routes, Route } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'react-router-dom'<\/span>\n<span class=\"hljs-keyword\">import<\/span> { QueryClient, QueryClientProvider, useQuery } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@tanstack\/react-query'<\/span>\n\n<span class=\"hljs-keyword\">const<\/span> qc = <span class=\"hljs-keyword\">new<\/span> QueryClient()\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">function<\/span> <span class=\"hljs-title\">UsersPage<\/span>(<span class=\"hljs-params\"><\/span>) <\/span>{\n  <span class=\"hljs-keyword\">const<\/span> { data, isLoading } = useQuery({\n    <span class=\"hljs-attr\">queryKey<\/span>: &#91;<span class=\"hljs-string\">'users'<\/span>],\n    <span class=\"hljs-attr\">queryFn<\/span>: <span class=\"hljs-function\"><span class=\"hljs-params\">()<\/span> =&gt;<\/span> fetch(<span class=\"hljs-string\">'\/api\/users'<\/span>).then(<span class=\"hljs-function\">(<span class=\"hljs-params\">r<\/span>) =&gt;<\/span> r.json()),\n  })\n  <span class=\"hljs-keyword\">if<\/span> (isLoading) <span class=\"hljs-keyword\">return<\/span> <span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">div<\/span>&gt;<\/span>Loading\u2026<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">div<\/span>&gt;<\/span><\/span>\n  <span class=\"hljs-keyword\">return<\/span> <span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>{data.map((u: any) =&gt; <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span> <span class=\"hljs-attr\">key<\/span>=<span class=\"hljs-string\">{u.id}<\/span>&gt;<\/span>{u.name}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>)}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span><\/span>\n}\n\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">default<\/span> <span class=\"hljs-function\"><span class=\"hljs-keyword\">function<\/span> <span class=\"hljs-title\">App<\/span>(<span class=\"hljs-params\"><\/span>) <\/span>{\n  <span class=\"hljs-keyword\">return<\/span> (\n    <span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">QueryClientProvider<\/span> <span class=\"hljs-attr\">client<\/span>=<span class=\"hljs-string\">{qc}<\/span>&gt;<\/span>\n      <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">BrowserRouter<\/span>&gt;<\/span>\n        <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">Routes<\/span>&gt;<\/span>\n          <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">Route<\/span> <span class=\"hljs-attr\">path<\/span>=<span class=\"hljs-string\">\"\/users\"<\/span> <span class=\"hljs-attr\">element<\/span>=<span class=\"hljs-string\">{<\/span>&lt;<span class=\"hljs-attr\">UsersPage<\/span> \/&gt;<\/span>} \/&gt;\n        <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">Routes<\/span>&gt;<\/span>\n      <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">BrowserRouter<\/span>&gt;<\/span>\n    <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">QueryClientProvider<\/span>&gt;<\/span><\/span>\n  )\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-2\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: niente di standard. L&#8217;agente deve scoprire da solo dove sono dichiarate le rotte (un componente <code>&lt;Routes&gt;<\/code> da qualche parte? un file <code>routes.ts<\/code>? lazy import?), quale fetcher \u00e8 in uso (react-query? swr? <code>fetch<\/code> dritto? un client API custom?), dove vivono i provider, se c&#8217;\u00e8 SSR. Ogni scelta \u00e8 arbitraria, ogni progetto \u00e8 diverso. La probabilit\u00e0 che l&#8217;agente generi codice &#8220;plausibile ma incoerente con il resto&#8221; \u00e8 alta, e cresce con la dimensione del repository.<\/p>\n\n\n\n<p>La vera domanda da porsi nel 2026 non \u00e8 pi\u00f9 &#8220;quale UI library&#8221;, ma &#8220;quale framework attorno a React&#8221;.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-angular\">Angular<\/h3>\n\n\n\n<p><strong>Angular sta vivendo una rinascita silenziosa che molti commentatori stanno ignorando<\/strong>. <a href=\"https:\/\/angular.dev\/guide\/components\" target=\"_blank\" rel=\"noreferrer noopener\">Standalone components<\/a>, signals, control flow nativo, defer block: l&#8217;Angular del 2026 \u00e8 un framework profondamente diverso da quello degli <code>NgModule<\/code>, ed \u00e8 (paradossalmente) uno dei pi\u00f9 LLM-friendly in circolazione.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-3\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\"><span class=\"hljs-comment\">\/\/ app\/users\/users.component.ts<\/span>\n<span class=\"hljs-keyword\">import<\/span> { Component, inject } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@angular\/core'<\/span>\n<span class=\"hljs-keyword\">import<\/span> { HttpClient } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@angular\/common\/http'<\/span>\n<span class=\"hljs-keyword\">import<\/span> { toSignal } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@angular\/core\/rxjs-interop'<\/span>\n\n@Component({\n  <span class=\"hljs-attr\">standalone<\/span>: <span class=\"hljs-literal\">true<\/span>,\n  <span class=\"hljs-attr\">template<\/span>: <span class=\"hljs-string\">`\n    &lt;ul&gt;\n      @for (u of users(); track u.id) {\n        &lt;li&gt;{{ u.name }}&lt;\/li&gt;\n      }\n    &lt;\/ul&gt;\n  `<\/span>,\n})\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">UsersComponent<\/span> <\/span>{\n  private http = inject(HttpClient)\n\n  users = toSignal(\n    <span class=\"hljs-keyword\">this<\/span>.http.get&lt;{ <span class=\"hljs-attr\">id<\/span>: number; name: string }&#91;]&gt;(<span class=\"hljs-string\">'\/api\/users'<\/span>),\n    { <span class=\"hljs-attr\">initialValue<\/span>: &#91;] }\n  )\n}\n\n<span class=\"hljs-comment\">\/\/ app.routes.ts<\/span>\n<span class=\"hljs-keyword\">import<\/span> { Routes } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@angular\/router'<\/span>\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">const<\/span> routes: Routes = &#91;\n  {\n    <span class=\"hljs-attr\">path<\/span>: <span class=\"hljs-string\">'users'<\/span>,\n    <span class=\"hljs-attr\">loadComponent<\/span>: <span class=\"hljs-function\"><span class=\"hljs-params\">()<\/span> =&gt;<\/span>\n      <span class=\"hljs-keyword\">import<\/span>(<span class=\"hljs-string\">'.\/users\/users.component'<\/span>).then(<span class=\"hljs-function\">(<span class=\"hljs-params\">m<\/span>) =&gt;<\/span> m.UsersComponent),\n  },\n]<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-3\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: dipendenze iniettate esplicitamente (<code>inject(HttpClient)<\/code>), signal dichiarativo invece di osservabili magici, control flow nativo (<code>@for<\/code> con <code>track<\/code>). Per un LLM tutto \u00e8 esplicito: cosa si importa, dove vive lo stato, come si itera, dove la rotta carica il componente.<\/p>\n\n\n\n<p>Pochi misteri runtime, convenzioni rigorose, errori del compiler chiari: se l&#8217;ecosistema enterprise lo sta riscoprendo, una delle ragioni \u00e8 proprio questa.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-vue-nuxt\">Vue \/ Nuxt<\/h3>\n\n\n\n<p><a href=\"https:\/\/vuejs.org\" target=\"_blank\" rel=\"noreferrer noopener\">Vue<\/a> e Nuxt occupano la nicchia &#8220;boring is beautiful&#8221;: convenzioni solide, ecosistema maturo, niente svolte epocali. Per molti team \u00e8 esattamente quello che serve.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-4\" data-shcb-language-name=\"HTML, XML\" data-shcb-language-slug=\"xml\"><span><code class=\"hljs language-xml\"><span class=\"hljs-comment\">&lt;!-- pages\/users.vue --&gt;<\/span>\n<span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">script<\/span> <span class=\"hljs-attr\">setup<\/span> <span class=\"hljs-attr\">lang<\/span>=<span class=\"hljs-string\">\"ts\"<\/span>&gt;<\/span><span class=\"actionscript\">\n<span class=\"hljs-class\"><span class=\"hljs-keyword\">interface<\/span> <span class=\"hljs-title\">User<\/span> <\/span>{ id: number; name: string }\n<span class=\"hljs-keyword\">const<\/span> { data: users } = await useFetch&lt;User&#91;]&gt;(<span class=\"hljs-string\">'\/api\/users'<\/span>)\n<\/span><span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">script<\/span>&gt;<\/span>\n\n<span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">template<\/span>&gt;<\/span>\n  <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n    <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span> <span class=\"hljs-attr\">v-for<\/span>=<span class=\"hljs-string\">\"u in users\"<\/span> <span class=\"hljs-attr\">:key<\/span>=<span class=\"hljs-string\">\"u.id\"<\/span>&gt;<\/span>{{ u.name }}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>\n  <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">template<\/span>&gt;<\/span><\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-4\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">HTML, XML<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">xml<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: file in <code>pages\/<\/code> = rotta, <code>useFetch<\/code> \u00e8 la convenzione standard (server al primo render, client dopo), single-file component con sezioni dichiarative chiaramente separate. Per un agente \u00e8 quasi banale: il pattern \u00e8 identico per qualunque pagina, l&#8217;auto-import di Nuxt riduce ulteriormente le scelte. La verbosit\u00e0 \u00e8 bassa, l&#8217;ambiguit\u00e0 anche. Una codebase Nuxt \u00e8 quasi sempre pi\u00f9 leggibile di una Next.js <em>equivalente in complessit\u00e0<\/em>, semplicemente perch\u00e9 l&#8217;ecosistema Vue ha sempre premiato la convenzione sull&#8217;innovazione.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-svelte-5-sveltekit\">Svelte 5 \/ SvelteKit<\/h3>\n\n\n\n<p>Svelte 5 ha fatto la scommessa pi\u00f9 radicale: <a href=\"https:\/\/svelte.dev\/blog\/runes\" target=\"_blank\" rel=\"noreferrer noopener\">le runes<\/a> spostano la reattivit\u00e0 da &#8220;magica e implicita&#8221; a &#8220;esplicita e dichiarativa&#8221;.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-5\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\"><span class=\"hljs-comment\">\/\/ src\/routes\/users\/+page.server.ts<\/span>\n<span class=\"hljs-keyword\">import<\/span> type { PageServerLoad } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'.\/$types'<\/span>\n\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">const<\/span> load: PageServerLoad = <span class=\"hljs-keyword\">async<\/span> ({ fetch }) =&gt; {\n  <span class=\"hljs-keyword\">const<\/span> users = <span class=\"hljs-keyword\">await<\/span> fetch(<span class=\"hljs-string\">'\/api\/users'<\/span>).then(<span class=\"hljs-function\">(<span class=\"hljs-params\">r<\/span>) =&gt;<\/span> r.json())\n  <span class=\"hljs-keyword\">return<\/span> { users }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-5\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-6\" data-shcb-language-name=\"HTML, XML\" data-shcb-language-slug=\"xml\"><span><code class=\"hljs language-xml\"><span class=\"hljs-comment\">&lt;!-- src\/routes\/users\/+page.svelte --&gt;<\/span>\n<span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">script<\/span> <span class=\"hljs-attr\">lang<\/span>=<span class=\"hljs-string\">\"ts\"<\/span>&gt;<\/span><span class=\"javascript\">\n  <span class=\"hljs-keyword\">let<\/span> { data } = $props()\n<\/span><span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">script<\/span>&gt;<\/span>\n\n<span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n  {#each data.users as user (user.id)}\n    <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span>&gt;<\/span>{user.name}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>\n  {\/each}\n<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span><\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-6\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">HTML, XML<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">xml<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: il <code>+page.server.ts<\/code> rende il boundary client\/server <em>lessicalmente<\/em> esplicito, non \u00e8 una convenzione di sintassi come <code>'use server'<\/code>, \u00e8 scritto proprio nel <em>nome del file<\/em>. Non si pu\u00f2 sbagliare.<\/p>\n\n\n\n<p>Le runes (<code>$props<\/code>, <code>$state<\/code>, <code>$derived<\/code>) sono dichiarazioni, non chiamate sensibili all&#8217;ordine come gli hook React. Il compiler garantisce che l&#8217;output runtime sia analizzabile e ottimizzato. Per un LLM che deve modificare un componente, la differenza tra <code>$state(0)<\/code> e una variabile la cui reattivit\u00e0 dipende da regole sintattiche \u00e8 la differenza tra un&#8217;API e un mistero. \u00c8 una delle ergonomie agentiche pi\u00f9 alte sul mercato.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-solid-solidstart\">Solid \/ SolidStart<\/h3>\n\n\n\n<p><a href=\"https:\/\/solidjs.com\" target=\"_blank\" rel=\"noreferrer noopener\">Solid<\/a> e <a href=\"https:\/\/start.solidjs.com\/\" target=\"_blank\" rel=\"noreferrer noopener\">SolidStart<\/a> condividono la filosofia compiler-first di Svelte con un purismo concettuale ancora pi\u00f9 marcato. La reattivit\u00e0 granulare di Solid \u00e8 uno dei modelli mentali pi\u00f9 puliti dell&#8217;intero ecosistema.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-7\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\"><span class=\"hljs-comment\">\/\/ src\/routes\/users.tsx<\/span>\n<span class=\"hljs-keyword\">import<\/span> { For } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'solid-js'<\/span>\n<span class=\"hljs-keyword\">import<\/span> { createAsync, query } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@solidjs\/router'<\/span>\n\n<span class=\"hljs-keyword\">const<\/span> getUsers = query(<span class=\"hljs-keyword\">async<\/span> () =&gt; {\n  <span class=\"hljs-keyword\">const<\/span> res = <span class=\"hljs-keyword\">await<\/span> fetch(<span class=\"hljs-string\">'\/api\/users'<\/span>)\n  <span class=\"hljs-keyword\">return<\/span> res.json() <span class=\"hljs-keyword\">as<\/span> <span class=\"hljs-built_in\">Promise<\/span>&lt;{ <span class=\"hljs-attr\">id<\/span>: number; name: string }&#91;]&gt;\n}, <span class=\"hljs-string\">'users'<\/span>)\n\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">default<\/span> <span class=\"hljs-function\"><span class=\"hljs-keyword\">function<\/span> <span class=\"hljs-title\">Users<\/span>(<span class=\"hljs-params\"><\/span>) <\/span>{\n  <span class=\"hljs-keyword\">const<\/span> users = createAsync(<span class=\"hljs-function\"><span class=\"hljs-params\">()<\/span> =&gt;<\/span> getUsers())\n  <span class=\"hljs-keyword\">return<\/span> (\n    <span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n      <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">For<\/span> <span class=\"hljs-attr\">each<\/span>=<span class=\"hljs-string\">{users()}<\/span>&gt;<\/span>{(u) =&gt; <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span>&gt;<\/span>{u.name}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">For<\/span>&gt;<\/span>\n    <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span><\/span>\n  )\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-7\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: signal-based reactivity esplicita: le parentesi <code>()<\/code> rivelano l&#8217;accesso reattivo a colpo d&#8217;occhio. <code>&lt;For&gt;<\/code> invece di <code>.map()<\/code> per liste, perch\u00e9 Solid non re-rendera l&#8217;intero componente: la differenza \u00e8 sintatticamente visibile. Il modello mentale \u00e8 coerente al 100%: non ci sono casi speciali, non ci sono &#8220;regole degli hook&#8221;, non ci sono dipendenze da dichiarare a mano. Per un LLM, la coerenza \u00e8 oro \u2014 e non \u00e8 un caso che le idee di Ryan Carniato siano migrate, in forme diverse, dentro Vue, Angular e perfino il lavoro su React Forget.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-astro\">Astro<\/h3>\n\n\n\n<p><a href=\"https:\/\/astro.build\" target=\"_blank\" rel=\"noreferrer noopener\">Astro<\/a> ha scelto un posizionamento laterale e furbo: content-first, islands, schema strutturato per i contenuti. \u00c8 il framework che meglio si presta a siti dove il contenuto \u00e8 il prodotto e l&#8217;interattivit\u00e0 \u00e8 puntuale.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-8\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\">---\n<span class=\"hljs-comment\">\/\/ src\/pages\/users.astro<\/span>\ninterface User { <span class=\"hljs-attr\">id<\/span>: number; name: string }\n<span class=\"hljs-keyword\">const<\/span> users: User&#91;] = <span class=\"hljs-keyword\">await<\/span> fetch(<span class=\"hljs-string\">'https:\/\/api.example.com\/users'<\/span>)\n  .then(<span class=\"hljs-function\">(<span class=\"hljs-params\">r<\/span>) =&gt;<\/span> r.json())\n---\n\n<span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n  {users.map((u) =&gt; <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span>&gt;<\/span>{u.name}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>)}\n<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span><\/span><\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-8\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: il frontmatter (<code>---<\/code>) \u00e8 server-side per costruzione, sempre, senza eccezioni. Il template \u00e8 statico per default. Niente da decidere su client vs server: \u00e8 ovvio dalla sintassi stessa. Aggiungere interattivit\u00e0 richiede un&#8217;island esplicita (<code>&lt;MyComponent client:load \/&gt;<\/code>), e questo \u00e8 proprio il metodo che riduce la varianza per l&#8217;agente. Quando si entra nel territorio dei contenuti, le Content Collections con schema Zod diventano un contratto leggibile per l&#8217;LLM: lo schema <em>\u00e8<\/em> la documentazione, e l&#8217;agente lo usa come tale per generare contenuti coerenti.<\/p>\n\n\n\n<p>Una codebase Astro ben strutturata \u00e8 uno dei terreni pi\u00f9 ergonomici in assoluto per un agente.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-qwik-qwik-city\">Qwik \/ Qwik City<\/h3>\n\n\n\n<p><a href=\"https:\/\/qwik.dev\/\" target=\"_blank\" rel=\"noreferrer noopener\">Qwik<\/a> \u00e8 la scommessa di lungo periodo: la resumability sostituisce l&#8217;idratazione, il modello di esecuzione \u00e8 formalmente pi\u00f9 pulito, l&#8217;app \u00e8 &#8220;lazy&#8221; per costruzione.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-9\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\"><span class=\"hljs-comment\">\/\/ src\/routes\/users\/index.tsx<\/span>\n<span class=\"hljs-keyword\">import<\/span> { component$ } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@builder.io\/qwik'<\/span>\n<span class=\"hljs-keyword\">import<\/span> { routeLoader$ } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@builder.io\/qwik-city'<\/span>\n\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">const<\/span> useUsers = routeLoader$(<span class=\"hljs-keyword\">async<\/span> () =&gt; {\n  <span class=\"hljs-keyword\">const<\/span> res = <span class=\"hljs-keyword\">await<\/span> fetch(<span class=\"hljs-string\">'https:\/\/api.example.com\/users'<\/span>)\n  <span class=\"hljs-keyword\">return<\/span> res.json() <span class=\"hljs-keyword\">as<\/span> <span class=\"hljs-built_in\">Promise<\/span>&lt;{ <span class=\"hljs-attr\">id<\/span>: number; name: string }&#91;]&gt;\n})\n\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">default<\/span> component$(() =&gt; {\n  <span class=\"hljs-keyword\">const<\/span> users = useUsers()\n  <span class=\"hljs-keyword\">return<\/span> (\n    <span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n      {users.value.map((u) =&gt; <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span> <span class=\"hljs-attr\">key<\/span>=<span class=\"hljs-string\">{u.id}<\/span>&gt;<\/span>{u.name}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>)}\n    <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span><\/span>\n  )\n})<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-9\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: il suffisso <code>$<\/code> non \u00e8 cosmetico, \u00e8 la marca lessicale di un boundary di lazy loading, leggibile dal compiler e dall&#8217;agente come confine di esecuzione. <code>routeLoader$<\/code> \u00e8 server-side per costruzione; <code>component$<\/code> \u00e8 il marker di un componente resumable.<\/p>\n\n\n\n<p>Pi\u00f9 rigido di altri framework, ma proprio per questo straordinariamente leggibile per una macchina: ogni <code>$<\/code> \u00e8 una dichiarazione formale di &#8220;qui succede qualcosa di specifico&#8221;, e non c&#8217;\u00e8 ambiguit\u00e0 su cosa. Qwik non ha ancora il momentum dei framework principali, ma la formalit\u00e0 del modello lo rende particolarmente interessante per chi pensa al lungo termine.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-react-router-7-ex-remix\">React Router 7 (ex Remix)<\/h3>\n\n\n\n<p>Remix \u00e8 diventato React Router 7, fondendo il framework e il router in un&#8217;unica entit\u00e0. La mossa \u00e8 coerente con la tesi di questo articolo: sempre meno pezzi separati, sempre pi\u00f9 contratti integrati.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-10\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\"><span class=\"hljs-comment\">\/\/ app\/routes\/users.tsx<\/span>\n<span class=\"hljs-keyword\">import<\/span> type { Route } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'.\/+types\/users'<\/span>\n\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">async<\/span> <span class=\"hljs-function\"><span class=\"hljs-keyword\">function<\/span> <span class=\"hljs-title\">loader<\/span>(<span class=\"hljs-params\"><\/span>) <\/span>{\n  <span class=\"hljs-keyword\">const<\/span> res = <span class=\"hljs-keyword\">await<\/span> fetch(<span class=\"hljs-string\">'https:\/\/api.example.com\/users'<\/span>)\n  <span class=\"hljs-keyword\">const<\/span> users = (<span class=\"hljs-keyword\">await<\/span> res.json()) <span class=\"hljs-keyword\">as<\/span> { <span class=\"hljs-attr\">id<\/span>: number; name: string }&#91;]\n  <span class=\"hljs-keyword\">return<\/span> { users }\n}\n\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">default<\/span> <span class=\"hljs-function\"><span class=\"hljs-keyword\">function<\/span> <span class=\"hljs-title\">Users<\/span>(<span class=\"hljs-params\">{ loaderData }: Route.ComponentProps<\/span>) <\/span>{\n  <span class=\"hljs-keyword\">return<\/span> (\n    <span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n      {loaderData.users.map((u) =&gt; <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span> <span class=\"hljs-attr\">key<\/span>=<span class=\"hljs-string\">{u.id}<\/span>&gt;<\/span>{u.name}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>)}\n    <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span><\/span>\n  )\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-10\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: pattern loader\/component canonico, tipi auto-generati (<code>Route.ComponentProps<\/code> viene da <code>.\/+types\/users<\/code>) che fluiscono dal loader al componente senza che lo sviluppatore (o l&#8217;agente di turno) debba dichiararli. Un agente sa esattamente dove sta il <code>fetch<\/code> (loader, server) e dove sta la presentazione (componente, possibly client).<\/p>\n\n\n\n<p>La fusione Remix =&gt; RR7 ha consolidato questo pattern come uno dei pi\u00f9 puliti dell&#8217;ecosistema React, ed \u00e8 uno dei pochi casi in cui un&#8217;evoluzione architetturale ha <em>aumentato<\/em> l&#8217;ADX invece di degradarla.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-tanstack-start\">TanStack Start<\/h3>\n\n\n\n<p><a href=\"https:\/\/tanstack.com\/\" target=\"_blank\" rel=\"noreferrer noopener\">TanStack<\/a> rappresenta l&#8217;anti-modello dichiarato. La filosofia di Tanner Linsley \u00e8 chiara: invece di un framework opinionato, primitive fortemente tipizzate e componibili.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-11\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><span><code class=\"hljs language-javascript\"><span class=\"hljs-comment\">\/\/ src\/routes\/users.tsx<\/span>\n<span class=\"hljs-keyword\">import<\/span> { createFileRoute } <span class=\"hljs-keyword\">from<\/span> <span class=\"hljs-string\">'@tanstack\/react-router'<\/span>\n\n<span class=\"hljs-keyword\">export<\/span> <span class=\"hljs-keyword\">const<\/span> Route = createFileRoute(<span class=\"hljs-string\">'\/users'<\/span>)({\n  <span class=\"hljs-attr\">loader<\/span>: <span class=\"hljs-keyword\">async<\/span> () =&gt; {\n    <span class=\"hljs-keyword\">const<\/span> res = <span class=\"hljs-keyword\">await<\/span> fetch(<span class=\"hljs-string\">'\/api\/users'<\/span>)\n    <span class=\"hljs-keyword\">return<\/span> res.json() <span class=\"hljs-keyword\">as<\/span> <span class=\"hljs-built_in\">Promise<\/span>&lt;{ <span class=\"hljs-attr\">id<\/span>: number; name: string }&#91;]&gt;\n  },\n  <span class=\"hljs-attr\">component<\/span>: UsersPage,\n})\n\n<span class=\"hljs-function\"><span class=\"hljs-keyword\">function<\/span> <span class=\"hljs-title\">UsersPage<\/span>(<span class=\"hljs-params\"><\/span>) <\/span>{\n  <span class=\"hljs-keyword\">const<\/span> users = Route.useLoaderData()\n  <span class=\"hljs-keyword\">return<\/span> (\n    <span class=\"xml\"><span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">ul<\/span>&gt;<\/span>\n      {users.map((u) =&gt; <span class=\"hljs-tag\">&lt;<span class=\"hljs-name\">li<\/span> <span class=\"hljs-attr\">key<\/span>=<span class=\"hljs-string\">{u.id}<\/span>&gt;<\/span>{u.name}<span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">li<\/span>&gt;<\/span>)}\n    <span class=\"hljs-tag\">&lt;\/<span class=\"hljs-name\">ul<\/span>&gt;<\/span><\/span>\n  )\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-11\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p><strong>ADX<\/strong>: tipizzazione end-to-end fortissima: il tipo del loader si propaga al componente, ai search params, e a tutti i <code>&lt;Link&gt;<\/code> che puntano a questa rotta.<\/p>\n\n\n\n<p>Per un agente TanStack \u00e8 un terreno di gioco eccellente: gli errori di tipo intercettano gran parte degli output sbagliati prima che arrivino al review umano. Per un agente meno disciplinato che ignora i tipi, la verbosit\u00e0 diventa rumore. <strong>La domanda che l&#8217;era agentica solleva su TanStack \u00e8 onesta<\/strong>: quanto bene si comporta quando met\u00e0 del codice viene scritto da un agente che non ha le stesse intuizioni del team che ha scelto le primitive?<\/p>\n\n\n\n<p>\u00c8 una domanda aperta, e che vale la pena tenere aperta.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-cosa-vede-un-agente-quando-entra-in-un-repository\">Cosa vede un agente quando entra in un repository<\/h2>\n\n\n\n<p>Vale la pena fermarsi e guardare nel dettaglio cosa accada, concretamente, quando uno strumento come Cursor, Codex o Claude Code apre per la prima volta una codebase. \u00c8 il punto in cui le considerazioni teoriche si traducono in differenze misurabili e dove l&#8217;idea di &#8220;compressione cognitiva&#8221; smette di essere una metafora.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"h-codebase-indexing\">Codebase indexing<\/h3>\n\n\n\n<p>Il tool costruisce in background una rappresentazione strutturata del progetto. Le componenti tipiche di questa rappresentazione sono almeno tre:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Una mappa dei file con metadata di base (path, linguaggio, dimensione, hash)<\/li>\n\n\n\n<li>Un set di embeddings semantici, calcolati su chunk di codice di dimensione variabile (funzione, classe, blocco di import, sezione di documentazione)<\/li>\n\n\n\n<li>Un grafo dei simboli pubblici (funzioni esportate, tipi, classi) derivato da analisi statica o da language server come <code>tsserver<\/code>.<\/li>\n<\/ul>\n\n\n\n<p>Cursor pubblica documentazione esplicita su questo (<a href=\"https:\/\/read.engineerscodex.com\/p\/how-cursor-indexes-codebases-fast\">qui<\/a> potete leggere un&#8217;ottima analisi), Claude Code fa qualcosa di simile in modo meno verboso. La qualit\u00e0 dell&#8217;indicizzazione dipende in larga misura da quanto la codebase \u00e8 <em>strutturata in modo riconoscibile<\/em>: un modulo nominato <code>users.ts<\/code> con un export chiamato <code>getUsers<\/code> \u00e8 infinitamente pi\u00f9 trovabile di un&#8217;arrow function anonima passata a <code>useQuery<\/code> dentro un componente.<\/p>\n\n\n\n<p>Quando arriva un prompt tipo &#8220;aggiungi paginazione alla lista utenti&#8221; l&#8217;agente non spedisce l&#8217;intero repository al modello. Fa un <em>retrieval<\/em>: combina ricerca semantica sugli embeddings, ricerca lessicale (tipicamente <code>ripgrep<\/code> sotto il cofano), e navigazione del grafo dei simboli per costruire un contesto rilevante.<\/p>\n\n\n\n<p>Su questo contesto, e su una serie di tool come <code>read_file<\/code>, <code>grep<\/code>, <code>find_references<\/code>, <code>edit_file<\/code> il modello ragiona iterativamente. \u00c8 un loop: il modello propone una query, riceve un risultato, propone un&#8217;edit o un&#8217;altra query, e cos\u00ec via, finch\u00e9 non produce il diff finale. Ogni passo costa token, latenza, e soprattutto \u00e8 un&#8217;occasione per sbagliare strada.<\/p>\n\n\n\n<p><strong>Qui le convenzioni del framework cominciano a fare differenze concrete<\/strong>. In una codebase Next.js App Router, &#8220;trova la pagina utenti&#8221; si risolve nel primo passo: <code>app\/users\/page.tsx<\/code> esiste o non esiste. In una codebase Astro, &#8220;modifica lo schema dei post&#8221; \u00e8 un singolo file in <code>src\/content\/config.ts<\/code> con uno Zod schema esplicito leggibile dall&#8217;agente esattamente come sarebbe leggibile per uno sviluppatore nuovo. In Angular moderno, gli standalone components con <code>inject()<\/code> esplicita dicono al modello cosa importare e da dove, senza che debba ricostruire la dependency injection a partire da decoratori sparsi. In SvelteKit, <code>+page.server.ts<\/code> dichiara lessicalmente che il file \u00e8 server-side: un agente non pu\u00f2 confonderlo con codice client.<\/p>\n\n\n\n<p><strong>In una codebase React vanilla con configurazione artigianale, niente di tutto questo \u00e8 dato<\/strong>. &#8220;Trova la pagina utenti&#8221; si traduce in: <code>grep -r \"\/users\"<\/code> su tutto il repo, parsing manuale del file dove <code>&lt;Routes&gt;<\/code> \u00e8 dichiarato, navigazione di import, identificazione del componente, controllo se il fetch \u00e8 dentro un <code>useEffect<\/code>, dentro un <code>useQuery<\/code>, in un custom hook, in un servizio API custom, in un loader passato come prop.<\/p>\n\n\n\n<p>Ognuno di questi passi \u00e8 una possibilit\u00e0 di errore. L&#8217;agente ricostruisce <em>abbastanza bene<\/em> nei casi comuni: \u00e8 per questo che l&#8217;illusione &#8220;tanto ci pensa l&#8217;AI&#8221; \u00e8 cos\u00ec seducente. Peccato che la varianza degli output sia alta, gli errori sottili siano frequenti, e il costo della review umana cresca in proporzione.<\/p>\n\n\n\n<p>Su uno snippet isolato non si vede; su un team di trenta persone con dieci agenti attivi in parallelo, s\u00ec e si misura in PR rifiutate, regressioni in produzione, sessioni di debugging che non sarebbero esistite.<\/p>\n\n\n\n<p>C&#8217;\u00e8 poi un modello emergente\u2026 <strong>Il Model Context Protocol<\/strong>, standardizzato da Anthropic e adottato sempre pi\u00f9 ampiamente da tool e framework, permette di esporre agli agenti non solo file ma <em>capability strutturate<\/em>. Un MCP server per un&#8217;app Next.js pu\u00f2 rispondere a query come &#8220;elenca tutte le rotte&#8221;, &#8220;qual \u00e8 il loader per <code>\/dashboard\/[id]<\/code>&#8220;, &#8220;quali Server Actions modificano la tabella users&#8221;, &#8220;qual \u00e8 lo schema dei dati ritornati da <code>getUserById<\/code>&#8220;.<\/p>\n\n\n\n<p>Un agente con accesso a un MCP server di questo tipo non fa pi\u00f9 grep: fa query strutturate. La differenza \u00e8 la stessa che passa tra cercare un&#8217;informazione leggendo migliaia di pagine di documentazione e cercarla con SQL su un database normalizzato.<\/p>\n\n\n\n<p>Vercel sta spingendo in questa direzione esplicitamente; SvelteKit, Nuxt e Angular hanno iniziative analoghe in corso. Un framework che espone in modo nativo il proprio &#8220;MCP applicativo&#8221; (con tanto di rotte, layout, server functions, schema dati, configurazione di build) diventa, di fatto, una tool API per gli agenti.<\/p>\n\n\n\n<p>\u00c8 il completamento naturale della tesi della compressione cognitiva: prima il framework comprime le scelte attraverso convenzioni; poi le espone in modo machine-readable attraverso un protocollo. Tra cinque anni dare un repo a un agente senza un MCP server attivo sar\u00e0 come dare un database senza un&#8217;introspezione dello schema. Tecnicamente fattibile, professionalmente discutibile.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-standardizzazione-frammentazione-e-l-effetto-schelling\">Standardizzazione, frammentazione, e l&#8217;effetto Schelling<\/h2>\n\n\n\n<p>Abbiamo detto che la domanda all&#8217;inizio dell&#8217;articolo \u00e8 &#8220;brutta e cattiva&#8221;\u2026 C&#8217;\u00e8 per\u00f2 una domanda strategica che vale la pena porre apertamente: l&#8217;AI sta favorendo la standardizzazione dell&#8217;ecosistema o la sua frammentazione?<\/p>\n\n\n\n<p>L&#8217;argomento per la frammentazione \u00e8 intuitivo: se un agente pu\u00f2 aiutarmi a usare qualsiasi framework, la barriera di adozione si abbassa, mille fiori fioriscono. L&#8217;argomento \u00e8 plausibile in superficie, ma la realt\u00e0 del training dei modelli racconta una storia diversa. Gli LLM sono distribuzionali: lavorano meglio sui pattern pi\u00f9 rappresentati nei dati. I framework con pi\u00f9 adozione, pi\u00f9 documentazione e pi\u00f9 codice pubblico diventano <em>progressivamente pi\u00f9 facili da generare bene<\/em>. Gli sviluppatori scelgono quelli che gli agenti gestiscono meglio. <strong>Loop di rinforzo. Vincono i vincitori<\/strong>.<\/p>\n\n\n\n<p>\u00c8 un effetto Schelling-point, e vale la pena spendere due parole sul concetto perch\u00e9 spiega molto di quello che sta succedendo. Il termine viene dall&#8217;economista <a href=\"https:\/\/it.wikipedia.org\/wiki\/Thomas_Schelling\" target=\"_blank\" rel=\"noreferrer noopener\">Thomas Schelling<\/a>, premio Nobel nel 2005 per il suo lavoro sulla teoria dei giochi. Schelling chiedeva ai suoi studenti: &#8220;Devi incontrare qualcuno a New York domani, non potete comunicare in anticipo, dove vai e a che ora?&#8221; La risposta modale era &#8220;Grand Central Station, mezzogiorno&#8221;. Non perch\u00e9 Grand Central sia oggettivamente il punto migliore (qualunque punto della citt\u00e0 funzionerebbe se entrambi ci andassero) ma perch\u00e9 \u00e8 il punto focale che entrambi <em>si aspettano<\/em> che l&#8217;altro scelga.<\/p>\n\n\n\n<p>Le persone convergono spontaneamente sui punti focali quando hanno bisogno di coordinarsi senza comunicare. Schelling chiam\u00f2 questi punti <em>focal points<\/em>; oggi li chiamiamo <strong>Schelling points<\/strong>.<\/p>\n\n\n\n<p>Nell&#8217;ecosistema dei framework, il meccanismo \u00e8 analogo ma a tre attori.<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Gli sviluppatori vogliono scegliere un framework che gli agenti AI gestiscano bene.<\/li>\n\n\n\n<li>I produttori di agenti vogliono performare bene sui framework che gli sviluppatori usano.<\/li>\n\n\n\n<li>I framework vogliono essere scelti dagli sviluppatori.<\/li>\n<\/ul>\n\n\n\n<p>Tutti e tre hanno incentivi locali a convergere sugli stessi pattern dominanti: quelli che hanno pi\u00f9 rappresentazione nei dati di training, pi\u00f9 documentazione pubblica, pi\u00f9 issue risolte su GitHub, pi\u00f9 esempi su Medium, dev.to e piattaforme simili. Ogni attore, individualmente, sta giocando una mossa razionale. L&#8217;effetto aggregato \u00e8 la convergenza.<\/p>\n\n\n\n<p>Questo non \u00e8 semplicemente un effetto di rete. Un effetto di rete classico (Facebook, WhatsApp) deriva dal fatto che il valore del prodotto cresce con il numero di utenti. Lo Schelling point dei framework \u00e8 pi\u00f9 sottile: deriva dal fatto che la <em>qualit\u00e0 degli output degli agenti<\/em> cresce con la rappresentazione del framework nei dati. \u00c8 un loop di rinforzo statistico. Pi\u00f9 Next.js \u00e8 documentato, pi\u00f9 gli LLM lo gestiscono bene; pi\u00f9 gli LLM lo gestiscono bene, pi\u00f9 i team lo scelgono; pi\u00f9 team lo scelgono, pi\u00f9 documentazione e codice pubblico viene prodotto. Lo stesso loop, in senso inverso, penalizza i framework di nicchia: non perch\u00e9 siano peggiori, ma perch\u00e9 il loro corpus di training \u00e8 pi\u00f9 piccolo e quindi gli output del modello su quei framework sono mediamente meno accurati.<\/p>\n\n\n\n<p>Le conseguenze pratiche sono ambivalenti. Da un lato, ottima esperienza per chi sta nel mainstream: meno fatica, meno errori, pi\u00f9 produttivit\u00e0. Dall&#8217;altro, una concentrazione di mercato che andr\u00e0 valutata con attenzione, soprattutto quando il &#8220;mainstream&#8221; coincide largamente con un singolo vendor, e nel caso di React + Next.js + Vercel + AI SDK, la concentrazione \u00e8 gi\u00e0 reale.<\/p>\n\n\n\n<p>C&#8217;\u00e8 anche un effetto secondario meno discusso: lo Schelling point premia anche le <em>versioni<\/em> di un framework, non solo il framework. Un agente lavora meglio sull&#8217;App Router che sul Pages Router perch\u00e9 c&#8217;\u00e8 pi\u00f9 codice App Router nei training set recenti. La conseguenza \u00e8 che restare su versioni vecchie di un framework opinionated (anche se tecnicamente funzionano) diventa progressivamente un costo nascosto in termini di ADX.<\/p>\n\n\n\n<p>La pressione a stare <em>sull&#8217;ultima major<\/em> aumenta, e con essa la frequenza di migrazioni dovute non a bisogni di prodotto ma a bisogni di leggibilit\u00e0 per gli strumenti.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-cosa-cambia-per-i-senior-e-per-i-team\">Cosa cambia per i senior e per i team<\/h2>\n\n\n\n<p>Per chi guida architetture, l&#8217;era agentica introduce un cambiamento di ruolo che vale la pena nominare. Il senior smette progressivamente di essere &#8220;chi scrive il codice difficile&#8221; e diventa &#8220;chi progetta i confini dentro cui l&#8217;agente pu\u00f2 scrivere senza fare danni&#8221;. \u00c8 un lavoro meno visibile e pi\u00f9 strategico: definire convenzioni, stabilire invarianti, decidere quali astrazioni sono leggibili e quali no, scegliere framework opinionated abbastanza da essere navigabili.<\/p>\n\n\n\n<p>Il code review cambia natura. Quando una PR di trecento righe \u00e8 stata generata in dieci minuti, il revisore umano non pu\u00f2 pi\u00f9 fare lo stesso tipo di lettura granulare. Deve fidarsi del framework, dei tipi, dei test, e concentrarsi sugli aspetti che la macchina non vede: coerenza architetturale, decisioni di prodotto, allineamento con il sistema esistente. \u00c8 un mestiere diverso, e va imparato.<\/p>\n\n\n\n<p>Le decisioni di adozione tecnologica si pesano diversamente. &#8220;Abbiamo libert\u00e0 totale&#8221; smette di essere un argomento a favore di uno stack. &#8220;Il nostro stack \u00e8 leggibile e prevedibile per gli strumenti che useremo nei prossimi tre anni&#8221; diventa una preoccupazione di prima istanza. Non \u00e8 una resa al mainstream: \u00e8 una valutazione realistica del costo che comporta uscirne.<\/p>\n\n\n\n<p>E c&#8217;\u00e8 il debito tecnico generato dagli agenti, che ha una forma sua: codice plausibile, sintatticamente corretto, che funziona nei casi testati e si rompe in modi sottili nei casi non testati. \u00c8 un debito tecnico particolarmente insidioso perch\u00e9 <em>sembra<\/em> finito. Architetture con convenzioni forti lo limitano alla radice, perch\u00e9 restringono lo spazio dove un errore pu\u00f2 nascondersi.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-quattro-scenari-a-tre-cinque-anni\">Quattro scenari a tre-cinque anni<\/h2>\n\n\n\n<p>Vale la pena chiudere disegnando, sobriamente, qualche scenario.<\/p>\n\n\n\n<p>Nel primo, <strong>convergenza dei protocolli<\/strong>: il modello Next.js + Vercel + AI SDK + MCP diventa lo standard de facto, e l&#8217;ecosistema si polarizza tra &#8220;framework-as-protocol&#8221; maturi e librerie composte residuali. \u00c8 lo scenario pi\u00f9 plausibile a breve termine, ed \u00e8 gi\u00e0 parzialmente in corso. Il rischio \u00e8 la concentrazione di mercato.<\/p>\n\n\n\n<p>Nel secondo, <strong>vittoria dei compiler-first<\/strong>: la prevedibilit\u00e0 del codice generato da Svelte, Solid e simili si dimostra un vantaggio decisivo per gli agenti, e una nuova generazione di framework con compiler ancora pi\u00f9 aggressivi, React compreso, ridisegna il panorama. \u00c8 uno scenario tecnicamente affascinante, e non cos\u00ec improbabile come sembra.<\/p>\n\n\n\n<p>Nel terzo, <strong>frammentazione assistita<\/strong>: i tool agentici diventano abbastanza bravi da neutralizzare il vantaggio dei framework opinionated, e ecosistemi composti come TanStack tornano competitivi grazie alla portabilit\u00e0. \u00c8 lo scenario meno probabile a tre anni, pi\u00f9 probabile a sette.<\/p>\n\n\n\n<p>Nel quarto, <strong>il framework diventa invisibile<\/strong>: l&#8217;agente sceglie, configura e gestisce lo stack al posto del team, e la conversazione si sposta dal &#8220;quale framework&#8221; al &#8220;quale obiettivo di prodotto&#8221;. \u00c8 lo scenario pi\u00f9 speculativo, e pone domande serie su autonomia, debugging e ownership delle decisioni architetturali. Ma non \u00e8 fantascienza: \u00e8 gi\u00e0 la traiettoria di tool come <a href=\"https:\/\/devin.ai\/\" target=\"_blank\" rel=\"noreferrer noopener\">Devin<\/a> o di alcune feature <em>autonomous<\/em> di Claude Code.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" id=\"h-la-domanda-giusta\">La domanda giusta<\/h2>\n\n\n\n<p>Il dibattito su framework e AI \u00e8 stato finora dominato da due narrative opposte e ugualmente sterili. Da una parte i catastrofisti, che annunciano la morte del frontend a ogni nuova release di un agente. Dall&#8217;altra gli ottimisti professionali, che fingono che nulla sia cambiato e che la solita curva di apprendimento basti.<\/p>\n\n\n\n<p>La realt\u00e0, per chi lavora davvero su codebase complesse, \u00e8 meno spettacolare e pi\u00f9 impegnativa. I framework JS non stanno morendo. Stanno cambiando padrone cognitivo. La metrica che li ha guidati per dieci anni (l&#8217;ergonomia del singolo sviluppatore) sta cedendo il passo a una metrica nuova: la leggibilit\u00e0 collettiva, dove &#8220;collettivo&#8221; include una flotta crescente di lettori artificiali.<\/p>\n\n\n\n<p>I framework che hanno investito in convenzioni stabili, compiler intelligence, tipi end-to-end, server boundaries esplicite e metadata strutturata si troveranno, semplicemente, nel posto giusto. Non per fortuna, ma perch\u00e9 stavano gi\u00e0 costruendo le feature di cui questa fase ha bisogno.<\/p>\n\n\n\n<p>La domanda operativa per chi legge non \u00e8 &#8220;quale framework scelgo&#8221;. \u00c8 pi\u00f9 scomoda: <em>quanto della mia codebase \u00e8 leggibile senza il mio cervello in mezzo?<\/em> Se la risposta \u00e8 &#8220;poco&#8221;, il problema non \u00e8 l&#8217;AI. \u00c8 un debito di leggibilit\u00e0 che esisteva gi\u00e0, e che l&#8217;era agentica si limiter\u00e0 a far emergere pi\u00f9 in fretta, e con meno cortesia, di quanto avrebbe fatto un nuovo collega.<\/p>\n\n\n\n<p>I framework sopravvivranno. Cambieranno destinatario. E i team che lo capiranno per primi smetteranno di chiedersi se React, Next, Svelte o Astro stiano morendo, e cominceranno a porsi una domanda molto pi\u00f9 produttiva: <strong>la nostra architettura \u00e8 leggibile da chiunque o solo da noi<\/strong>?<\/p>\n\n\n\n<p><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Convenzioni, compiler intelligence e server boundaries non sono dettagli ergonomici: sono la nuova interfaccia tra le codebase e gli agenti AI che ci lavorano dentro. Lo so, lo so\u2026 La domanda, cos\u00ec formulata, \u00e8 davvero provocatoria. Implica che esista una soglia oltre la quale gli agenti AI rendono superflua le astrazioni che chiamiamo &#8220;framework&#8221;. Inoltre,&#8230; <a class=\"more-link\" href=\"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/\">Read more<\/a><\/p>\n","protected":false},"author":349,"featured_media":35849,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_editorskit_title_hidden":false,"_editorskit_reading_time":0,"_editorskit_is_block_options_detached":false,"_editorskit_block_options_position":"{}","_uag_custom_page_level_css":"","_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","footnotes":""},"categories":[10230],"tags":[10329],"collections":[11549],"class_list":{"0":"post-35820","1":"post","2":"type-post","3":"status-publish","4":"format-standard","5":"has-post-thumbnail","7":"category-linguaggi-programmazione","8":"tag-framework","9":"collections-il-meglio-della-settimana","10":"entry"},"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v26.9 (Yoast SEO v27.5) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all&#039;era agentica? - Codemotion Magazine<\/title>\n<meta name=\"description\" content=\"I framework che sopravvivranno ai prossimi cinque anni sono quelli che stanno ridisegnando le proprie convenzioni anche per questo nuovo utilizzatore. Non devono sostituire l&#039;umano ma devono far lavorare l&#039;agente AI e l&#039;umano insieme\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all&#039;era agentica?\" \/>\n<meta property=\"og:description\" content=\"I framework che sopravvivranno ai prossimi cinque anni sono quelli che stanno ridisegnando le proprie convenzioni anche per questo nuovo utilizzatore. Non devono sostituire l&#039;umano ma devono far lavorare l&#039;agente AI e l&#039;umano insieme\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/\" \/>\n<meta property=\"og:site_name\" content=\"Codemotion Magazine\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/Codemotion.Italy\/\" \/>\n<meta property=\"article:published_time\" content=\"2026-05-18T12:37:32+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-05-18T13:06:32+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1672\" \/>\n\t<meta property=\"og:image:height\" content=\"941\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Francesco Napoletano\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@CodemotionIT\" \/>\n<meta name=\"twitter:site\" content=\"@CodemotionIT\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Francesco Napoletano\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"22 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/\"},\"author\":{\"name\":\"Francesco Napoletano\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#\\\/schema\\\/person\\\/f27416284aa6defd4fb248cf2766dfaf\"},\"headline\":\"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all&#8217;era agentica?\",\"datePublished\":\"2026-05-18T12:37:32+00:00\",\"dateModified\":\"2026-05-18T13:06:32+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/\"},\"wordCount\":4627,\"publisher\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/wp-content\\\/uploads\\\/2026\\\/05\\\/framework-obsoleti-1.png\",\"keywords\":[\"Framework\"],\"articleSection\":[\"Linguaggi di programmazione\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/\",\"url\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/\",\"name\":\"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all'era agentica? - Codemotion Magazine\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/wp-content\\\/uploads\\\/2026\\\/05\\\/framework-obsoleti-1.png\",\"datePublished\":\"2026-05-18T12:37:32+00:00\",\"dateModified\":\"2026-05-18T13:06:32+00:00\",\"description\":\"I framework che sopravvivranno ai prossimi cinque anni sono quelli che stanno ridisegnando le proprie convenzioni anche per questo nuovo utilizzatore. Non devono sostituire l'umano ma devono far lavorare l'agente AI e l'umano insieme\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/wp-content\\\/uploads\\\/2026\\\/05\\\/framework-obsoleti-1.png\",\"contentUrl\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/wp-content\\\/uploads\\\/2026\\\/05\\\/framework-obsoleti-1.png\",\"width\":1672,\"height\":941},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Linguaggi di programmazione\",\"item\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/it\\\/linguaggi-programmazione\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all&#8217;era agentica?\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#website\",\"url\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/\",\"name\":\"Codemotion Magazine\",\"description\":\"We code the future. Together\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#organization\",\"name\":\"Codemotion\",\"url\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/wp-content\\\/uploads\\\/2019\\\/11\\\/codemotionlogo.png\",\"contentUrl\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/wp-content\\\/uploads\\\/2019\\\/11\\\/codemotionlogo.png\",\"width\":225,\"height\":225,\"caption\":\"Codemotion\"},\"image\":{\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/Codemotion.Italy\\\/\",\"https:\\\/\\\/x.com\\\/CodemotionIT\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/#\\\/schema\\\/person\\\/f27416284aa6defd4fb248cf2766dfaf\",\"name\":\"Francesco Napoletano\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/be00812d69638a442c22193c6743ed3189a542aa1086fd87b3de0dd855de400a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/be00812d69638a442c22193c6743ed3189a542aa1086fd87b3de0dd855de400a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/be00812d69638a442c22193c6743ed3189a542aa1086fd87b3de0dd855de400a?s=96&d=mm&r=g\",\"caption\":\"Francesco Napoletano\"},\"url\":\"https:\\\/\\\/www.codemotion.com\\\/magazine\\\/author\\\/francesco-napoletano\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all'era agentica? - Codemotion Magazine","description":"I framework che sopravvivranno ai prossimi cinque anni sono quelli che stanno ridisegnando le proprie convenzioni anche per questo nuovo utilizzatore. Non devono sostituire l'umano ma devono far lavorare l'agente AI e l'umano insieme","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/","og_locale":"en_US","og_type":"article","og_title":"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all'era agentica?","og_description":"I framework che sopravvivranno ai prossimi cinque anni sono quelli che stanno ridisegnando le proprie convenzioni anche per questo nuovo utilizzatore. Non devono sostituire l'umano ma devono far lavorare l'agente AI e l'umano insieme","og_url":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/","og_site_name":"Codemotion Magazine","article_publisher":"https:\/\/www.facebook.com\/Codemotion.Italy\/","article_published_time":"2026-05-18T12:37:32+00:00","article_modified_time":"2026-05-18T13:06:32+00:00","og_image":[{"width":1672,"height":941,"url":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1.png","type":"image\/png"}],"author":"Francesco Napoletano","twitter_card":"summary_large_image","twitter_creator":"@CodemotionIT","twitter_site":"@CodemotionIT","twitter_misc":{"Written by":"Francesco Napoletano","Est. reading time":"22 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/#article","isPartOf":{"@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/"},"author":{"name":"Francesco Napoletano","@id":"https:\/\/www.codemotion.com\/magazine\/#\/schema\/person\/f27416284aa6defd4fb248cf2766dfaf"},"headline":"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all&#8217;era agentica?","datePublished":"2026-05-18T12:37:32+00:00","dateModified":"2026-05-18T13:06:32+00:00","mainEntityOfPage":{"@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/"},"wordCount":4627,"publisher":{"@id":"https:\/\/www.codemotion.com\/magazine\/#organization"},"image":{"@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/#primaryimage"},"thumbnailUrl":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1.png","keywords":["Framework"],"articleSection":["Linguaggi di programmazione"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/","url":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/","name":"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all'era agentica? - Codemotion Magazine","isPartOf":{"@id":"https:\/\/www.codemotion.com\/magazine\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/#primaryimage"},"image":{"@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/#primaryimage"},"thumbnailUrl":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1.png","datePublished":"2026-05-18T12:37:32+00:00","dateModified":"2026-05-18T13:06:32+00:00","description":"I framework che sopravvivranno ai prossimi cinque anni sono quelli che stanno ridisegnando le proprie convenzioni anche per questo nuovo utilizzatore. Non devono sostituire l'umano ma devono far lavorare l'agente AI e l'umano insieme","breadcrumb":{"@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/#primaryimage","url":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1.png","contentUrl":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1.png","width":1672,"height":941},{"@type":"BreadcrumbList","@id":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/framework-js-stanno-diventando-obsoleti-o-si-stanno-trasformando\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.codemotion.com\/magazine\/"},{"@type":"ListItem","position":2,"name":"Linguaggi di programmazione","item":"https:\/\/www.codemotion.com\/magazine\/it\/linguaggi-programmazione\/"},{"@type":"ListItem","position":3,"name":"I framework JS stanno diventando obsoleti o si stanno trasformando per sopravvivere all&#8217;era agentica?"}]},{"@type":"WebSite","@id":"https:\/\/www.codemotion.com\/magazine\/#website","url":"https:\/\/www.codemotion.com\/magazine\/","name":"Codemotion Magazine","description":"We code the future. Together","publisher":{"@id":"https:\/\/www.codemotion.com\/magazine\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.codemotion.com\/magazine\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.codemotion.com\/magazine\/#organization","name":"Codemotion","url":"https:\/\/www.codemotion.com\/magazine\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.codemotion.com\/magazine\/#\/schema\/logo\/image\/","url":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2019\/11\/codemotionlogo.png","contentUrl":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2019\/11\/codemotionlogo.png","width":225,"height":225,"caption":"Codemotion"},"image":{"@id":"https:\/\/www.codemotion.com\/magazine\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/Codemotion.Italy\/","https:\/\/x.com\/CodemotionIT"]},{"@type":"Person","@id":"https:\/\/www.codemotion.com\/magazine\/#\/schema\/person\/f27416284aa6defd4fb248cf2766dfaf","name":"Francesco Napoletano","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/be00812d69638a442c22193c6743ed3189a542aa1086fd87b3de0dd855de400a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/be00812d69638a442c22193c6743ed3189a542aa1086fd87b3de0dd855de400a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/be00812d69638a442c22193c6743ed3189a542aa1086fd87b3de0dd855de400a?s=96&d=mm&r=g","caption":"Francesco Napoletano"},"url":"https:\/\/www.codemotion.com\/magazine\/author\/francesco-napoletano\/"}]}},"featured_image_src":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-600x400.png","featured_image_src_square":"https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-600x600.png","author_info":{"display_name":"Francesco Napoletano","author_link":"https:\/\/www.codemotion.com\/magazine\/author\/francesco-napoletano\/"},"uagb_featured_image_src":{"full":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1.png",1672,941,false],"thumbnail":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-150x150.png",150,150,true],"medium":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-300x169.png",300,169,true],"medium_large":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-768x432.png",768,432,true],"large":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-1024x576.png",1024,576,true],"1536x1536":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-1536x864.png",1536,864,true],"2048x2048":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1.png",1672,941,false],"small-home-featured":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-100x100.png",100,100,true],"sidebar-featured":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-180x128.png",180,128,true],"genesis-singular-images":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-896x504.png",896,504,true],"archive-featured":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-400x225.png",400,225,true],"gb-block-post-grid-landscape":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-600x400.png",600,400,true],"gb-block-post-grid-square":["https:\/\/www.codemotion.com\/magazine\/wp-content\/uploads\/2026\/05\/framework-obsoleti-1-600x600.png",600,600,true]},"uagb_author_info":{"display_name":"Francesco Napoletano","author_link":"https:\/\/www.codemotion.com\/magazine\/author\/francesco-napoletano\/"},"uagb_comment_info":0,"uagb_excerpt":"Convenzioni, compiler intelligence e server boundaries non sono dettagli ergonomici: sono la nuova interfaccia tra le codebase e gli agenti AI che ci lavorano dentro. Lo so, lo so\u2026 La domanda, cos\u00ec formulata, \u00e8 davvero provocatoria. Implica che esista una soglia oltre la quale gli agenti AI rendono superflua le astrazioni che chiamiamo &#8220;framework&#8221;. Inoltre,&#8230;&hellip;","lang":"it","_links":{"self":[{"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/posts\/35820","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/users\/349"}],"replies":[{"embeddable":true,"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/comments?post=35820"}],"version-history":[{"count":2,"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/posts\/35820\/revisions"}],"predecessor-version":[{"id":35854,"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/posts\/35820\/revisions\/35854"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/media\/35849"}],"wp:attachment":[{"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/media?parent=35820"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/categories?post=35820"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/tags?post=35820"},{"taxonomy":"collections","embeddable":true,"href":"https:\/\/www.codemotion.com\/magazine\/wp-json\/wp\/v2\/collections?post=35820"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}