La fine del middleware: come i modelli stanno divorando la catena del valore software

Chiunque abbia vissuto almeno due cicli tecnologici sa riconoscere il momento esatto in cui una narrazione smette di essere marketing e diventa struttura economica. Non accade con un annuncio, né con un benchmark; accade quando la catena del valore si accorcia senza chiedere permesso. È esattamente ciò che sta succedendo oggi, mentre aziende come Anthropic iniziano a insinuarsi, con discrezione chirurgica, nello spazio che fino a ieri apparteneva a intere categorie di startup.

Il punto non è se il paradigma “prompt → app” sia reale. Lo è già, in forma imperfetta ma operativa. Il punto è capire chi sopravvive quando questa astrazione smette di essere una demo e diventa infrastruttura. Qui la retorica si scontra con la fisica economica.

Negli ultimi quindici anni abbiamo costruito un’intera industria sul concetto di layering. Il modello non parlava direttamente con l’utente; servivano API, orchestratori, ambienti di sviluppo, piattaforme di deploy. Ogni layer aggiungeva valore, ma anche attrito. Aziende come Replit e Vercel hanno capitalizzato proprio su questo attrito, trasformandolo in esperienza utente, affidabilità e lock-in. Nulla di illegittimo. Anzi, brillante esecuzione.

Poi arrivano i modelli generativi di nuova generazione e fanno una cosa che la Silicon Valley adora: saltano passaggi. Non perché siano più intelligenti, ma perché sono abbastanza intelligenti da rendere superfluo ciò che prima era indispensabile. È un dettaglio semantico con implicazioni miliardarie.

La frase “the harness was never the moat” suona bene, ma è un’ipersemplificazione utile più per i tweet che per i bilanci. Il vero moat non è mai stato solo tecnico. È sempre stato socio-tecnico. Distribuzione, fiducia, ecosistema, integrazione. Nessuno abbandona una piattaforma perché un modello è più bravo a scrivere codice; lo fa quando l’intero sistema di lavoro diventa obsoleto. Ed è qui che la partita si complica.

Un CEO con memoria storica ricorda bene cosa accadde con il cloud. Quando Amazon Web Services iniziò a erodere il valore dei data center tradizionali, non distrusse immediatamente i system integrator. Li costrinse a evolvere. Alcuni lo fecero. Altri scomparvero con dignità. La stessa dinamica si sta ripetendo, ma con una velocità superiore e con un dettaglio inquietante: questa volta il layer che viene compresso è cognitivo, non solo infrastrutturale.

Il passaggio da “Model → API → Tooling → App” a “Model = Tool + Builder + Runtime” non è una semplice ottimizzazione. È una ridefinizione del concetto stesso di software. Se il modello diventa capace di generare, orchestrare e distribuire, allora il software smette di essere un artefatto statico e diventa un processo continuo. Una funzione, non un prodotto. Una pipeline, non un’applicazione.

Questa trasformazione ha un effetto collaterale che molti sottovalutano: riduce drasticamente il valore del middleware generico. Tutto ciò che non è specifico, proprietario o profondamente integrato tende a diventare commodity. È una legge non scritta della tecnologia, osservata più volte, da Microsoft negli anni ’90 fino a Google nel decennio successivo.

Le startup più esposte sono quelle che hanno costruito valore principalmente sull’orchestrazione generica. Interfacce eleganti, certo. Workflow fluidi, senza dubbio. Ma se il core è semplicemente “rendere utilizzabile un modello”, allora il rischio è esistenziale. Quando il modello stesso diventa utilizzabile, l’intermediazione perde senso.

Non significa che queste aziende siano condannate. Significa che devono spostarsi. E rapidamente.

Il vero terreno difendibile si sta già delineando, ed è molto meno glamour di quanto piaccia raccontare nelle conferenze. Settori verticali con complessità regolatoria, dati proprietari difficili da replicare, workflow aziendali radicati e costosi da migrare. In altre parole: tutto ciò che non può essere generato da un prompt.

Nel settore sanitario, ad esempio, il valore non è nella capacità di generare codice per una cartella clinica, ma nella conformità normativa, nella gestione dei dati sensibili e nell’integrazione con sistemi legacy che nessun modello può semplicemente “immaginare”. Lo stesso vale per il legale, la finanza, l’industria manifatturiera. Lì il software non è solo funzionalità; è responsabilità.

