Le nuove dinamiche della programmazione con l'IA

Il 19 ottobre è stato lanciato MiniMax M3.1 Flash, il 17 ottobre è arrivato l’aggiornamento DeepSeek‑V4.1‑Flash‑1017, e pochi giorni prima Meta ha rilasciato Muse Spark Open. OpenAI ha potenziato la capacità agente parallelo di GPT‑6 Pro, mentre Google ha presentato Gemini 4 Argon per compiti complessi. L’iterazione dei modelli avviene a velocità sempre più elevate e gli strumenti di programmazione IA stanno trasformando radicalmente il lavoro degli sviluppatori.

Oggi è possibile generare codice, creare siti web e sviluppare giochi con poche conversazioni. Tuttavia, la rapidità nella scrittura del codice non implica necessariamente che la realizzazione del software sia più semplice.

Nel podcast Beyond Coding, il conduttore Patrick Akil ha chiesto a Carlos Kelkboom quale fosse la più evidente evoluzione della software engineering rispetto a qualche anno fa. Kelkboom ha risposto: «Ho notato un fenomeno che non mi piace: la collaborazione tra sviluppatori diminuisce. Lavori con il tuo agente personale, ma non più con il team».

Le trasformazioni indotte dall’IA superano la mera generazione di codice. Controllare la qualità, orchestrare più agenti per lavori cooperativi e mantenere il giudizio ingegneristico con maggiore efficienza sono ora le sfide principali.

Le cinque regole operative di Kelkboom

Kelkboom ha sintetizzato la sua esperienza in cinque principi pratici:

    • Costruisci manualmente lo scheletro del progetto: definisci in anticipo directory, file chiave e firme delle funzioni.
    • Vieta le modifiche dirette del principale agente: solo dopo aver compreso pienamente i requisiti, avvia un agente di esecuzione.
    • Se non capisci il codice, scartalo subito: i risultati vengono isolati in un albero di lavoro; ogni discrepanza con la struttura attesa porta al rifiuto e alla ricomposizione.
    • Assegna compiti ampi agli agenti: evita modifiche ripetute che generano patch continui.
    • Usa più agenti in parallelo: ad esempio tre agenti sviluppano soluzioni diverse, mentre un quarto le confronta e integra le parti migliori.

Il problema della conclusione dei progetti

L’abbassamento della collaborazione porta a un problema più diretto: l’IA facilita l’avvio di un progetto, ma non ne assicura il completamento. Kelkboom ha avviato cinque progetti di compilatori; solo uno è stato realmente terminato.

Questo fenomeno non è nuovo, ma l’accessibilità degli strumenti IA amplifica la tendenza a rimanere nella fase di “tentativi”. Il conduttore del podcast ha confermato di avviare molti progetti che poi non porta a termine.

Kelkboom paragona la situazione a un maratona versus uno sprint: “Fare qualcosa rapidamente e non completarlo è diverso dal creare qualcosa destinato a durare”. Quando si lavora in solitaria, è più facile trascurare gli step finali.

Esempio della game development

Nel game development, molti creatori cercano di produrre giochi “velocemente”. Kelkboom sottolinea che il vero ostacolo è considerare il feedback degli utenti e progettare un gameplay solido. Gli agenti IA permettono iterazioni rapide, ma è indispensabile mantenere un dialogo continuo con il mondo esterno.

Il risultato è spesso una dipendenza dal “dopamine hit” di vedere subito un prototipo funzionante, a scapito del lavoro di rifinitura ingegneristica.

Scaffolding: preparare il terreno prima dell’IA

Per contrastare la tendenza a progetti incompleti, Kelkboom dedica 20 minuti‑un’ora alla fase di scaffolding prima di coinvolgere gli agenti. Crea manualmente directory, file, specifiche linguistiche e esempi di codice, definendo anche le relazioni tra i moduli.

Ad esempio, per scrivere un compilatore, imposta la struttura delle cartelle, redige il lexer, descrive la rappresentazione intermedia (AST) e inserisce numerosi esempi nella lingua target. Solo allora l’agente genera il compilatore, aderendo a un modello già definito.

Il motivo è che gli agenti eccellono nella risoluzione di problemi grezzi, ma spesso dimenticano come integrare la soluzione nell’intera applicazione.

Kelkboom ha provato a far costruire un’intera applicazione dall’agente fin dall’inizio. Dopo uno o due mesi, il codice era difficile da comprendere, gli script di deployment originari erano stati sostituiti da altri script, e lo scopo di molti nuovi file era ormai sconosciuto.

Strategie di apprendimento da progetti open‑source

Quando si affronta un dominio sconosciuto, Kelkboom suggerisce di:

    • Identificare progetti open‑source maturos.
    • Far analizzare all’agente i pattern di design presenti.
    • Comprendere tali pattern prima di costruire lo scaffolding.
    • Avviare una piccola proof‑of‑concept e verificare il design con l’agente.

Questa procedura garantisce che l’agente lavori su una base ben compresa, riducendo il rischio di deviazioni architetturali.

Lavorare con agenti: compiti ampi e parallelismo

Kelkboom osserva che gli agenti sono più efficienti quando ricevono compiti completi piuttosto che incrementali. Il loro addestramento sembra ottimizzato per risolvere task una tantum anziché per sviluppare iterativamente su una codebase esistente.

Di conseguenza, stabilire un framework solido fin dall’inizio permette agli agenti di operare entro limiti chiari, massimizzando la produttività.

Naturalmente, non tutti i progetti richiedono una preparazione estesa. Per verificare rapidamente un’idea, è possibile sperimentare in maniera veloce; se l’idea fallisce, si ricomincia da capo.

Esplorazione parallela in pratica

Una tecnica efficace consiste nel creare tre rami di lavoro separati, assegnando a tre agenti lo sviluppo indipendente di ciascuno. Un quarto agente analizza i risultati, confronta le soluzioni e integra le parti migliori in un’unica build finale.

Questo approccio riduce il tempo di valutazione e favorisce l’emergere di soluzioni innovative, limitando al contempo i bias individuali di un singolo agente.

Conclusioni: l’IA come inizio, non fine, del ciclo di sviluppo

L’adozione di agenti intelligenti sta trasformando il modo in cui i progetti software vengono avviati. Tuttavia, come sottolinea Kelkboom, la vera sfida è portare questi progetti a termine, mantenendo coerenza architetturale e qualità del codice.

Seguire le cinque regole – scaffolding manuale, controllo delle modifiche, eliminazione del codice incomprensibile, assegnazione di compiti ampi e utilizzo di più agenti in parallelo – fornisce un quadro pratico per bilanciare l’efficienza dell’IA con il rigore ingegneristico.

In definitiva, l’IA è solo il punto di partenza di una maratona di sviluppo; la disciplina, la pianificazione e la collaborazione rimangono gli ingredienti chiave per trasformare le idee in prodotti solidi e duraturi.