Sviluppo di App assistito da AI

L'intelligenza artificiale generativa sta trasformando il modo in cui scriviamo codice. Ma usarla bene non significa delegare tutto a un modello: significa imparare a guidarla con metodo, tracciabilità e verifica continua.

1. Introduzione

Questo articolo affronta lo sviluppo di una applicazione completa in .NET MAUI con il supporto di strumenti di Intelligenza Artificiale generativa e agentica. L'obiettivo non consiste nel delegare la realizzazione del progetto a un sistema automatico, ma nell'imparare a guidare l'AI in modo controllato, tracciabile e verificabile.

L'approccio adottato è di tipo spec-driven. Ciò significa che ogni iterazione di lavoro parte da specifiche esplicite, passa attraverso un piano operativo e produce modifiche limitate, controllate e testate.

Presupposti

Il percorso si inserisce dopo un corso introduttivo che ha già affrontato i fondamenti di .NET MAUI, l'uso di XAML, i layout, le risorse condivise, la navigazione con Shell, la persistenza locale, il data binding, i temi, i permessi e l'analisi di sample ufficiali Microsoft. Il nuovo approccio estende quindi un impianto già esistente e non sostituisce i fondamenti acquisiti.

Obiettivi

Al termine del percorso lo sviluppatore dovrebbe essere in grado di:

• definire specifiche realistiche per un progetto software
• pianificare il lavoro in iterazioni brevi e verificabili
• usare l'AI per generare e rivedere codice senza rinunciare al controllo umano
• integrare API esterne, persistenza locale e navigazione in una applicazione MAUI completa
• documentare il percorso di sviluppo in modo strutturato
• preparare una versione finale installabile e dimostrabile

2. AI come supporto, non come sostituto

Uno strumento AI può produrre codice plausibile in pochi secondi, ma non garantisce automaticamente correttezza, coerenza architetturale, sicurezza, qualità della UX o affidabilità del risultato finale. Per questo motivo il ruolo umano rimane centrale in tutte le fasi: definizione del problema, controllo delle scelte, review del codice, validazione dei test e presentazione del progetto.

L'uso corretto dell'AI si basa su quattro principi:

• contesto chiaro: fornire sempre all'AI informazioni sufficienti sul progetto, sull'architettura e sui vincoli
• richieste precise: evitare prompt generici e preferire richieste specifiche, limitate a una singola feature o classe
• iterazioni brevi: non chiedere mai "tutta l'app", ma procedere per piccoli passi verificabili
• verifica continua: ogni output dell'AI deve essere letto, compreso, testato e, se necessario, corretto

Vibe Coding vs Sviluppo Spec-Driven

L'approccio più diffuso e più rischioso adottato da chi inizia a programmare con l'AI è il cosiddetto Vibe Coding. Questo metodo si caratterizza per una serie di comportamenti problematici:

• prompt vaghi e discorsivi, del tipo "fammi un'app meteo completa"
• accettazione passiva di blocchi di codice molto grandi senza lettura critica
• assenza di pianificazione architetturale
• impossibilità di spiegare il funzionamento del codice prodotto
• accumulo rapido di debito tecnico, codice duplicato e dipendenze inutili

Il risultato è spesso una "scatola nera" apparentemente funzionante, in cui lo sviluppatore perde rapidamente la comprensione del flusso logico dell'applicazione. Quando qualcosa si rompe, o quando viene chiesto di modificare una feature, lo sviluppatore non sa dove intervenire.

Per ovviare a queste criticità, si introduce il paradigma dello Sviluppo Spec-Driven. Questo approccio richiede che la generazione del codice sia sempre guidata da specifiche tecniche rigorose prodotte preventivamente dallo sviluppatore.

Nell'approccio spec-driven si applicano le seguenti regole fondamentali:

1. La specifica è il punto di origine: prima di scrivere codice, si redige una documentazione che descrive requisiti, input/output attesi e criteri di accettazione.
2. L'AI è esecutrice, non architetto: il design del software, la scelta del pattern architetturale e l'organizzazione delle dipendenze rimangono responsabilità umana.
3. Micro-iterazioni: la generazione del codice avviene in segmenti modulari, focalizzati su una singola classe o metodo per volta.
4. La Code Review è sistematica: nessuna riga di codice viene integrata nel progetto senza prima essere stata compresa, analizzata e testata.

Vantaggi dello sviluppo spec-driven

Questo approccio offre diversi vantaggi concreti:

• riduce il rischio di modifiche casuali o incoerenti
• facilita la revisione del lavoro
• consente di documentare il processo in modo naturale
• rende più facile il testing
• aiuta a mantenere il controllo del progetto anche quando l'AI produce molto codice
• prepara lo sviluppatore a pratiche professionali reali

Rischi dello sviluppo non guidato

Lo sviluppo non guidato da specifiche può portare rapidamente a:

• file generati senza struttura logica
• dipendenze NuGet inutili o incompatibili
• naming incoerente tra classi, metodi e proprietà
• logica applicativa dispersa tra View e code-behind invece che nei ViewModel
• regressioni difficili da spiegare dopo ogni modifica
• impossibilità di motivare le scelte tecniche

3. Il modello operativo: Man-in-the-Loop

Il modello di lavoro adottato è di tipo Man-in-the-Loop ("l'uomo nel ciclo di controllo"). In questo schema l'AI non opera da sola, ma interviene dentro una pipeline controllata in cui l'essere umano agisce come decisore, validatore e regista dell'intero processo.

Il ciclo a cinque fasi

Ogni iterazione di lavoro segue un ciclo strutturato:

1. Planning — Definire l'obiettivo verificabile, identificare i file da modificare, creare un branch Git dedicato. Un buon obiettivo è specifico: "Implementare BookDetailViewModel con proprietà Title, Author, Description e un ICommand che chiami IBookService.GetBookByIdAsync", non "Crea la pagina del dettaglio del libro".

2. Build — L'AI genera il codice partendo da un prompt strutturato che include contesto, obiettivo, vincoli e formato atteso. Ogni prompt riguarda al massimo una feature, e se il codice tocca troppi file è meglio dividere la richiesta.

3. Review — Il codice generato viene letto interamente e confrontato con la specifica. Si verificano: architettura MVVM, coerenza del naming, assenza di dipendenze non richieste, gestione errori, leggibilità.

4. Testing — La feature viene verificata con casi normali e casi limite (input vuoti, errori HTTP, timeout, JSON malformato, stato loading, tema scuro). Una feature è completata solo dopo verifica concreta su dispositivo o emulatore.

5. Documentazione e Git — Si aggiornano i log di iterazione, la specifica, il prompt log e la matrice di test. Si esegue il merge del branch nel ramo principale e il push sul repository remoto.

Questo ciclo garantisce che ogni modifica sia tracciabile, verificabile e reversibile, trasformando l'AI da "scatola nera" a strumento di produttività sotto il pieno controllo dello sviluppatore.

Articolo tratto da: Guida allo sviluppo di App assistito da AI — malafronte.dev