Un osservatore superficiale potrebbe dire che stiamo assistendo alla democratizzazione dello sviluppo software. Ed è vero, ma solo fino a un certo punto. Ogni ondata di astrazione ha promesso di eliminare la complessità. Nessuna ci è mai riuscita davvero. Ha solo spostato la complessità altrove.

Il passaggio dal codice all’intento non elimina il bisogno di architettura; lo rende invisibile fino a quando non fallisce. E quando fallisce, fallisce in modo spettacolare.

Qui emerge una distinzione fondamentale che separa hype e realtà. Costruire una demo funzionante in pochi minuti è impressionante. Costruire un sistema scalabile, sicuro, osservabile e conforme è un’altra storia. Le aziende non pagano per la velocità di prototipazione; pagano per la prevedibilità del comportamento.

È per questo che il vantaggio competitivo di piattaforme come Vercel o Replit non svanirà dall’oggi al domani. Hanno costruito qualcosa di più profondo di una semplice interfaccia. Hanno costruito abitudini. E le abitudini, in tecnologia, sono spesso più resilienti del codice.

Detto questo, ignorare il cambiamento sarebbe ingenuo. Quando un modello inizia a integrare capacità di deployment, gestione dello stato e orchestrazione multi-step, non sta solo migliorando. Sta invadendo territori che prima richiedevano intere stack tecnologiche.

La vera domanda strategica non è “chi verrà sostituito”, ma “dove si sposterà il margine”. Storicamente, il margine si sposta verso ciò che è scarso. E in un mondo dove la generazione di codice diventa abbondante, ciò che resta scarso è il contesto. Dati proprietari, conoscenza del dominio, integrazione profonda con i processi aziendali.

Un paradosso interessante emerge osservando questo fenomeno. Più i modelli diventano potenti, meno conta la loro potenza in senso assoluto. Conta invece come vengono incastonati in sistemi reali. È la differenza tra tecnologia e prodotto, una distinzione che la Silicon Valley ama ignorare fino a quando il mercato non la costringe a ricordarla.

L’analogia più calzante forse non viene dal software, ma dall’energia. Quando l’elettricità è diventata ubiqua, il valore non è scomparso. Si è spostato verso le applicazioni che la utilizzavano in modo più efficace. Lo stesso accadrà con l’intelligenza artificiale.

In questo contesto, aziende come Anthropic non stanno semplicemente competendo con startup specifiche. Stanno ridefinendo il livello a cui si gioca la partita. È un movimento più simile a quello di AWS che a quello di una nuova libreria JavaScript. E chi ha memoria ricorda come è andata a finire.

Una frase sintetizza bene questa fase: il software sta diventando liquido. Non più pacchetti distribuiti, ma flussi generati on demand. Non più versioni, ma iterazioni continue. Non più sviluppo, ma negoziazione con un sistema intelligente.

Questa trasformazione ha implicazioni anche culturali, oltre che economiche. Il ruolo dello sviluppatore cambia, ma non scompare. Si sposta da scrittore di codice a orchestratore di sistemi. Un cambiamento che molti accolgono con entusiasmo e altri con un certo disagio, comprensibile.

Alla fine, la narrativa dell’estinzione è sempre seducente. Fa clic, genera discussione, alimenta l’ecosistema mediatico. La realtà è più noiosa e più interessante allo stesso tempo. Le aziende non muoiono perché la tecnologia cambia; muoiono perché non riescono a cambiare abbastanza velocemente.

Chi ha costruito valore reale, basato su utenti, workflow e dati, ha ancora carte da giocare. Chi ha costruito solo interfacce sopra modelli, probabilmente dovrà reinventarsi. Non è una tragedia. È il ciclo naturale dell’innovazione.

Un ultimo dettaglio, spesso trascurato, merita attenzione. L’espansione del “model as product” non riduce solo il numero di layer tecnologici. Riduce anche la distanza tra idea e implementazione. Questo ha un effetto inflazionistico sul software. Più applicazioni vengono create, meno ciascuna vale, a meno che non abbia qualcosa di realmente unico.

Ed è qui che la storia si chiude, almeno per ora, con una nota quasi ironica. Dopo decenni passati a costruire astrazioni per semplificare lo sviluppo, stiamo tornando a una verità elementare: il valore non è mai stato nel codice. È sempre stato nel problema che quel codice risolve. Tutto il resto è, inevitabilmente, comprimibile.