L’agente di coding non aspetta più lo sviluppatore: il software continua a essere sviluppato anche quando il team è offline

Per decenni, lo sviluppo software è stato direttamente legato alla presenza dello sviluppatore.

Lo sviluppatore apre l’ambiente di sviluppo, analizza il problema, scrive il codice, esegue i test, esamina i risultati e poi decide quale debba essere il passo successivo.

Anche quando l’intelligenza artificiale è entrata in questo processo, il modello iniziale è rimasto quasi invariato.

Lo sviluppatore era online.

L’AI era lì per assisterlo.

Ma gli agenti di coding stanno iniziando a cambiare questa relazione.

Con l’esecuzione nel cloud, la delega delle attività e processi in grado di proseguire in modo indipendente, un agente non ha più necessariamente bisogno che lo sviluppatore rimanga davanti allo schermo per tutto il tempo.

Un’attività può essere delegata.

L’agente può continuare a lavorare nel cloud.

Lo sviluppatore può allontanarsi.

E quando torna, una parte del lavoro potrebbe essere già completata.

Questo può sembrare un semplice miglioramento della produttività.

Ma in realtà potrebbe rappresentare l’inizio di un cambiamento molto più profondo nell’architettura dello sviluppo software.

Dall’AI che risponde all’AI che continua a lavorare

La maggior parte dei primi strumenti di programmazione basati sull’AI funzionava in modo sincrono.

Lo sviluppatore poneva una domanda.

L’AI rispondeva.

Lo sviluppatore esaminava la risposta e decideva cosa dovesse accadere successivamente.

Anche quando l’AI ha iniziato a utilizzare strumenti, terminali e repository, lo sviluppatore rimaneva generalmente una parte attiva della sessione.

Il nuovo modello è diverso.

Invece di dirigere ogni singolo passaggio, lo sviluppatore può definire un obiettivo e delegarne l’esecuzione a un agente.

L’agente può analizzare il repository, modificare file, eseguire comandi, avviare test e continuare il processo in un ambiente cloud.

A questo punto, l’AI non è più semplicemente uno strumento in attesa di un comando.

Sta diventando un processo in grado di continuare a lavorare dopo che l’attività è stata delegata.

Il cloud sta offrendo all’agente di coding un ambiente in cui lavorare

Uno dei cambiamenti più importanti è lo spostamento dell’esecuzione degli agenti verso il cloud.

In un modello tradizionale, molte delle azioni di un agente di coding avvengono sul dispositivo locale dello sviluppatore.

Ciò significa che l’agente dipende dalla sessione locale, dall’ambiente dello sviluppatore e, in molti casi, dalla sua presenza attiva.

L’esecuzione nel cloud cambia questa situazione.

L’attività può essere trasferita in un ambiente remoto in cui l’agente dispone del repository, degli strumenti e delle risorse necessarie per continuare a lavorare.

Questo crea una nuova separazione.

Lo sviluppatore definisce l’attività.

L’infrastruttura crea l’ambiente.

L’agente esegue il lavoro.

Il risultato viene restituito al team per la revisione.

Questo rende il processo di sviluppo meno dipendente da una singola sessione umana.

Lo sviluppatore può delegare un’attività e dedicarsi ad altro

Questo potrebbe cambiare il modo in cui viene organizzata la giornata di uno sviluppatore.

Immaginiamo che uno sviluppatore identifichi diverse attività al mattino.

Un agente si occupa dell’aggiornamento di un modulo.

Un altro analizza un problema nei test.

Un altro processo esamina una pull request.

Nel frattempo, lo sviluppatore può concentrarsi sull’architettura, su un problema più complesso o su una riunione con il team.

Quando torna alle attività delegate, non deve necessariamente ripartire da zero.

Gli agenti potrebbero aver prodotto implementazioni, risultati dei test o proposte già pronte per essere esaminate.

Questo modifica il rapporto tra il tempo umano e il tempo di esecuzione del software.

Nel modello tradizionale, il lavoro spesso si interrompe quando lo sviluppatore si ferma.

Nel modello basato sugli agenti, il processo può continuare.

Il software può essere sviluppato anche al di fuori dell’orario di attività del team

È qui che emerge una possibilità ancora più interessante.

Se un agente può lavorare nel cloud senza che uno sviluppatore lo monitori costantemente, alcuni processi non devono necessariamente essere limitati alle ore in cui il team è attivo.

