Luca Morelli
Software engineer e analista
Team lead

Coding agent in un gruppo di sviluppo: verificare, misurare, formare.

I coding agent fanno produrre più codice. Per chi guida un gruppo di sviluppo la domanda diventa un'altra: il team riesce a capirlo, verificarlo e mantenerlo? Il vantaggio va misurato sul software utile e mantenibile che arriva in produzione.

Cosa posso fare, e cosa non ho ancora fatto

Formare e seguire i profili junior fa parte da sempre del mio lavoro di senior e team lead.

Posso fare lo stesso con i coding agent: formare i singoli sviluppatori a usarli con metodo, ciascuno sul proprio lavoro (specifiche scritte, una harness personale, verifiche), e seguirli durante il progetto. È il modo in cui li uso io, descritto in Coding agent.

Far lavorare un intero team su un'unica harness condivisa è un passo diverso e molto più complesso, che non ho ancora affrontato in un progetto. Le sezioni che seguono raccolgono i criteri che considero necessari in un gruppo: sono proposte di metodo, non il racconto di un'adozione già guidata.

Perché una harness condivisa è difficile

Non l'ho ancora fatto in un progetto. Questi sono i problemi che vedo.

  • Chi la modifica. Se tutti possono cambiarla, si degrada e perde precisione: servono un responsabile e una revisione, come per il codice.
  • Come cresce. Le informazioni aumentano e l'agente deve continuare a trovare quelle giuste: va mantenuta e ottimizzata nel tempo.
  • Cosa contiene. Oltre a una struttura di base, ogni progetto ha esigenze proprie: non esiste un modello pronto da copiare.
  • Senior e junior. Per come la vedo, i senior dovrebbero costruire nella harness i flussi, la documentazione di dominio e i controlli che permettono di assegnare i compiti e validare il lavoro; i junior riceverebbero i compiti e ci lavorerebbero finché la revisione non dà il via libera alla pull request. In teoria funziona così; in pratica mi sembra complesso. E l'agente, da solo, non fa crescere un junior: formarlo e seguirlo durante il progetto resta compito dei senior.
  • Quanto costa. È lavoro in più, da mettere nel conto dell'adozione.

Review delle pull request con l'IA e crescita dei junior

La verifica può diventare il collo di bottiglia

Se l'agente modifica più codice di quanto il team riesca a comprendere e verificare, la velocità iniziale può diventare lavoro di revisione e manutenzione. È il rischio che considero centrale.

La mia proposta è separare la produzione dalla validazione: criteri di accettazione e risultati di riferimento devono essere controllati anche fuori dal processo che ha generato la modifica. Un secondo agente può aiutare, ma può condividere gli stessi errori del primo.

  • Test di comportamento, integrazione, contratti e regressione proporzionati al rischio.
  • Analisi statica, controlli di sicurezza e verifiche delle dipendenze.
  • Revisioni con criteri espliciti e confronto con requisiti e vincoli del dominio.
  • Modifiche abbastanza piccole da rendere visibili errori e conseguenze.

Non ogni riga richiede lo stesso controllo umano. Serve però una persona responsabile della decisione, con verifiche più forti dove un errore ha conseguenze maggiori.

Strumenti e responsabilità in un team

Da libero professionista la valutazione è diretta: mi do un budget e verifico se il risultato giustifica la spesa; dove serve, l'uso lo approva il cliente. In un'azienda la resa cambia da persona a persona, e senza strumenti per misurarla approvare l'uso dei coding agent diventa difficile.

Non valutarli, però, ha un costo. Nella mia esperienza piccoli team e studi professionali hanno spesso, in ambiti specifici, una capacità tecnica superiore a quella di team assemblati da aziende più grandi, ed è anche per questo che a volte ricevono lavori delegati. Con i coding agent, forse non subito, un piccolo team con competenze e metodo può proporre a un cliente una soluzione migliore e meno costosa. Se poi mantiene le promesse, compresa la continuità del servizio, chi perde l'incarico perde anche in immagine. È uno scenario da valutare, non una previsione.

Per un team proporrei di scegliere strumenti e livelli di accesso in base alle attività, invece di assegnare automaticamente la stessa licenza a tutti. L'acquisto va accompagnato da formazione, pratiche condivise e responsabilità chiare per contesto e documentazione.

Un caso reso noto nell'ottobre 2026 va in questa direzione: secondo 404 Media, dal 1° ottobre Accenture paga per ogni dipendente 29 dollari al mese di Claude e chiede di addebitare la spesa in più al progetto o al gruppo di lavoro. Uno dei dipendenti, che usava Claude Code per sviluppare e provare software destinato a più clienti, spendeva di solito tra 500 e 1.000 dollari al mese. Con un coding agent usato in modo intensivo la spesa dipende dall'uso, non dalla licenza: per questo il costo va confrontato con il lavoro che produce, non con il listino.

Preparare il lavoro prima di assegnarlo riduce anche il consumo: con richieste precise l'agente esplora meno il codice.

Misurerei tempi di completamento e revisione, difetti e rilavorazioni insieme ai costi. Token, righe generate e numero di pull request non bastano a valutare il beneficio o il contributo di una persona: questa è una proposta metodologica, non una formula universale di ROI.

Misurare il lavoro che il team può mantenere

Il costo complessivo delle applicazioni IA

Valutare anche la scelta di aspettare

Preparare il lavoro: pull request più chiare e meno spesa

Formare i profili junior

I coding agent possono aumentare la produttività, a seconda del compito e del contesto. Non sostituiscono la comprensione del sistema, e lì la differenza resta.

