--- title: "ShipReal: Da vibe coder a ingegnere vero" description: "La tua AI ha scritto l'app. Nessuno ha scritto la parte che la tiene in piedi. Questo corso di 20 ore chiude quel gap." canonical: "https://shipreal.dev/it" last-updated: "2026-08-31" --- # Da vibe coder a ingegnere vero > La tua AI ha scritto l'app. Nessuno ha scritto la parte che la tiene in piedi. Questo corso di 20 ore chiude quel gap. Narrazione in inglese, sottotitoli in italiano. **38 moduli, postmortem reali, esercitazioni pratiche e quiz ad autovalutazione.** [YouTube](https://www.youtube.com/watch?v=fyHbx9de3GI&list=PLFEcqBh9-Xwo) · [Teachable](https://shipreal.teachable.com/courses/course/lectures/66619411) ## Contenuti del corso ### Introduzione La tua mappa dell'intero corso: cosa consegna ogni modulo di approfondimento e come le undici parti si costruiscono una sull'altra. - **Introduzione: la strada davanti** (13 capitoli, ~25 min): La mappa sul tavolo: tutti i 38 moduli, cosa consegna ogni approfondimento e a quale modulo saltare quando qualcosa si rompe. ### Parte 1: Il cambio di mentalità Ricabla il modo in cui pensi al software che funziona: sistemi, stato e trade-off. Il livello di criterio che l'AI non può darti. - **L'illusione del 'funziona'** (12 capitoli, ~28 min): Il ciclo di vita di una richiesta, gli ambienti e l'iceberg della produzione: perché 'gira sul mio laptop' non significa quasi niente. - **Pensare in sistemi e stato** (12 capitoli, ~29 min): Stato, effetti collaterali e idempotenza: perché 'rilancialo e basta' a volte peggiora le cose. - **Decisioni, complessità e astrazione** (14 capitoli, ~36 min): Trade-off, YAGNI e quando un'astrazione si paga l'affitto: le decisioni di criterio che l'AI non può prendere per te. ### Parte 2: Le fondamenta dello sviluppatore Il mestiere quotidiano: Git come strumento di pensiero, un workflow AI-native, runtime, algoritmi, architettura frontend e il campo minato delle dipendenze. - **Il version control come strumento di pensiero** (13 capitoli, ~33 min): Git oltre commit e push: strategia di branching, bisect e blame come archeologia. - **Il workflow di ingegneria AI-native** (13 capitoli, ~31 min): Il prompting come scrittura di specifiche, la review di codice che non hai scritto tu e i guardrail che rendono sicura la velocità dell'AI. - **Come gira il codice: il livello runtime** (13 capitoli, ~33 min): Processi, memoria ed event loop: perché Node si blocca e perché il GIL di Python conta. - **Pensiero algoritmico: complessità e strutture dati** (13 capitoli, ~27 min): Intuito per il Big-O e array vs mappe vs alberi: quando N al quadrato ti uccide in silenzio a 10.000 utenti. - **Architettura frontend: cosa costruisce l'AI per te (e cosa sbaglia)** (13 capitoli, ~35 min): Modelli di rendering, gestione dello stato e le parti del frontend che l'AI imposta male. - **Gestione delle dipendenze: il campo minato nascosto** (12 capitoli, ~31 min): Lockfile, le bugie del semver e gli attacchi supply-chain: la storia di left-pad e come non essere il protagonista del sequel. ### Parte 3: Il livello dei dati Database come modelli mentali: tabelle e indici prima delle query, SQL senza paura e migrazioni che non buttano giù la produzione. - **Fondamenta dei database: pensare in dati** (13 capitoli, ~33 min): Pensare in tabelle, indici e vincoli prima di scrivere una sola query. - **SQL e pensiero per query** (13 capitoli, ~33 min): Join senza paura, query plan che sai davvero leggere e le query che si sciolgono su larga scala. - **Dati su larga scala: mutazioni, migrazioni e oltre** (13 capitoli, ~34 min): Mutazioni, migrazioni e backfill che non si portano giù la produzione. ### Parte 4: Reti e contratti Come i sistemi si parlano: APIs come contratti, la catena dal DNS all'HTTP su cui vive ogni richiesta e i pattern real-time. - **Progettare API come contratti** (13 capitoli, ~35 min): Pensiero REST vs RPC, versioning e far evolvere le APIs senza rompere chi ci dipende. - **Fondamenta di networking** (12 capitoli, ~33 min): DNS, TCP, TLS, HTTP: la catena su cui ogni richiesta vive o muore. - **Pattern real-time ed event-driven** (12 capitoli, ~33 min): WebSocket, server-sent event e flussi event-driven: per quando il polling smette di bastare. ### Parte 5: Fortificazione Farlo sopravvivere al contatto con la realtà: sicurezza di default, gestione degli errori resiliente, test che comprano fiducia e osservabilità che risponde a 'cosa si è rotto alle 3 di notte'. - **Sicurezza di default** (12 capitoli, ~35 min): I rischi principali di OWASP, injection e fallimenti di auth: gli attacchi che trovano te, non il contrario. - **Gestione degli errori e resilienza** (12 capitoli, ~32 min): Timeout, retry con backoff e circuit breaker: fallire con grazia invece che con fragore. - **Test: fiducia, non coverage** (12 capitoli, ~33 min): Test che comprano fiducia invece di numeri di coverage: cosa testare, cosa saltare e perché. - **Osservabilità: log, metriche e trace** (15 capitoli, ~33 min): Log, metriche e trace che rispondono a 'cosa si è rotto alle 3 di notte' prima dei tuoi utenti. ### Parte 6: Infrastruttura e deploy Su cosa poggia il tuo codice: cosa risolvono davvero i container, concetti cloud che sopravvivono a qualsiasi redesign della console e pipeline che bloccano i deploy sbagliati. - **Container: perché, non come** (12 capitoli, ~35 min): Cosa risolve davvero Docker: immagini vs container, e perché 'funziona nel container' finalmente significa qualcosa. - **Infrastruttura cloud: concetti, non click in console** (12 capitoli, ~38 min): L'albero decisionale dei servizi gestiti: concetti cloud che sopravvivono a qualsiasi redesign della console. - **CI/CD: la pipeline che ti protegge** (12 capitoli, ~33 min): La pipeline che blocca i deploy sbagliati prima che li trovino i tuoi utenti. ### Parte 7: Architettura e scala Progettare per la crescita: architettura monolith-first, code, caching, profiling prima di ottimizzare e intuito per i sistemi distribuiti. - **Pattern di architettura: monoliti, servizi e la via di mezzo** (13 capitoli, ~34 min): Pensiero monolith-first, quando i servizi si guadagnano la loro complessità e la via di mezzo che nessuno pubblicizza. - **Elaborazione asincrona e code** (14 capitoli, ~34 min): Le code di messaggi: perché ogni sistema vero ne ha una e cosa succede quando i consumer restano indietro. - **Strategie di caching** (12 capitoli, ~30 min): Redis, TTL e l'invalidazione della cache: notoriamente uno dei due problemi difficili dell'informatica. - **Performance, profiling e scaling** (14 capitoli, ~33 min): Profila prima di ottimizzare: trovare il vero collo di bottiglia invece di quello che hai indovinato. - **Intuito per i sistemi distribuiti** (12 capitoli, ~34 min): Le fallacie del calcolo distribuito, e l'intuito per riconoscerle nel tuo stesso design. ### Parte 8: Il livello business Il codice che paga le bollette: pagamenti e compliance, metriche che predicono davvero il fatturato e attribuzione senza raccontarti storie. - **Pagamenti, abbonamenti e compliance** (12 capitoli, ~34 min): Webhook di pagamento che sopravvivono ai retry, macchine a stati per gli abbonamenti e le basi di compliance che non puoi saltare. - **Metriche di business e product analytics** (13 capitoli, ~35 min): Le metriche che predicono davvero il fatturato, e quelle di vanità che non lo fanno. - **Acquisizione utenti, ads e attribuzione** (13 capitoli, ~36 min): UTM, finestre di attribuzione e i conti sugli ads senza raccontarti storie. ### Parte 9: Prodotti potenziati dall'AI Mettere in produzione l'intelligenza in modo responsabile: come imparano i modelli, embedding e RAG, e feature AI in produzione con eval e budget di costo. - **Fondamenti di machine learning: come imparano i modelli** (12 capitoli, ~33 min): Come imparano davvero i modelli: abbastanza per non farti incantare da demo e vendor. - **Aggiungere intelligenza alla tua app** (13 capitoli, ~33 min): Embedding, RAG e scegliere il modello giusto per il lavoro invece di quello che fa più rumore. - **Costruire feature AI per la produzione** (12 capitoli, ~33 min): Eval, budget di costo e latenza, e feature LLM che sopravvivono agli utenti veri. ### Parte 10: Mestiere e padronanza in produzione Le abitudini da senior: debugging guidato dalle ipotesi e la checklist di go-live che separa i lanci dalle scommesse. - **Il debugging come disciplina** (12 capitoli, ~35 min): Debugging guidato dalle ipotesi: riprodurre, isolare, dimostrare, non print e preghiere. - **Production readiness e operations continue** (14 capitoli, ~37 min): La checklist di go-live, la gestione degli incidenti e il ritmo delle operations che inizia dopo il lancio. ### Parte 11: Espansione mobile Su un telefono cambia tutto: dati offline-first, reti che spariscono a metà richiesta e i treni di rilascio degli app store. - **Modelli mentali specifici del mobile** (13 capitoli, ~33 min): Perché il mobile non è un sito piccolo: cicli di vita, permessi e l'OS come padrone di casa severo. - **Dati e rete sul mobile** (12 capitoli, ~37 min): Dati offline-first, conflitti di sincronizzazione e reti che spariscono a metà richiesta. - **Release e distribuzione mobile** (12 capitoli, ~30 min): La review degli app store, i treni di rilascio e perché non puoi fare hotfix a un binario. ### Congedo: Il congedo La chiusura del cerchio: cosa è cambiato nel tuo modo di pensare e l'unica cosa da fare subito, finché è fresca. - **Il congedo: ora vai a rilasciare qualcosa che regge** (7 capitoli, ~12 min): Cosa è cambiato nel modo in cui pensi, l'unica cosa da fare questa settimana e come mantenere il criterio che hai appena costruito. ## Domande frequenti ### Per chi è questo corso? Sviluppatori che hanno imparato costruendo, non studiando. Metti in produzione app con strumenti AI ogni giorno (Copilot, Claude, ChatGPT) e sei più veloce che mai. Ma c'è un gap tra "gira" e "è ingegnerizzato", e lo senti quando qualcosa si rompe alle 3 di notte o quando un dev senior ti chiede "perché l'hai fatto così?" Non sei un principiante. Sai scrivere codice ma non sempre sai spiegare cosa succede dopo aver premuto Invio. È esattamente il gap che questo corso chiude. ### Cosa mi insegna che non posso ottenere con un prompt? Criterio. L'AI ormai scrive l'80% del tuo codice; il 20% che conta è architettura, gestione degli errori, modello di sicurezza e progettazione del sistema. Quel 20% richiede di capire trade-off, contesto e conseguenze, che è esattamente ciò che l'AI non può fare al posto tuo. Ogni modulo prende qualcosa che già "sai" (database, APIs, deploy) e ti mostra cosa ti manca: il ciclo di vita di una richiesta, i query plan, le retry storm, l'invalidazione della cache, la checklist di go-live. ### Serve una laurea in CS o uno stack specifico? Nessuna laurea richiesta. Il corso è costruito per chi l'ha saltata, o l'ha presa e ne ha dimenticato gran parte. È concept-first: gli esempi usano strumenti mainstream come PostgreSQL, Redis, Docker e Stripe, ma ogni modulo insegna il modello mentale, non a cliccare i bottoni di un vendor, quindi vale per qualsiasi stack usi per andare in produzione. ### Cosa sono i postmortem e le esercitazioni? Ogni modulo di Completo seziona un disastro ingegneristico reale e documentato: azienda reale, data reale, root cause reale, e cosa lo avrebbe evitato. Poi l'esercitazione applica il modulo al tuo progetto già in produzione, non a un repo giocattolo, così ogni modulo finisce con il tuo sistema reale un po' più production-grade di prima. ### Quanto tempo ci vuole? Completo sono 38 moduli didattici da 25-40 minuti l'uno, più le esercitazioni, e si chiude con un breve congedo. Calcola circa 20 ore di video, e più o meno il doppio con il lavoro pratico. È strutturato in undici parti indipendenti, quindi puoi anche saltare dritto alla parte che sta andando a fuoco in questo momento: deploy rotti? Parte 6. Query lente? Parte 3. ### Ricevo un certificato? Sì! E te lo guadagni, non te lo regalano per aver guardato i video: il certificato di fine corso ShipReal, emesso da Teachable. Ogni modulo si chiude con un quiz ad autovalutazione da 10 domande e una domanda aperta, e il certificato arriva quando li hai completati tutti. ### La mia azienda può acquistarlo per tutto il team? Sì. I posti si acquistano direttamente, al prezzo per posto indicato nei piani per team qui sopra, con un'unica fattura, e seguono il team quando le persone entrano ed escono. Ogni ingegnere riceve il corso Completo, applicato al proprio progetto e non a una sandbox condivisa. Oltre i 20 posti, o se servono un PO, il single sign-on via SAML o OIDC, o i moduli consegnati nel vostro LMS come pacchetti SCORM o xAPI o via LTI, dentro Cornerstone, Workday, Moodle o qualunque cosa usi la vostra azienda, scrivetemi e lo definiamo insieme. ### E se non fa per me? Parti dalle panoramiche gratuite su YouTube: ti diranno in fretta se il corso parla la tua lingua. Oltre a questo, la garanzia nella tabella prezzi è tutta la risposta, e i dettagli per farla valere sono nella politica di rimborso. ### In che lingue è disponibile? Per ora la narrazione è solo in inglese. Completo su Teachable include sottotitoli in inglese, francese, tedesco, italiano, spagnolo ed ebraico. Altre lingue in arrivo. ## Legal [Privacy Policy](https://shipreal.dev/privacy) · [Terms of Service](https://shipreal.dev/terms) · [Refund Policy](https://shipreal.dev/refunds)