Definire
Partire da utente, problema, vincoli e criteri di successo prima di aprire un prompt.
corso laboratorio / metodo
Vibe Coding
Dal desiderio confuso a codice verificato.
Un percorso in otto moduli per imparare a progettare con l'AI senza consegnarle il volante: prima problema e architettura, poi prompt, codice, diff, test e revisione.
idea centrale
Il corso sposta l'attenzione dal codice prodotto al controllo del processo.
L'AI accelera la scrittura, ma non chiarisce da sola obiettivi, confini, rischi e qualita. Per questo la pagina ora segue lo stesso ordine del corso: capire, strutturare, generare, verificare.
cosa impari
Quattro abilita, non una lista di slogan.
Guidare
Usare l'AI come assistente operativo: prima piano e struttura, poi codice circoscritto.
Leggere
Capire il risultato generato a livello di file, dipendenze, flusso dati e responsabilita.
Verificare
Costruire abitudini di test, debug, review, sicurezza e pubblicazione responsabile.
roadmap formativa
Otto moduli, una progressione leggibile.
Prima costruisci giudizio, poi strumenti e specifiche. Solo dopo lavori su architettura, contesto, dialogo con l'AI, review e pubblicazione.
Dal codice scritto riga per riga al codice generato attraverso intenzioni, prompt e cicli di feedback.
Capisci cosa cambia quando il codice nasce da una conversazione e quali responsabilita restano tue.
Chat generaliste, IDE AI, generatori di interfacce, agenti CLI: forze, limiti e criteri di scelta.
Scegli lo strumento adatto invece di trattare chat, IDE e agenti come fossero la stessa cosa.
Definire problema, utente, vincoli e criteri di successo, poi tradurli in prompt operativi e iterabili.
Trasformi idee vaghe in problemi, vincoli e criteri di successo abbastanza chiari da guidare l'AI.
Per il prompt engineering in profondità: corso dedicato.
- 12 Da desiderio a problema: cinque domande prima di toccare la tastiera
- 13 Utente, contesto d'uso, casi reali
- 14 Vincoli: tempo, dati, piattaforma, budget, competenze
- 15 Criteri di successo: come si capisce che è fatto
- 16 Esercizio: trasformare tre idee vaghe in problemi definiti
- 17 Anatomia di un prompt utile: ruolo, contesto, obiettivo, vincoli, formato, verifiche
- 18 Chiedere prima un piano, poi il codice
- 19 Few-shot, esempi negativi e controesempi
- 20 Decomposizione: spezzare richieste grandi in passi piccoli
- 21 Iterare sul prompt: cosa cambiare quando l'output non torna
- 22 Anti-pattern: prompt vaghi, ambigui, contraddittori, sovraccarichi
Frontend, backend, dati, stato, API, autenticazione: la mappa minima per sapere cosa chiedere prima di generare.
Disegni la struttura minima dell'app prima che il modello inizi a scrivere file.
Per i fondamenti completi: corso Architettura del software.
- 23 Frontend, backend, dati, stato: cosa vive dove
- 24 API, autenticazione, autorizzazione, sessioni
- 25 Database: quando serve, quale tipo, come si modella
- 26 Il confine fra client e server: cosa non spostare mai
- 27 Decisioni reversibili vs irreversibili in architettura
- 28 Disegnare l'architettura prima di farla generare
Cosa ricorda davvero un LLM, come scrivere file di regole e convenzioni, come tenere il contesto vivo nel tempo.
Prepari regole, memoria e contesto per sessioni di lavoro piu lunghe e meno caotiche.
- 29 Finestra di contesto: cosa ricorda davvero un LLM
- 30 File di regole: cosa metterci
- 31 Convenzioni di progetto, stile, vincoli: scriverli una volta sola
- 32 Aggiornare il contesto man mano che il progetto cresce
- 33 Memoria persistente, RAG, allegati: quando servono
- 34 Anti-pattern: incollare l'intera repo in chat
Modifiche piccole e reversibili, alternative, trade-off, recupero dai loop. Git come rete di sicurezza minima.
Impari a chiedere piani, alternative e revisioni senza perdere il controllo della direzione.
Per il controllo versione in profondità: corso Git e controllo versione.
- 35 Modifiche piccole, leggibili, reversibili: la regola del diff
- 36 Git essenziale per il vibe coder: branch, commit, revert, blame
- 37 Chiedere alternative e trade-off, non soluzioni uniche
- 38 Quando l'AI va in loop: come uscirne
- 39 Pair con l'agente: chi guida, chi verifica
- 40 Quando fermarsi e scrivere a mano
Lettura strutturale, riconoscimento di codice fragile e di hallucinations, test manuali e automatici minimi.
Leggi il diff, trovi fragilita, testi e correggi cio che e stato generato.
Per il metodo di debugging completo: corso Debugging.
- 41 Mappa rapida: file, moduli, dipendenze, punto d'ingresso
- 42 Flusso dei dati: input, trasformazioni, output
- 43 Riconoscere codice fragile: duplicazioni, accoppiamenti, magic numbers
- 44 Dipendenze inutili, librerie inventate, API che non esistono
- 45 Domande da fare all'AI sul proprio output: spiega, motiva, semplifica
- 46 Review del diff: leggere modifiche riga per riga
- 47 Quando rifiutare il codice e ripartire dal prompt
- 48 Casi normali, casi limite, input ostili
- 49 Debug guidato dall'AI: descrivere il sintomo, non la causa
- 50 Test manuali strutturati: checklist riproducibili
- 51 DevTools, log e network: verificare ciò che l'AI dichiara
- 52 Test automatici minimi: unit, integration, smoke
- 53 Errori comuni del codice generato e come accorgersene presto
- 54 Loop debug, fix, regression: evitare di rompere ciò che funzionava
Hardening completo (segreti, privacy, OWASP, pre-deploy) e capstone che attraversa l'intero ciclo del corso.
Porti un prototipo verso sicurezza, privacy, deploy e retrospettiva finale.
- 55 Segreti: API key, token, env, cosa non finisce mai in repo
- 56 Dati personali e GDPR per il vibe coder
- 57 Permessi, ruoli, validazione input lato server
- 58 Database in produzione: backup, migration, accessi
- 59 OWASP top hits per app generate: injection, XSS, auth rotta
- 60 Pre-deploy checklist: cosa controllare prima di pubblicare
- 61 Cosa fare se qualcosa va storto in produzione
- 62 Capstone — scelta del problema e definizione delle specifiche
- 63 Capstone — architettura su carta e file di contesto del progetto
- 64 Capstone — generazione iterativa con commit piccoli
- 65 Capstone — lettura, test, debug del proprio prototipo
- 66 Capstone — hardening: sicurezza, privacy, deploy
- 67 Capstone — retrospettiva: cosa ha funzionato, dove l'AI ha sbagliato, cosa rifare diversamente
per chi e fatto
Pensato per chi vuole prototipare senza perdere comprensione.
Non serve conoscere gia un linguaggio specifico. Serve voler leggere, verificare e correggere cio che viene generato.
A chi parla
- principianti che vogliono usare l'AI senza saltare le basi del ragionamento
- studenti di programmazione che vogliono integrare strumenti AI nel proprio metodo
- creator, founder e professionisti che vogliono prototipare idee software
- sviluppatori che vogliono rendere più ordinato il proprio workflow con AI
Prerequisiti
- familiarità minima con computer, file, cartelle e browser
- curiosità verso il codice
- disponibilità a ragionare prima di generare
cosa non e
Non e una scorciatoia per smettere di capire.
- Non è un corso su JavaScript, Python, Swift o un framework specifico.
- Non è una raccolta di prompt magici.
- Non è una scorciatoia per pubblicare applicazioni senza capirle.
- Non è un invito ad accettare codice generato senza leggerlo.
risultato atteso
Competenze verificabili a fine percorso.
- distinguere vibe coding, no-code, low-code e programmazione assistita dall'AI
- trasformare un'idea vaga in una specifica utilizzabile
- scrivere prompt orientati a obiettivi, vincoli e risultati verificabili
- dividere un progetto in parti: interfaccia, dati, logica, stato, API, autenticazione
- chiedere all'AI prima un piano e solo dopo il codice
- leggere il codice generato a livello strutturale
- riconoscere errori, fragilità e dipendenze inutili
- usare cicli di test, debug e revisione
- evitare i rischi più comuni su privacy, sicurezza e pubblicazione
- preparare il passaggio verso corsi specifici su linguaggi reali