Un’attività può essere preparata e delegata.

Un processo può essere eseguito successivamente.

Un controllo può essere effettuato periodicamente.

Un agente può analizzare i risultati e preparare il lavoro per la fase successiva.

Al mattino, il team potrebbe non trovare soltanto un elenco di attività da iniziare.

Potrebbe trovare risultati da verificare.

Questo non significa che il software debba modificarsi autonomamente senza supervisione.

Significa che alcune parti del processo di sviluppo possono continuare senza richiedere la presenza costante di una persona.

Dalle sessioni alle attività

Questo cambiamento può sembrare piccolo, ma dal punto di vista architetturale è estremamente significativo.

Fino a oggi, l’interazione con molti strumenti di AI è stata organizzata intorno alle sessioni.

Lo sviluppatore apre una sessione.

Fornisce le istruzioni.

L’AI risponde.

La sessione termina.

Ma gli agenti autonomi stanno spostando questo modello verso un concetto diverso:

l’attività.

Un’attività ha un obiettivo.

Ha un ambiente di esecuzione.

Ha strumenti e vincoli.

Ha uno stato.

E produce un risultato che deve essere restituito allo sviluppatore.

Questo avvicina lo sviluppo basato sull’AI ad altri sistemi distribuiti, nei quali i processi possono essere eseguiti in modo indipendente e i risultati possono essere recuperati successivamente.

Le attività pianificate potrebbero creare una nuova categoria di automazione

Quando gli agenti di coding vengono combinati con l’esecuzione nel cloud e la pianificazione delle attività, le possibilità si ampliano ulteriormente.

Non ogni attività deve necessariamente iniziare con un comando diretto dello sviluppatore in quel preciso momento.

Alcune attività possono essere ripetute.

Per esempio, un agente può controllare periodicamente una parte di un progetto.

Può analizzare nuovi problemi.

Può preparare aggiornamenti.

Può eseguire controlli definiti dal team.

Può identificare i casi che richiedono un intervento umano.

Questo trasforma l’AI da uno strumento che viene attivato soltanto quando lo sviluppatore lo richiede a una componente continua del processo di sviluppo.

Autonomia non significa necessariamente indipendenza

Qui è necessario fare una distinzione importante.

Il fatto che un agente di coding possa continuare a lavorare senza la presenza dello sviluppatore non significa necessariamente che debba prendere ogni decisione autonomamente.

L’autonomia può avere diversi livelli.

Un agente può essere autorizzato ad analizzare il repository.

Può essere autorizzato a modificare un branch isolato.

Può eseguire test.

Può preparare una pull request.

Ma potrebbe non essere autorizzato a integrare quella modifica nel branch principale.

In questo modo, il processo può essere autonomo nell’esecuzione pur rimanendo controllato nel processo decisionale.

Questa distinzione sarà essenziale per l’architettura dei sistemi costruiti intorno agli agenti di coding.

Più a lungo l’agente lavora da solo, più importante diventa la tracciabilità

Quando uno sviluppatore segue ogni passaggio di un agente in tempo reale, è relativamente facile capire cosa sta accadendo.

Ma cosa succede quando l’agente lavora per un periodo prolungato senza supervisione diretta?

Il sistema deve allora essere in grado di spiegare il processo.

Quali file ha analizzato l’agente?

Che cosa ha modificato?

Quali comandi ha eseguito?

Quali test sono stati superati?

Quali test sono falliti?

Quali decisioni ha preso?

In quale momento ha richiesto, o avrebbe dovuto richiedere, un intervento umano?

Più lo sviluppo passa dalle sessioni interattive alle attività autonome, più questa tracciabilità diventa importante.

Lo sviluppatore non dovrebbe vedere soltanto il risultato.

Dovrebbe anche essere in grado di comprendere il percorso seguito dall’agente per raggiungerlo.

Lo sviluppo autonomo richiede limiti chiari

L’esecuzione nel cloud offre flessibilità, ma allo stesso tempo solleva un’importante questione di sicurezza:

Che cosa è autorizzato a fare l’agente quando nessuno lo sta monitorando direttamente?

È qui che convergono alcune delle più importanti sfide architetturali legate agli agenti.

Può modificare qualsiasi file?

Può installare pacchetti?

Può connettersi a Internet?

Può utilizzare credenziali?

