Come Diventare un Ingegnere AI nel 2026
Senza una laurea in informatica.
Senza un bootcamp.
Senza sapere cosa sia un transformer oggi.
Ecco cosa nessuno ti dice:
Le aziende che assumono ora non hanno bisogno di persone che capiscono la matematica.
Hanno bisogno di persone che sappiano costruire sistemi che sopravvivano in produzione.
C'è una differenza.
Un wrapper per chatbot non è un sistema.
Una chiamata a uno strumento non è un agente.
Conoscere LangChain non significa saper fare ingegneria dell'infrastruttura.
Il divario tra queste due cose vale circa 150.000 dollari di stipendio.
Questa è la roadmap esatta per colmarlo.
Salvala. La leggerai due volte.
PRIMA LA DURA VERITÀ
La maggior parte degli sviluppatori che costruiscono AI oggi stanno costruendo giocattoli.
Avvolgono GPT con qualche prompt. Lo chiamano "prodotto AI". Si chiedono perché nessuno lo paga.
Il mercato è invaso da strati sottili sopra gli LLM.
Non sono aziende. Sono funzionalità in attesa di essere fagocitate dalle Big Tech.
Ecco per cosa le aziende pagano davvero nel 2026:
→ Agenti che non si rompono alle 2 del venerdì notte
→ Sistemi che puoi misurare e dimostrare che non stanno regredendo
→ Infrastrutture che fanno performare lo stesso modello l'86% meglio
L'ultimo punto non è fantascienza.
Anthropic ha eseguito lo stesso modello (Opus 4.5) su due infrastrutture diverse.
→ Infrastruttura Claude Code: 78% sul benchmark CORE
→ Infrastruttura Smolagents: 42% sul benchmark CORE
Stesso modello. Infrastruttura diversa. 36 punti di differenza.
L'infrastruttura è il lavoro.
COSA FA DAVVERO UN INGEGNERE AI NEL 2026
Non scrivere prompt. Non scegliere modelli.
Un ingegnere AI costruisce e gestisce il sistema attorno al modello.
Questo significa:
→ Progettare il ciclo dell'agente e la distribuzione degli strumenti
→ Ingegnerizzare il contesto — quali token vanno davanti al modello in ogni passaggio
→ Scrivere strumenti che il modello seleziona effettivamente correttamente
→ Aggiungere memoria, persistenza e sandboxing per il traffico in produzione
→ Collegare valutazioni e porte di regressione CI così che "migliore" diventi misurabile
→ Rilasciare agenti che sopravvivono a utenti reali e costi reali
I quattro elementi primitivi del contesto di cui ogni ingegnere di agenti ha bisogno:
Scrittura — blocchi per appunti, file di memoria che l'agente legge e aggiorna
Selezione — recupero nel punto di utilizzo, non scaricamento iniziale
Compressione — riassunto all'85-95% della finestra di contesto
Isolamento — sub-agenti con le proprie finestre di contesto separate
Questo si chiama ingegneria del contesto. L'ingegneria dei prompt è morta come competenza a sé stante. L'ingegneria del contesto l'ha sostituita.
LA ROADMAP IN 6 FASI
17 settimane se sei full-time. 40 settimane se lo fai nel tempo libero.
Ogni fase ha un progetto concreto. Nessuna fase finisce senza aver rilasciato qualcosa.
FASE 0: Costruisci Modelli Mentali Corretti (Settimane 1-2)
Non scrivere ancora una singola riga di codice per agenti.
La maggior parte dei principianti salta questo passaggio. Si tuffano direttamente nei tutorial. Poi scrivono codice di cui non sanno ragionare quando si rompe.
Tre cose da capire a fondo prima di qualsiasi altra cosa:
1. Workflow vs Agente
Un workflow ha un flusso di controllo fisso che hai scritto tu. Un agente prende le proprie decisioni sul flusso di controllo all'interno di un ciclo.
Costruire un agente quando hai bisogno di un workflow costa 10 volte di più e si rompe il doppio delle volte.
2. I 5 pattern di workflow (da Anthropic)
→ Concatenamento di prompt: passa l'output di una chiamata alla successiva
→ Routing: modelli diversi per compiti diversi
→ Parallelizzazione: esegui più compiti contemporaneamente
→ Orchestrator-worker: un cervello, molte mani
→ Evaluator-optimizer: genera → giudica → migliora
3. L'infrastruttura (harness)
L'infrastruttura è ciò che si trova tra te e l'API del modello.
Pensala come un sistema operativo:
→ Modello = CPU (calcolo grezzo)
→ RAM = finestra di contesto
→ OS = infrastruttura
→ App = le competenze del tuo agente
Il sistema operativo determina cosa la CPU può effettivamente fare. L'infrastruttura determina cosa il modello può effettivamente fare.
Progetto Fase 0: Scrivi un documento di 2 pagine — con parole tue — che definisca: workflow vs agente, i 5 pattern di workflow, i 4 elementi primitivi del contesto, il pattern orchestrator-worker.
Se non riesci a scriverlo senza guardare, non hai letto abbastanza attentamente.
FASE 1: Costruisci il Tuo Primo Agente da Zero (Settimane 3-5)
Scrivi un agente due volte.
Prima: con l'SDK grezzo di Anthropic. ~100 righe di Python.
Poi: con il Claude Agent SDK.
Poi senti la differenza.
Costruzione #1 — Il Ciclo Grezzo
Il ciclo dell'agente non è magia.
- Chiama il modello con messaggi e strumenti
- Estrai i blocchi tool_use
- Esegui lo strumento
- Aggiungi tool_result
- Ripeti finché stop_reason = end_turn
Scrivilo in meno di 100 righe tu stesso.
Una volta fatto, ogni framework diventa leggibile.
Dagli 3 strumenti: → web_search → read_file → write_file
Eseguilo su un compito di ricerca. Leggi ogni passo della traccia.
Costruzione #2 — Lo Stesso Agente su Claude Agent SDK
Il Claude Agent SDK è la stessa infrastruttura che alimenta Claude Code.
Aggiungi:
→ CLAUDE.md con le convenzioni del progetto
→ Una Skill (una cartella che definisce un formato di output "research-summary")
→ Un hook PostToolUse che formatta automaticamente ogni file che l'agente scrive
→ Un sub-agente generato tramite il tool Task
Poi scrivi 200 parole rispondendo: "Cosa mi ha dato gratuitamente l'infrastruttura che ho scritto io stesso nella Costruzione #1?"
Progetto Fase 1: Un agente di briefing quotidiano. Legge i tuoi appunti Markdown + feed RSS. Scrive un briefing riassunto su disco ogni mattina. Eseguilo per una settimana. Guardalo fallire. Risolvilo.
FASE 2: Costruisci un Agente Reale con un'Architettura Propria (Settimane 6-9)
Ora costruisci su LangGraph + Deep Agents.
Questo è lo stack di produzione.
LangGraph ti dà:
→ Macchina a stati (nodi + archi)
→ Checkpoint PostgresSaver (sopravvive a qualsiasi kill del processo)
→ Debug con viaggio nel tempo (torna indietro a qualsiasi passo)
→ Interruzioni human-in-the-loop
→ Osservabilità di prima classe tramite LangSmith
Deep Agents (l'infrastruttura impacchettata di LangChain) ti dà:
→ Middleware di pianificazione
→ Filesystem virtuale
→ Generazione di sub-agenti
→ Compressione automatica del contesto
→ Skills
Il concetto chiave: middleware
Il middleware è come personalizzi un agente impacchettato senza doverlo biforcare.
Quattro hook che contano:
→ before_agent — viene eseguito prima che inizi il ciclo
→ wrap_model_call — avvolge ogni chiamata LLM
→ before_tools — viene eseguito prima che qualsiasi strumento venga eseguito
→ after_tools — viene eseguito dopo che qualsiasi strumento viene eseguito
Progetto Fase 2: Agente Analista di Ricerca
Input: una domanda di ricerca
Architettura:
→ L'agente principale pianifica, scrive una TODO list sul filesystem virtuale
→ Genera 3 sub-agenti di ricerca in parallelo (contesto isolato)
→ I sub-agenti scrivono i risultati in file, restituiscono brevi riassunti al genitore
→ Un sub-agente di citazione verifica le affermazioni
→ L'agente scrittore produce un Markdown finale con citazioni in linea
→ Lo stato persiste tramite PostgresSaver — uccidi il processo, riprendi da dove era rimasto
→ Interruzione human-in-the-loop: chiedi conferma prima di superare $1 in token
Rilascia un URL di traccia LangSmith insieme al tuo README.
FASE 3: Costruisci il Livello dell'Infrastruttura da Solo (Settimane 10-13)
Questa è la fase a più alta leva dell'intera roadmap.
Smetti di usare un'infrastruttura impacchettata. Costruiscine una leggera tu stesso.
Non riuscirai mai a fare i giusti compromessi sull'infrastruttura in produzione finché non ne avrai costruita una almeno una volta.
I 10 componenti di un'infrastruttura moderna:
- Controllo del ciclo — il ciclo while che guida modello → strumenti → modello
- Distribuzione degli strumenti — registro, validazione dello schema, chiamate parallele, tentativi
- Gestione del contesto — assemblaggio del prompt di sistema, compattazione all'85% della finestra
- Persistenza — checkpoint dello stato ad ogni nodo per riprendere, tornare indietro, biforcare
- Orchestrazione dei sub-agenti — figli con contesto isolato, riassunti compressi di ritorno
- Skills e divulgazione progressiva — carica le capacità solo quando pertinenti
- Hook — PreToolUse, PostToolUse, PreCompact, Stop
- Osservabilità — span OTEL per ogni chiamata al modello, chiamata allo strumento, invocazione di sub-agente
- Sandboxing — esecuzione del codice in un contenitore a cui il modello non ha mai credenziali
- Mediazione dell'autenticazione — le credenziali non entrano mai nel contesto del modello
Progetto Fase 3: Scrivi una mini-infrastruttura in ~1.500 righe di Python.
Deve includere:
→ Registro degli strumenti da un decorator @tool con generazione di schema JSON
→ Caricatore di prompt di sistema in stile CLAUDE.md
→ Caricatore di divulgazione progressiva SKILL.md
→ Primitiva di generazione di sub-agenti con contesto isolato
→ Scaricamento su filesystem: qualsiasi risultato dello strumento oltre 20K token
→ scrivi su disco, sostituisci nel contesto con percorso + anteprima di 10 righe
→ Auto-compattazione all'85% della finestra di contesto
→ Sistema di hook inseribile (pre_tool, post_tool, stop)
→ Tracciamento OpenTelemetry
→ Ripresa durevole: persisti su SQLite dopo ogni passo, ricarica per ID esecuzione
Il vero risultato: un'analisi post-mortem di 1.000 parole che confronta la tua mini-infrastruttura con Claude Agent SDK e Deep Agents. Cosa hai fatto bene. Cosa hai tagliato. Cosa faresti diversamente.
FASE 4: Costruisci l'Infrastruttura di Valutazione e Regressione (Settimane 14-17)
Senza questo, ogni "miglioramento" è solo sensazione.
Qui è dove la maggior parte degli ingegneri si blocca.
Riescono a costruire un grande agente. Non riescono a dire se la loro prossima modifica lo ha migliorato o peggiorato.
I 4 tipi di valutazione che devi implementare:
1. Valutazioni a turno singolo
Dato questo input, l'output è giusto? Il più economico. Valutatori deterministici quando possibile. Esegui costantemente.
2. Valutazioni di traiettoria
L'agente ha chiamato la giusta sequenza di strumenti con i giusti argomenti? Testa varianti a passo singolo, turno completo e multi-turno.
3. LLM-as-judge
Per output aperti: report di ricerca, revisione del codice, spiegazioni. Calibra settimanalmente rispetto a esempi valutati da umani.
4. Valutazioni dello stato finale
Per agenti con stato: il database è stato scritto correttamente? I file giusti sono cambiati? Confronta lo stato finale dell'ambiente con la verità di base.
La scomoda verità sulle valutazioni:
I modelli possono rilevare quando vengono valutati. Si comportano diversamente sugli input di valutazione.
Progetta la tua suite di valutazione per prevenirlo. Usa query di produzione reali, non sintetiche.
Progetto Fase 4: Infrastruttura di regressione attorno al tuo agente della Fase 2.
→ Dataset aureo: 30-50 domande di ricerca valutate a mano (3 livelli di difficoltà)
→ Valutatori deterministici per query fattuali
→ LLM-as-judge con rubrica a 5 criteri per quelle aperte
→ Valutazione di traiettoria: l'agente ha pianificato, generato 2+ sub-agenti, citato le fonti, finito sotto budget?
→ Collega a GitHub Actions: blocca il merge se il tasso di superamento del dataset aureo scende di 3+ punti
→ Campionamento in produzione: l'1% delle tracce live viene valutato automaticamente ogni notte
FASE 5: Indurimento in Produzione (Per Sempre)
Questa fase non finisce mai.
Cinque cose che contano per sempre:
1. Disciplina dei costi
→ Fai cache del tuo CLAUDE.md, prompt di sistema e definizioni degli strumenti — risparmia fino al 90%
→ Instrada per difficoltà: Haiku per turni semplici, Sonnet per la maggior parte dei compiti, Opus per ragionamenti complessi
→ API batch per lavoro non in tempo reale: 50% di sconto
→ Il multi-agente consuma ~15x i token del singolo agente — eseguilo solo quando il valore supera quella soglia
2. Latenza
→ Chiamate parallele agli strumenti, sempre — il prompt di sistema dell'agente di ricerca di Anthropic dice letteralmente "devi usare chiamate parallele agli strumenti"
→ Stream di output parziali all'interfaccia utente
→ Fan-out dei sub-agenti: un agente sequenziale di 60 passi
→ 10 passi lead + 5 sub-agenti paralleli di 10 passi
3. Sicurezza e sandboxing
→ Tutta l'esecuzione del codice in un sandbox (Modal, E2B): mai eseguire exec() dell'output del modello nel tuo processo principale
→ Credenziali mediate fuori dal contesto del modello: il modello non vede mai la chiave API che usa
→ Interruzioni human-in-the-loop su qualsiasi azione irreversibile
4. Monitoraggio e deriva
→ Avvisi su: costo dei token per richiesta, tasso di fallimento delle chiamate agli strumenti, punteggio LLM-as-judge, latenza p95
→ Ricalibra le valutazioni dopo ogni aggiornamento del modello — le infrastrutture codificano ipotesi su cosa il modello non può fare, e quelle ipotesi diventano obsolete
5. Resilienza
→ Esecuzione durevole (Inngest, Temporal, PostgresSaver) per qualsiasi agente che viene eseguito per oltre 60 secondi
→ Checkpoint dopo ogni nodo
→ Tornare indietro e biforcare dovrebbe essere sempre possibile
I 5 PROGETTI DI LIVELLO PRODUZIONE (Scegline uno e costruiscilo questo weekend)
Questi sono classificati per complessità.
Dimostrano ciò che le aziende hanno bisogno di vedere realmente.
Progetto 1: App Mobile Alimentata da AI con SLM
Costruisci un'app mobile offline-first usando modelli linguistici piccoli. Zero costi API. Privacy completa.
Cosa lo rende non banale:
→ Carica modelli on-demand, scarica sotto pressione di memoria
→ Finestra di contesto scorrevole con chunking semantico
→ Quantizzazione a 4 bit per dispositivi vecchi, 8 bit per quelli nuovi
→ Inferenza batch per ridurre i cicli di risveglio della batteria
Perché è importante: dimostri di capire i vincoli delle risorse e l'AI a livello di dispositivo. Non stai solo chiamando un'API — stai gestendo la pressione della memoria e la quantizzazione.
Progetto 2: Agente di Codifica Auto-Migliorante
Costruisci un agente che scrive codice, esegue test e impara dai fallimenti. Non si ferma finché il codice non è funzionante.
Cosa lo rende non banale:
→ Pianifica → Esegui → Testa
→ Ciclo di riflessione con limite massimo di iterazioni
→ Ambiente di esecuzione isolato per compito con limiti di risorse
→ Gerarchia di memoria: breve termine (ultime 5 iterazioni), lungo termine (pattern di successo), memoria dei fallimenti (firme di errore + soluzioni)
→ Analisi statica prima dell'esecuzione — rileva operazioni pericolose
Perché è importante: introduce cicli agentici. Mostra che capisci il debug in produzione e il perfezionamento iterativo.
Progetto 3: Cursor ma per Editor Video
Forka un editor open-source (Shotcut) e costruisci un agente AI che capisce l'intento di editing.
L'utente dice "rendilo cinematografico". L'agente gestisce tagli, transizioni e grading del colore.
Cosa lo rende non banale:
→ Modello visivo analizza ogni fotogramma + modello audio analizza il dialogo
→ Traduzione dell'intento: "cinematografico"
→ parametri concreti (ritmo, LUT, simulazione di messa a fuoco)
→ Rilevamento delle scene tramite analisi delle differenze tra fotogrammi
→ Anteprima incrementale — renderizza solo le sezioni interessate
Perché è importante: AI multimodale + integrazione di strumenti complessi. Ti distingue dal 99% dei costruttori di chatbot.
Progetto 4: Agente Sistema Operativo della Vita Personale
Costruisci un agente che gestisce il tuo calendario, le finanze e la salute. Pianifica con mesi di anticipo. Rileva il burnout analizzando i pattern di sonno e la densità degli incontri.
Cosa lo rende non banale:
→ Ingestione in tempo reale da calendario, finanze, salute, comunicazioni
→ Grafo della conoscenza personale di entità e relazioni
→ Thread in background eseguito ogni 6 ore che controlla anomalie
→ Allineamento ai valori: l'utente stabilisce le priorità (famiglia > lavoro) — ogni raccomandazione viene validata rispetto ad esse
→ Tutti i dati crittografati a riposo con chiavi controllate dall'utente
Perché è importante: richiede una gestione sofisticata del contesto e una progettazione etica dell'AI. Dimostra un'architettura di produzione incentrata sulla privacy.
Progetto 5: Agente di Workflow Aziendale Autonomo
Un agente che esegue workflow aziendali end-to-end.
Monitora Slack/Jira → pianifica l'esecuzione → delega compiti → riporta i risultati con registri di controllo completi.
Cosa lo rende non banale:
→ Basato su eventi: ascolta Slack, Jira, email, sistemi di monitoraggio
→ Delega multi-agente: orchestratore
→ agente di comunicazione, agente dati, agente di analisi, agente di documentazione
→ Auto-riparazione: backoff esponenziale, interruttori automatici, decisioni automatiche di ripetizione
→ Registro di controllo immutabile: ogni azione, chi l'ha autorizzata, qual è stato il risultato
→ Human-in-the-loop: l'agente propone un piano prima dell'esecuzione su workflow critici
Perché è importante: combina orchestrazione, sicurezza e osservabilità in un unico sistema scalabile. Questo è il portfolio che chiude il cerchio.
LO STACK (Cosa imparare realmente)
Framework: LangGraph 1.0 + Deep Agents
Perché non CrewAI, AutoGen o OpenAI Swarm?
→ CrewAI: demo più veloce, fragile in produzione. Usalo per hackathon.
→ AutoGen: fuso nel Microsoft Agent Framework. Futuro incerto.
→ OpenAI Swarm: esplicitamente "non pronto per la produzione" secondo lo stesso README di OpenAI.
LangGraph ti dà: macchina a stati + persistenza PostgresSaver + debug con viaggio nel tempo + osservabilità OTEL-friendly + agnostico rispetto al modello.
Riferimento infrastruttura: Claude Agent SDK
Studialo. Usalo. È la stessa infrastruttura di Claude Code.
CLAUDE.md + Skills + sub-agenti + hook + filesystem-come-memoria.
Ogni altra infrastruttura nel 2026 sta convergendo su questi elementi primitivi.
Osservabilità: Scegline uno
→ LangSmith: se vivi in LangGraph
→ Braintrust: se vuoi gating CI agnostico rispetto al framework ($249/mese fisso)
→ Arize Phoenix: se vuoi open-source + OTEL-native
Salta nel 2026:
→ OpenAI Swarm — non pronto per la produzione (puoi usare Kimi Agent Swarm)
→ OpenAI Assistants API — in dismissione a metà 2026
→ Costruire il tuo archivio vettoriale prima di aver misurato un effettivo problema di recupero
→ Piattaforme di agenti no-code a meno che non sia usa e getta
I NUMERI DI BENCHMARK (Maggio 2026)
SWE-bench Verified (compiti di codifica): → Claude Opus 4.7: ~87.6% → GPT-5.5: ~88.7%
GAIA (compiti generali degli agenti): → Claude Sonnet 4.5 è in testa con 74.6%
τ-bench (agenti di servizio clienti): → Claude Mythos Preview: 89.2%
Intuizione chiave: stesso benchmark, infrastruttura diversa = oscillazione di 10-36 punti.
Il modello conta meno dell'infrastruttura.
LA TEMPISTICA DI 17 SETTIMANE
Settimana 2 → Fase 0 completata. Sai spiegare un'infrastruttura in inglese semplice.
Settimana 5 → Fase 1 completata. Agente Claude Agent SDK rilasciato con una Skill, un hook, un sub-agente.
Settimana 9 → Fase 2 completata. Agente profondo LangGraph in esecuzione con persistenza PostgresSaver e tracce LangSmith.
Settimana 13 → Fase 3 completata. Mini-infrastruttura di 1.500 righe scritta e documentata.
Settimana 17 → Fase 4 completata. Dataset aurei, porte CI, un'esecuzione di benchmark pubblicata tramite Inspect.
Settimana 17+ → Fase 5. Per sempre.
Nel tempo libero con 10-15 ore a settimana: moltiplica tutto per 2.5x.
LA SCOMODA VERITÀ
La maggior parte delle persone leggerà questo e non farà nulla.
Lo metteranno nei segnalibri. Diranno "ottimo articolo". Torneranno a costruire wrapper.
La dura verità per il 2026:
→ I sostituibili: costruire thin wrapper GPT
→ Gli insostituibili: rilasciare sistemi autonomi con valutazioni e persistenza
Il divario tra loro è di 5 progetti e 17 settimane di lavoro concentrato.
Il 57% dei team ora ha agenti in produzione.
L'89% di questi ha cablato l'osservabilità.
La qualità è la barriera n.1 (il 32% dei team la cita).
Questo significa che l'intero campo è in un collo di bottiglia sugli ingegneri che sanno costruire valutazioni e infrastrutture.
Non sugli ingegneri che sanno chiamare un'API LLM.
Questa è l'offerta di lavoro.
CONCLUSIONE
Questa roadmap non ti renderà un ingegnere AI principale in 17 settimane.
Ti renderà qualcuno che sa costruire e rilasciare sistemi di agenti che sopravvivono al traffico di produzione.
Che è esattamente la cosa per cui le aziende stanno pagando in questo momento.
Ecco cosa voglio che tu faccia dopo:
1. Scegli un progetto. Inizia con il Progetto 1 se sei nuovo. Inizia con il Progetto 5 se stai già rilasciando codice. Inizia e basta.
2. Costruiscilo questo weekend. Il mercato premia il rilascio, non lo studio.
3. Documenta tutto: le tue decisioni architetturali, i tuoi fallimenti e recuperi, i tuoi cicli di autocorrezione.
4. Costruisci in pubblico. Taggami quando rilasci — lo amplificherò.
Entro il prossimo mese, il 90% delle persone non avrà fatto nulla. Starà ancora costruendo gli stessi wrapper.
L'altro 10% avrà rilasciato qualcosa di reale. Avrà i colloqui, le offerte e la leva professionale.
La scelta è semplice:
Diventa l'architetto che le aziende sono disperate di assumere. O diventa obsoleto.
La competenza è l'unica sicurezza lavorativa rimasta. I sistemi di produzione sono l'unico portfolio che conta.
Ora costruisci qualcosa che sopravviva alla realtà.
Rispondi con quale progetto stai iniziando. Leggo ogni risposta.
→ Ripubblica per condividere con la tua rete
→ Segui @sairahul1 per altre analisi come questa
