L’AI scrive il codice, ma chi è responsabile quando qualcosa va storto?

Per decenni, la responsabilità nello sviluppo software è stata relativamente chiara.

Lo sviluppatore scrive il codice. Il team lo revisiona. I test verificano che funzioni. L’organizzazione decide se il software è pronto per essere distribuito in produzione.

Ma l’AI sta cambiando uno degli anelli più fondamentali di questo processo.

Oggi, un agente di coding non si limita più a suggerire poche righe di codice.

Può analizzare un repository, identificare un problema, modificare più file, sviluppare una funzionalità, eseguire test e proporre un’implementazione quasi completa.

Secondo il rapporto The 2026 State of AI Agents di Anthropic, più di 9 organizzazioni intervistate su 10 utilizzano l’AI come supporto alla programmazione. L’86% utilizza agenti di coding per codice destinato alla produzione, mentre il 42% si affida a questi agenti per guidare il lavoro di sviluppo, con gli esseri umani che continuano a revisionare il codice e a definire la strategia.

Questo solleva una domanda che l’industria del software dovrà affrontare sempre più spesso:

Se l’AI scrive la maggior parte del codice, chi è responsabile quando quel codice presenta problemi?

Da “L’AI mi ha aiutato” a “L’AI lo ha implementato”

Nelle prime fasi della programmazione assistita dall’AI, la divisione delle responsabilità era più semplice.

Lo sviluppatore scriveva il codice, mentre l’AI suggeriva una funzione, completava alcune righe o spiegava un errore.

Il processo decisionale e l’implementazione rimanevano principalmente nelle mani dell’essere umano.

Gli agenti di coding stanno cambiando questo rapporto.

Uno sviluppatore può assegnare a un agente un obiettivo di alto livello e consentirgli di determinare autonomamente una parte dell’approccio all’implementazione.

Lo studio di Anthropic su circa 400.000 sessioni di Claude Code mostra precisamente questa divisione: gli esseri umani tendono a prendere più decisioni su ciò che deve essere fatto, mentre l’AI prende più decisioni su come farlo.

In questo modello, lo sviluppatore non è necessariamente l’autore di ogni riga di codice.

Ma rimane parte del processo che determina se quel codice debba essere accettato.

L’autore del codice e chi ne è responsabile non sono necessariamente la stessa persona

È necessario fare una distinzione importante.

Chi ha generato il codice?

e

Chi è responsabile della sua distribuzione in produzione?

sono due domande diverse.

Un agente di coding può generare l’implementazione.

Ma è l’organizzazione a decidere quali strumenti di AI utilizzare, a quali risorse possono accedere, quali standard deve rispettare il codice e in quale momento è necessaria l’approvazione umana.

Pertanto, l’utilizzo dell’AI non dovrebbe creare un vuoto di responsabilità.

Al contrario, richiede che le responsabilità siano definite in modo ancora più chiaro.

“L’ha scritto l’AI” non può diventare un meccanismo per trasferire la responsabilità

Immaginiamo che un agente di coding crei una nuova funzionalità.

I test vengono superati.

Il codice sembra pulito.

Lo sviluppatore lo approva e la modifica viene distribuita in produzione.

Successivamente viene scoperto un problema serio.

In un modello tradizionale, il team può analizzare le decisioni tecniche che hanno portato all’errore e il processo di code review che non è riuscito a identificarlo.

In un flusso di lavoro guidato dall’AI, potrebbe emergere una nuova risposta:

“Quella parte l’ha scritta l’AI.”

Ma questo non risolve il problema.

Se un’organizzazione ha scelto di utilizzare l’AI per implementare software, deve anche costruire i processi necessari per verificarne i risultati.

L’AI può cambiare il modo in cui viene prodotto il codice.

Non dovrebbe eliminare la responsabilità relativa al modo in cui quel codice viene verificato e utilizzato.

Human-in-the-Loop sta assumendo un nuovo significato

Secondo il rapporto di Anthropic, il 42% delle organizzazioni afferma di fidarsi degli agenti di coding per guidare lo sviluppo, mentre gli esseri umani rimangono coinvolti nella revisione del codice e nella definizione della strategia.

Questa espressione — human-in-the-loop — sta diventando sempre più importante.

Ma il semplice coinvolgimento di una persona nel processo non è sufficiente.

Se l’AI genera migliaia di righe di codice e uno sviluppatore si limita a fare clic su “Approva”, tecnicamente esiste una supervisione umana, ma nella pratica potrebbe non essere realmente significativa.

Pertanto, la domanda non dovrebbe essere soltanto:

“È stato approvato da una persona?”

Dovrebbe essere:

“Quella persona disponeva delle informazioni, del tempo e delle competenze necessarie per valutare correttamente la modifica?”

Più codice produce l’AI, più diventa difficile revisionare tutto

L’AI crea un nuovo paradosso per i team di sviluppo software.

Gli agenti di coding possono aumentare significativamente la velocità con cui viene prodotto il codice.

Ma la velocità della revisione umana del codice non aumenta automaticamente allo stesso ritmo.

Se un team in precedenza produceva dieci modifiche al giorno e ora, grazie all’AI, riesce a produrne molte di più, revisionare manualmente ogni modifica con lo stesso livello di approfondimento diventa sempre più difficile.

Anthropic prevede esattamente questo tipo di trasformazione: la supervisione umana potrebbe gradualmente passare dalla revisione di ogni singolo risultato alla concentrazione sui casi in cui il giudizio umano è realmente necessario.

Ciò significa che il sistema stesso deve diventare più efficace nell’identificare i rischi.

L’AI può revisionare l’AI, ma la responsabilità non scompare