Può creare pull request?

Può eseguire workflow?

Può decidere autonomamente quando un’attività è completata?

L’autonomia senza limiti può creare rischi.

Per questo motivo, lo sviluppo autonomo non dovrebbe essere costruito soltanto intorno alle capacità del modello.

Deve essere costruito intorno ai limiti del sistema che controlla il modello.

Lo sviluppatore sta passando dal ruolo di operatore a quello di supervisore

In un modello tradizionale, lo sviluppatore è il principale operatore del processo.

Scrive i comandi.

Modifica i file.

Esegue i test.

Passa da una fase alla successiva.

Con gli agenti di coding, una parte di questa esecuzione può essere delegata.

Questo non elimina lo sviluppatore dal processo.

Ma cambia il punto in cui viene creato il suo valore.

Invece di eseguire manualmente ogni singolo passaggio, lo sviluppatore deve definire:

Quale obiettivo deve raggiungere l’agente?

Quali risorse può utilizzare?

Che cosa non deve modificare?

Quali test devono essere superati?

In quali situazioni deve fermarsi?

Quali risultati richiedono l’approvazione umana?

Queste sono sempre più questioni di orchestrazione e architettura piuttosto che di esecuzione manuale.

Potrebbe emergere un nuovo modello di lavoro: lo sviluppatore delega, l’AI esegue, lo sviluppatore verifica

Se questa direzione continuerà, il ciclo di sviluppo potrebbe essere sempre più organizzato intorno a tre fasi.

Delega.

Lo sviluppatore definisce il problema, i limiti e i criteri di successo.

Esecuzione.

L’agente lavora in modo indipendente in un ambiente controllato, locale o basato sul cloud.

Verifica.

Lo sviluppatore o il sistema di revisione controlla il risultato prima che la modifica diventi parte del software.

Questo modello è molto diverso dalla programmazione tradizionale.

Lo sviluppatore non è più necessariamente la persona che esegue ogni singola azione.

Diventa la persona che progetta, controlla e verifica il modo in cui il lavoro viene svolto.

Lo sviluppo software autonomo sta diventando un problema architetturale

Per ALSoft, lo sviluppo software autonomo non dovrebbe essere considerato semplicemente un modo per produrre più codice in meno tempo.

Cambia l’architettura stessa del processo di sviluppo.

Nel momento in cui un agente di coding può continuare un’attività nel cloud anche dopo che lo sviluppatore ha lasciato la sessione, il team deve definire non soltanto ciò che l’AI può fare, ma anche come controllare il lavoro che svolge senza una supervisione continua.

Questo include l’isolamento dell’ambiente, i limiti di accesso, la tracciabilità, i criteri di completamento, i test automatizzati e i punti in cui è richiesta l’approvazione umana.

Come afferma Ermal Beqiri, fondatore di ALSoft:

«Il passo decisivo non è semplicemente il fatto che l’AI possa scrivere codice. Il vero cambiamento inizia quando uno sviluppatore può delegare un obiettivo, lasciare la sessione e tornare trovando un risultato prodotto nel frattempo. A quel punto, non stiamo semplicemente automatizzando il coding; stiamo progettando un nuovo sistema di lavoro in cui l’autonomia dell’AI deve essere accompagnata da limiti, tracciabilità e controllo umano.»

Gli agenti di coding stanno gradualmente cambiando il rapporto tra le persone e il processo di sviluppo.

All’inizio, l’AI aspettava lo sviluppatore.

Poi ha iniziato a suggerire codice.

Successivamente ha iniziato a utilizzare strumenti ed eseguire comandi.

Ora sta emergendo la fase successiva:

un’AI che continua a lavorare anche dopo che lo sviluppatore non è più nella sessione.

Questo potrebbe creare team di sviluppo software che lavorano in modo molto più asincrono.

Le persone definiscono gli obiettivi e prendono le decisioni critiche.

Gli agenti svolgono una parte sempre maggiore dell’esecuzione.

E l’infrastruttura collega questi due mondi definendo ciò che può essere eseguito automaticamente e ciò che deve attendere l’intervento di una persona.

In questo modello, la domanda non è più semplicemente:

«Quanto codice può scrivere l’AI?»

La domanda più interessante sta diventando:

«Per quanto tempo può continuare il processo di sviluppo senza che lo sviluppatore sia davanti allo schermo?»