Mappa delle competenze di ingegneria AI: utilizzare agenti di programmazione

Una competenza chiave nell'ingegneria AI è l'uso di agenti di codifica. La tua abilità nel guidarli sia per scrivere codice che per svolgere attività non legate al codice, come analizzare dati o gestire operazioni di sistema, ti permette di ottenere molto di più.

Il ritmo rapido dell'evoluzione degli agenti di codifica significa che anche questa competenza si sta evolvendo rapidamente — più velocemente di altre competenze di ingegneria AI di alto livello. Gli agenti proprietari (come Claude Code, Codex e Cursor) e quelli open source (come OpenCode e Pi) progrediscono a passi da gigante grazie sia ai miglioramenti dell'infrastruttura che dei modelli. Quindi, tenersi al passo con l'uso degli agenti di codifica richiede un processo continuo di sperimentazione, costruzione e apprendimento.

Intervistando dozzine di ingegneri AI di alto livello e riflettendo sull'uso degli agenti di codifica da parte del nostro team, abbiamo trovato un flusso di lavoro di alto livello coerente per sviluppare software con essi. I passaggi chiave sono:

• Pianificazione. Questo include (i) brainstorming, che può comprendere ricerca, sperimentazione e comprensione del codebase esistente (se presente) e (ii) scrittura di un documento di specifica che catturi requisiti, progettazione tecnica e architettura, seguito dalla generazione di un piano di esecuzione. Potresti anche rivedere il piano per mettere in discussione le ipotesi chiave e verificare la presenza di problemi di sicurezza, overengineering e altre lacune.
• Esecuzione, in cui costruisci, testi e verifichi, con il giusto equilibrio tra autonomia dell'agente e supervisione umana. Questo comporta (i) far costruire il software all'agente, con un livello calibrato di autonomia e (ii) verificare il suo output tramite controlli automatizzati e/o umani.
• Distribuzione e monitoraggio, in cui (i) distribuisci, magari con un gate tramite pipeline CI/CD o ulteriori gate umani, e (ii) usi gli agenti per monitorare i log, segnalare problemi e proporre ed eseguire miglioramenti.

Questo flusso di lavoro di alto livello è simile a quello tipicamente utilizzato per sviluppare software prima degli agenti di codifica. Ora, ci concentriamo molto meno sul codice e invece ci concentriamo sul decidere cosa costruire, progettare l'architettura, scrivere le specifiche e verificare gli output.

La durata di ogni passaggio può variare significativamente tra i progetti e alcuni passaggi possono essere omessi. Ad esempio, le specifiche per un prototipo greenfield (cioè costruito da zero) potrebbero essere descritte approssimativamente in un prompt scritto rapidamente, mentre le specifiche per un progetto brownfield (preesistente) con molti utenti potrebbero richiedere molto più impegno per essere scritte e verificate. Inoltre, il flusso di lavoro è altamente iterativo e gli sviluppatori esperti sanno quando il feedback di un passaggio successivo dovrebbe riportarli a uno precedente. Ad esempio, se la verifica fallisce, sanno come guidare l'agente per ricostruire e correggere gli errori; o se il monitoraggio evidenzia problemi, sanno come far aggiornare il sistema agli agenti e ridistribuirlo.

Per utilizzare efficacemente gli agenti di codifica in questo flusso di lavoro, le competenze chiave sono:

• Dirigere il flusso di lavoro
• Abilitare l'autonomia dell'agente
• Revisionare il lavoro
• Personalizzare l'agente e il suo ambiente
• Fondamenti degli agenti di codifica

Dirigere il flusso di lavoro. Sai come navigare ogni passaggio del flusso di lavoro sopra descritto. Questo implica decidere quanto sforzo umano e quanto sforzo dell'agente dedicare a ciascuno e quando tornare a un passaggio precedente per iterare. Richiede una profonda comprensione dei compromessi tra velocità, costo, rischio tecnico e sforzo umano, in modo da poter decidere quanto ricercare e pianificare in anticipo, quando mantenere la proprietà umana su lavori critici, come scegliere l'architettura, quanto dettaglio scrivere in una serie di artefatti di pianificazione (come un documento di specifica) e come scomporre il lavoro in passaggi verificabili.

Abilitare l'autonomia dell'agente. Quando applichi un agente di codifica ai passaggi del flusso di lavoro, scegli il livello di autonomia: lo osservi e procedi avanti e indietro in modo interattivo o gli deleghi un blocco di lavoro più grande? E quando imposti un obiettivo chiaro e lo fai iterare fino al successo? Inoltre, devi gestire attentamente il contesto per l'agente. Mentre la costruzione procede attraverso fasi diverse, calibrerai quando assicurarti che gli apprendimenti chiave, il feedback degli utenti e le ipotesi — incluse quelle cambiate durante la costruzione — siano catturati per essere utilizzati dall'agente in seguito. Inoltre, deciderai quando impostare molti agenti per eseguire in parallelo una scomposizione del compito — sia facendo orchestrare questi altri agenti da un umano o da un agente di livello superiore — e come gestire l'attenzione umana tra sessioni di agenti concorrenti. Sai anche come eseguire gli agenti in modo sicuro, impostando permessi e bloccando le azioni in modo appropriato per permettere uno sviluppo rapido limitando il rischio di fughe di dati, perdita di dati o altri danni.

