La settimana scorsa Anthropic ha rilasciato Claude 3.7 Sonnet e, insieme, un tool che non mi aspettavo di usare così presto: Claude Code, una research preview di un agente che vive nel terminale. Sono passati pochi giorni e ho già cambiato una parte del mio modo di lavorare. Provo a mettere per iscritto cosa gli delego davvero sui progetti, cosa non gli lascio toccare, e una tesi che mi si sta formando in testa mentre lo uso.
La tesi, detta subito, perché è l’unica cosa che vale la pena portarsi a casa da questo pezzo: un agente così non potenzia allo stesso modo chiunque lo usi. Sul codice fa già meglio di uno sviluppatore medio, ma se chi lo guida ha chiare l’idea, i processi e il metodo. Quel “se” non è una clausola di prudenza infilata per non espormi: è il cuore della cosa. Nelle mani di chi sa cosa vuole ottenere è un moltiplicatore. Nelle mani di chi non lo sa produce codice plausibile e sbagliato, e la parte cattiva è che chi non ha competenza non se ne accorge.
Cosa cambia con l'”hybrid reasoning”
Claude 3.7 viene presentato come il primo modello “hybrid reasoning”: puoi usarlo in modalità rapida, come un normale assistente, oppure attivare l’extended thinking e lasciargli spazio per ragionare prima di rispondere. Non è marketing. La differenza la vedo quando il problema ha più passaggi impliciti: un refactoring che tocca tre file collegati, una query che deve reggere edge case, un pezzo di logica di pricing con troppe condizioni.
Il punto interessante non è “pensa di più”, è che decido io quando serve. Per riscrivere una funzione banale non voglio aspettare mezzo minuto di ragionamento. Per capire perché una regola di catalogo si comporta in modo strano su un ambiente Adobe Commerce, invece, quel tempo in più mi restituisce una risposta che tiene conto di cose che io stesso avrei dimenticato di controllare. È un controllo di granularità che prima non avevo. Con una postilla che vale la pena dire ad alta voce: il modello non sa quale dei miei problemi è profondo e quale è banale. Quel giudizio resta mio, e se lo sbaglio io lo sbaglia anche lui.
Claude Code: l’agente entra nel terminale
Claude Code è un’altra cosa rispetto alla chat. Gira nel terminale, legge il repository, esegue comandi, scrive file, li modifica. Non è più “copio la domanda, incollo la risposta”: è un agente che agisce sul progetto. Questa è la parola che pesa, agisce. La comodità è reale, ma proprio perché agisce va tenuto al guinzaglio corto.
Nei primi giorni l’ho messo a lavorare su cose molto concrete. Uno script di migrazione dati tra due tracciati, impostato in dieci minuti descrivendogli input e output. Un refactoring di una serie di funzioni con nomi incoerenti, dove il valore non era la creatività ma la pazienza meccanica di rinominare senza rompere i riferimenti. Un paio di automazioni per generare report ricorrenti da file che ricevo ogni mese. In tutti questi casi il denominatore comune è lo stesso: compito noioso, verificabile, a basso rischio. E, aggiungo, compito che io saprei fare a mano. Non è un dettaglio: è la ragione per cui riesco a controllarlo.
Nel tempo libero sto provando a spingermi un po’ più in là, e lo dico per quello che è: un esperimento, non un prodotto. Ho messo insieme un primo prototipo di MCP server sopra un’istanza Adobe Commerce di test, giusto per vedere se un agente riesce a interrogare ordini e attributi prodotto senza che io gli incolli mezzo database nel prompt. Funziona, in un senso molto limitato della parola: espone quattro cose in croce, la gestione degli errori è imbarazzante e non lo farei vedere a nessuno. Ma il fatto stesso che in una sera ci si arrivi mi dice qualcosa su dove sta andando questo mestiere.
Cosa gli delego davvero
Delego volentieri tre categorie di lavoro.
- Script e automazioni usa-e-getta. Trasformazioni di dati, parsing di export, piccoli tool interni. Sono il caso perfetto: il risultato o funziona o no, e me ne accorgo subito.
- Refactoring meccanico. Rinominare, spezzare funzioni troppo lunghe, uniformare uno stile. Lavoro dove sbagliare costa poco e controllare costa ancora meno.
- Prima bozza di codice in territori che conosco. Se so già come dovrebbe essere fatta una cosa, farmela scrivere e poi correggerla è più veloce che partire da zero. La competenza resta il mio filtro, non la sua.
Un esempio dal campo, anonimizzato: per un merchant fashion di taglia media avevo bisogno di riconciliare un export ordini con un tracciato gestionale che nessuno aveva più voglia di guardare. Ho descritto le due strutture, Claude Code ha prodotto lo script, l’ho fatto girare su un campione, ho trovato due colonne mappate male, gliel’ho detto, ha corretto. Ci ho messo un pomeriggio. A mano ci avrei messo un paio di giorni, ma è una mia stima, non una misura, e la scrivo come tale. Il campione, comunque, l’ho controllato io riga per riga: quella parte non si comprime.
E adesso la volta che è andata male, perché è la cosa che dice di più. Gli ho chiesto un pezzo più ambizioso, una sincronizzazione di giacenze tra gestionale ed e-commerce. Il codice era ordinato, commentato, e girava. Peccato che gestisse in modo silenzioso le righe con quantità negative (i resi rientrati) e che i numeri, dopo due giorni, non tornassero più. Ho perso mezza giornata a capire dove, e la colpa era mia: gli avevo dato un contesto povero, senza spiegargli come funzionano davvero i movimenti di magazzino di quel cliente. L’agente non ha inventato niente, ha semplicemente eseguito il mio modello mentale incompleto. Ecco cosa intendo quando dico che è un moltiplicatore: moltiplica anche gli errori a monte.
Cosa NON gli lascio fare
Qui sono rigido, e credo che chi lavora su sistemi di produzione dovrebbe esserlo.
- Niente accesso diretto ad ambienti di produzione. L’agente lavora in locale o su ambienti isolati. Un comando sbagliato eseguito in autonomia su un e-commerce vivo non è un rischio teorico, è un incidente.
- Niente decisioni di architettura. Come strutturare un’integrazione, dove mettere un confine tra sistemi, quale trade-off accettare tra performance e manutenibilità: questa è la parte per cui vengo pagato, e non la delego a un modello che ottimizza per “farmi contento adesso”.
- Niente merge senza revisione umana. Il codice che produce passa sempre da una lettura mia prima di entrare da qualche parte. Non perché sia scritto male, spesso è ordinato, ma perché la responsabilità di quel codice resta di chi lo firma.
- Niente su ciò che non so verificare. Se mi trovassi a non saper giudicare se una sua risposta è giusta, il problema non è suo, è che sto delegando competenza che non ho. Lì mi fermo e studio, non accetto.
Sull’ultimo punto ho anche dei dubbi, per onestà. La regola è facile da enunciare e difficilissima da applicare, perché il codice sbagliato di un buon modello somiglia moltissimo al codice giusto. Non ho una soluzione elegante: per adesso l’unica difesa che conosco è restare quello che sa già come dovrebbe venire il risultato.
La mia opinione onesta
La domanda che mi sento fare più spesso è “quindi ti sostituisce?”. No, e trovo che sia la domanda sbagliata. Claude 3.7 e Claude Code spostano il collo di bottiglia: prima era la produzione, la scrittura materiale del codice o dello script; adesso è la verifica. Il tempo che risparmio a scrivere lo reinvesto a controllare, e il controllo richiede più competenza di prima, non meno. Il valore si sposta a monte, sull’idea e sulla progettualità: non su come si fa una cosa, ma su cosa vale la pena fare.
Da questo discende la parte che dà fastidio dirla: lo sviluppatore che oggi liquida questi strumenti come giocattoli inaffidabili, secondo me, sta guardando dal lato sbagliato. Non perché l’AI sia infallibile, ho appena raccontato il contrario, ma perché chi ha idee, processi e metodo chiari con questi strumenti fa in una frazione del tempo quello che faceva prima. Chi non li ha, invece, farà solo più danni più in fretta. Non è una promessa di produttività per tutti: è esattamente il punto in cui i due gruppi si separano.
C’è poi un rischio concreto che vedo già in giro: la fiducia mal riposta. Un agente che gira nel terminale ed esegue comandi dà una sensazione di autonomia che invita a mollare la presa. È esattamente il momento in cui bisogna stringerla. La produttività vera non arriva da chi delega tutto, arriva da chi sa cosa delegare e cosa no.
Detto questo, non torno indietro. Il ragionamento a granularità controllata di 3.7 e l’agente nel terminale sono, per il tipo di lavoro che faccio, il salto più concreto che abbia visto da un po’. Non perché siano magici, ma perché finalmente il modello agisce dove serve, cioè dentro il progetto e non a fianco. Il resto, cioè il giudizio, resta un lavoro umano. E per me è una buona notizia. Ma è una lettura a caldo di uno che ci gioca da due settimane: se tra sei mesi avrò cambiato idea su qualcosa, lo scriverò qui.
Mini-FAQ
Cos’è l’hybrid reasoning di Claude 3.7?
È la possibilità di usare lo stesso modello in modalità rapida oppure con extended thinking, decidendo caso per caso quanto tempo lasciargli per ragionare prima di rispondere.
Che cos’è Claude Code?
È una research preview di un agente da terminale, rilasciata insieme a Claude 3.7 il 24 febbraio 2025, che legge il repository, esegue comandi e scrive o modifica file direttamente sul progetto. Va trattata per quello che è, una preview, non uno strumento maturo.
Cosa conviene delegare a un agente di questo tipo?
Compiti noiosi, verificabili e a basso rischio: script usa-e-getta, refactoring meccanico, automazioni ricorrenti e prime bozze in ambiti che si conoscono già. La regola pratica è: deleghi bene solo ciò che sapresti fare da solo.
Cosa non andrebbe delegato?
Accesso diretto alla produzione, decisioni di architettura, merge senza revisione umana e qualsiasi cosa che non si sia in grado di verificare.
Fabio Canovi è consulente Adobe presso il gruppo Lutech, certificato Adobe Commerce, Adobe Experience Manager, Adobe Analytics e Adobe Target. Approfondisce l’AI agentica e il lavoro con Claude, integrandolo nei progetti reali di chi vende online.