Cambia anche il modo di formare i profili junior. Il rischio è una persona che non cresce e si limita a interrogare l'IA finché non ottiene qualcosa che funziona. Per questo chiedo ai junior che seguo di costruirsi una visione diretta del prodotto, e discuto sempre con loro gli elementi assegnati. È lo stesso principio con cui lavoro da team lead.

Mantenere la comprensione del sistema

Uso «debito di comprensione» per descrivere un rischio: il software continua a funzionare, ma sempre meno persone sanno perché è stato costruito così. È un concetto utile, non una metrica standard consolidata.

Decisioni documentate, discussione del dominio e verifiche con il team aiutano a mantenere questa conoscenza. Il ruolo dello sviluppatore comprende requisiti, architettura, contesto e giudizio sulle modifiche; delegare l'esecuzione richiede ancora queste competenze.

La harness deve rendere visibili gli errori

Una harness contiene contesto, regole, strumenti e procedure. Migliorarla può rendere l'agente più efficace; può anche propagare più rapidamente un'interpretazione sbagliata.

Per questo considero parte della harness anche i limiti alle azioni e le condizioni per fermarsi: test falliti, requisiti ambigui, differenze inattese o controlli mancanti. Conta la capacità di rilevare una modifica errata prima che entri nel prodotto.

Il mio metodo: specifiche e harness di progetto

Coding agent su applicazioni legacy

Un coding agent può lavorare con maggiore autonomia quando dispone di un ciclo di verifica: modifica il codice, esegue i controlli, legge gli errori e corregge. I test automatici sono una parte centrale di questo ciclo, insieme alla compilazione e alle altre verifiche pertinenti. Non occorre necessariamente adottare un processo TDD rigoroso; servono riscontri ripetibili sul comportamento richiesto.

In alcune applicazioni legacy, provare una modifica richiede l’avvio dell’intero sistema, un database con dati adatti, servizi esterni e configurazioni difficili da ricostruire. Se la logica è strettamente legata a queste dipendenze e mancano test automatici, predisporre un ciclo di verifica richiede lavoro aggiuntivo. Anche un’applicazione recente può avere gli stessi vincoli.

La presenza di un database non impedisce l’automazione: si possono predisporre ambienti di test e dati ripristinabili. Può però essere necessario documentare l’avvio, introdurre test che descrivano il comportamento esistente e separare gradualmente alcune dipendenze. Questo lavoro va incluso nella valutazione iniziale dell’adozione. Dove la verifica resta soprattutto manuale, considererei più limitata l’autonomia dell’agente e manterrei modifiche piccole con controlli umani espliciti.

Misurare il lavoro che il team può mantenere

Percentuale di codice generato, token, prompt o numero di pull request non bastano a misurare il beneficio. Confronto tempi di completamento e revisione, difetti, regressioni, rilavorazioni e capacità di evolvere il prodotto.

Il framework SPACE tratta la produttività come multidimensionale. In questo senso propongo di valutare insieme risultati, collaborazione e sostenibilità del lavoro, senza trasformare una singola misura in una graduatoria dei singoli sviluppatori.

L'obiettivo che sceglierei è produrre software corretto, utile e mantenibile a un costo sostenibile.

Cosa dicono gli studi

Produttività e qualità non hanno un rapporto automatico.

L'esperimento di Borg e colleghi, pubblicato nel 2026 con 151 partecipanti, non trova differenze significative nella successiva manutenibilità del codice sviluppato con assistenti IA. Le attività risalgono a fine 2024 e precedono i coding agent attuali.

Liu e colleghi analizzano invece circa 302.600 commit attribuiti all'IA in 6.299 repository. Individuano problemi con analisi statica, dei quali il 22,7% resta presente all'ultima revisione osservata. È evidenza di problemi persistenti nel campione, non una misura di tutti i difetti o del confronto con ogni sviluppatore umano.

GitClear osserva più duplicazione e meno refactoring nel periodo di diffusione dell'IA. Sono segnali da monitorare; da soli non dimostrano una causa unica.

Il rapporto DORA 2025, basato su quasi 5.000 risposte, osserva che all'uso dell'IA si associano più consegne ma anche rilasci meno stabili, e che il 30% dei partecipanti ha poca o nessuna fiducia nel codice generato. Per gli autori l'IA amplifica ciò che c'è già: rafforza i team solidi e mette in evidenza i problemi degli altri. È un'indagine sulle risposte dei partecipanti, non una misura diretta sul codice.

Leggere insieme questi lavori suggerisce di misurare gli effetti nel proprio processo.

Un caso: Shopify

Nel settembre 2026 Shopify descrive il passaggio da React Native a Swift e Kotlin: i coding agent hanno cambiato il costo di mantenere due implementazioni native. La Shop app è stata ricostruita e pubblicata in circa 12 settimane; la migrazione della Shopify app, con oltre 300 schermate, è descritta come in corso. Per la migrazione usa piccoli passi con test, confronto visivo e due revisioni indipendenti; l'approvazione di un ingegnere è l'impostazione normale. È un'esperienza aziendale specifica, non una stima trasferibile ad altre applicazioni.

Ne ricavo una proposta più generale: responsabilità chiare, contratti espliciti, test rapidi e osservabilità comprensibile rendono più facile lavorare sul sistema, sia alle persone sia agli agenti.

Fonti a supporto

Gli studi hanno metodi e ambiti diversi. Le proposte su validazione e ruolo dello sviluppatore sono criteri di lavoro ricavati da queste evidenze, non promesse di un risultato universale.

Ultimo aggiornamento dei contenuti:

Volete che i vostri sviluppatori imparino a usarli con metodo?

Curriculum dettagliato e referenze su richiesta.