Revisionare il lavoro. L'output di un agente di codifica è incerto. Non sappiamo in anticipo quali buone idee potrebbe avere e quali bug implementerà. Revisionare e verificare l'output è un passaggio chiave per assicurarti di ottenere il risultato desiderato e per reindirizzare l'agente in caso contrario. Progetterai test e validazioni adatti al compito, applicando sia la verifica comportamentale che funzionale secondo necessità. Potresti anche testare i flussi utente, magari facendo fornire all'agente screenshot come prova del successo o del fallimento. Per la valutazione qualitativa/comportamentale, si possono utilizzare set di valutazione, magari con un LLM come giudice.

Devi anche decidere quanto di questi test debba essere automatizzato. Alcuni flussi di lavoro avranno tutti i test e le validazioni completamente automatizzati in modo che l'agente possa controllare il suo lavoro e sapere quando ha completato con successo un compito. Devi valutare i test per assicurarti che corrispondano ai tuoi obiettivi e li farai evolvere in caso contrario. Inoltre, utilizzi la revisione del codice agentica ed esegui audit di sicurezza e architettura abilitati dall'AI. Quando la revisione AI non è sufficiente, inserisci giudiziosamente revisioni umane del comportamento del codice (e, raramente, anche del codice) mentre esplori come automatizzare ulteriormente questa revisione. Infine, verifichi la distribuzione e puoi rendere operativi il monitoraggio e la gestione degli incidenti con gli agenti.

Personalizzare l'agente e il suo ambiente. La tua capacità di aggiornare sia l'agente che l'ambiente in cui lavora permette ai tuoi agenti di ottenere efficientemente il contesto di cui hanno bisogno, accedere agli strumenti e costruire correttamente ed efficientemente. Sai come integrare competenze, plugin e server MCP dell'agente. Occasionalmente li poti quando non sono più necessari (ad esempio, quando un nuovo modello rende superflua una vecchia competenza). Puoi usare gli hook per automatizzare parti ripetibili del processo di sviluppo, come attivare revisioni automatiche del codice o pipeline CI/CD. Puoi anche mantenere l'ambiente in cui l'agente lavora: aggiornare il contesto permanente (come AGENTS.md o CLAUDE.md) con informazioni sul codebase, ipotesi architetturali chiave, stile del codice e pattern di accesso ai dati. Sai come preservare lo stato attraverso più sessioni e attraverso agenti paralleli, e accumulare gli apprendimenti dell'agente nel tempo, magari eseguendo retrospettive post-esecuzione per catturare cosa ha funzionato e cosa no. Sai anche come impostare convenzioni e strutture coerenti per rendere il tuo codebase navigabile per l'agente e come eliminare occasionalmente il debito generato dall'agente. Quando lavori in un team, consideri come coordinare il contesto tra gli agenti dei diversi sviluppatori.

Fondamenti degli agenti di codifica. Infine, per prendere buone decisioni durante tutto il processo, hai una buona comprensione di come funzionano gli agenti di codifica: come effettuano la ricerca/recupero nel codebase, come gestiscono le loro finestre di contesto, come diverse operazioni (come l'aggiunta di chiamate a strumenti, server MCP, ecc.) influenzano il contesto, come interagiscono agenti e sottoagenti, e come l'agente è costruito avvolgendo un'infrastruttura attorno a un LLM. Questo rende l'agente meno una scatola nera e ti aiuta a riconoscere le modalità di fallimento, come l'overengineering di una soluzione semplice, la perdita di rigore perché all'agente manca un processo di verifica esplicito, l'arrestarsi prima dell'obiettivo, o azioni dell'agente che rischiano la distruzione di file o dati di produzione. Ti aiuta anche a ragionare sullo stato dell'agente e a guidarlo dandogli la giusta prescrizione o contesto. E quando monitori un'esecuzione, questa comprensione ti permette di individuare meglio quando l'agente va fuori strada e richiede il tuo intervento.

Trovo che i social media spesso diano descrizioni eccessivamente semplificate su come usare gli agenti di codifica. Ad esempio, a volte è utile far eseguire gli agenti in modo autonomo per ore e bruciare milioni o decine di milioni di token. Ma attualmente l'utilità pratica dei compiti a lunghissimo orizzonte — specialmente in relazione al loro costo — è stata amplificata oltre la realtà. Invece, l'uso più efficace degli agenti di codifica è un processo complesso e altamente iterativo, e essere in grado di intervenire con un giudizio di alto livello dà risultati molto migliori.

La tua abilità nell'usare gli agenti di codifica ti renderà un costruttore efficace. Questo ti posiziona anche per guidare la costruzione complessiva. Dirò di più su questo in un articolo futuro.