Una soluzione emergente consiste nell’utilizzare l’AI per revisionare i risultati prodotti da altri sistemi di AI.

Un agente può scrivere il codice.

Un altro può revisionarlo.

Un sistema di sicurezza può cercare vulnerabilità.

I test automatizzati possono verificarne il comportamento.

Un altro meccanismo può segnalare soltanto le modifiche ad alto rischio affinché uno sviluppatore possa esaminarle.

Questo può rendere la supervisione molto più scalabile.

Ma crea anche un’altra domanda:

Se l’AI scrive il codice e un’altra AI lo approva, chi controlla il sistema di revisione?

In definitiva, deve esistere un livello in cui la responsabilità appartiene all’organizzazione e alle persone che definiscono le regole che governano il sistema.

La responsabilità si sta spostando dalla singola riga di codice al sistema di sviluppo

Questo potrebbe essere uno dei cambiamenti più importanti che l’AI porta nell’ingegneria del software.

Nel modello tradizionale, lo sviluppatore era molto vicino a ogni riga di codice che produceva.

In un modello costruito intorno agli agenti di coding, lo sviluppatore può essere più distante dall’implementazione diretta.

La sua responsabilità si sposta verso la progettazione del processo:

Che cosa può essere delegato all’AI?

Che cosa dovrebbe essere verificato automaticamente?

Quali modifiche richiedono una code review umana?

Quando dovrebbe fermarsi l’agente e chiedere aiuto?

Quali test devono essere superati prima che una modifica venga accettata?

Quali parti del sistema sono considerate troppo critiche per essere delegate completamente a un agente?

Queste stanno diventando questioni di architettura software e governance dell’ingegneria.

Le competenze umane non stanno diventando meno importanti

Potrebbe sembrare che, man mano che l’AI migliora nella scrittura del codice, gli sviluppatori abbiano bisogno di meno competenze tecniche.

I dati di Anthropic suggeriscono un quadro più complesso.

Nella sua analisi di circa 400.000 sessioni di Claude Code, gli utenti con maggiore esperienza nel dominio specifico avevano maggiori probabilità di completare con successo le attività.

Questo è comprensibile.

Per revisionare un’implementazione, è necessario capire come dovrebbe comportarsi il sistema.

Per identificare una decisione architetturale sbagliata, è necessario comprendere l’architettura.

E per sapere quando non fidarsi di un risultato generato dall’AI, è necessaria la competenza tecnica per metterlo in discussione.

L’AI potrebbe quindi ridurre la quantità di codice che uno sviluppatore scrive manualmente, aumentando allo stesso tempo l’importanza del giudizio tecnico.

La tracciabilità diventerà importante quanto la code review

In un sistema in cui l’AI partecipa all’implementazione, i team devono comprendere come è stata creata una modifica.

Quale agente l’ha proposta?

Quali istruzioni ha ricevuto?

Quali strumenti ha utilizzato?

Quali test ha eseguito?

Quale sviluppatore l’ha revisionata?

Quali controlli automatizzati ha superato?

Questo crea una nuova forma di tracciabilità del software.

Non è più sufficiente sapere soltanto che cosa è cambiato nel codice.

Sempre più spesso, potremmo aver bisogno di sapere anche come e da chi sono state prese le decisioni che hanno prodotto quella modifica.

Dalla proprietà del codice alla governance dell’AI

Molti team di sviluppo software utilizzano già il concetto di proprietà del codice.

Un team o uno sviluppatore è responsabile di una parte specifica del sistema.

Gli agenti di coding non dovrebbero eliminare questo modello.

Potrebbero renderlo ancora più importante.

Un repository può contenere migliaia di righe di codice generate dall’AI, ma deve comunque esistere una responsabilità umana sul sistema.

Qualcuno deve definire gli standard.

Qualcuno deve stabilire i limiti dell’autonomia.

Qualcuno deve analizzare gli incidenti.

E qualcuno deve avere l’autorità di stabilire che una modifica prodotta dall’AI non debba essere distribuita in produzione.

La responsabilità del codice AI sta diventando parte dell’architettura software

Per ALSoft, la domanda su chi abbia scritto una determinata riga di codice diventerà gradualmente meno importante rispetto alla domanda su come quel codice sia stato verificato prima di diventare parte del sistema.

Le organizzazioni che utilizzano agenti di coding devono progettare non soltanto il modo in cui l’AI produce il codice, ma anche il modo in cui quel codice viene testato, revisionato, approvato e tracciato.

Ciò significa che la responsabilità non può essere una discussione che inizia soltanto dopo che si è verificato un incidente.

Deve essere integrata fin dall’inizio nell’architettura del processo di sviluppo.

Come afferma Ermal Beqiri, fondatore di ALSoft:

“L’AI può assumersi una quota crescente dell’implementazione, ma la responsabilità non può essere delegata a un modello. Se un’organizzazione decide di affidare all’AI la scrittura del codice, deve anche costruire i meccanismi che definiscono chi lo revisiona, chi lo approva e chi è responsabile del risultato. L’autonomia tecnica deve sempre essere accompagnata da una chiara responsabilità umana.”

L’AI sta cambiando la paternità del software.

Una quota crescente dell’implementazione può essere prodotta da sistemi che non sono umani.

Ma questo non significa che la responsabilità debba diventare poco chiara.

Al contrario.

Più autonomo diventa un agente di coding, più chiaramente devono essere definiti i suoi limiti, il processo di verifica e la responsabilità umana sul risultato.

Nell’era degli agenti di coding, la domanda non sarà più semplicemente:

“Chi ha scritto questo codice?”

La domanda più importante sarà:

“Chi ha deciso che questo codice fosse sufficientemente affidabile per essere utilizzato?”