Copilot, Cursor o Claude Code: quale AI da coding vale davvero i soldi nel 2026

La discussione parte quasi sempre da qui: meglio GitHub Copilot, Cursor o Claude Code?

A gennaio me l'ha aperta così un tech lead di Bologna, davanti a un caffè, con il tono di chi si vergogna un po' della domanda: “Matteo, il team paga tre abbonamenti diversi. Nessuno sa dire quale serve a cosa. Li tengo tutti?”

La sua domanda è uguale alla tua, con nomi diversi nella lista.

Domanda tutt'altro che ingenua: anzi, è quella giusta, fatta con due anni di ritardo, perché nel frattempo nessuno gliel'aveva spiegato.

Nel 2026 non ti chiedi più se usare un'intelligenza artificiale per scrivere codice. Ti chiedi quale usare, e per cosa.

E la risposta che dai oggi decide quanto lavoro puoi delegare davvero, quanto tempo recuperi ogni settimana e quanti soldi stai bruciando in licenze che sfrutti a un terzo.

Tre strumenti hanno definito le categorie:

• GitHub Copilot, il più diffuso, la porta d'ingresso per la maggioranza degli sviluppatori.
• Cursor, l'ambiente di sviluppo costruito attorno all'intelligenza artificiale, che si è preso una fetta consistente dei professionisti.
• Claude Code, l'agente che lavora direttamente sui file del tuo progetto.

Windsurf e le altre alternative meritano un capitolo a parte, e ce l'hanno.

Quello che leggi qui non esce da un test di laboratorio né da una tabella di funzionalità copiata dai siti dei produttori.

Esce da un lavoro su .NET: rifattorizzare il codice esistente, aggiungere una nuova funzionalità dentro una solution che esiste già, generare test, cercare un bug, capire un repository che non hai mai visto.

I risultati cambiano parecchio a seconda del compito, e proprio questa è la parte che le comparative saltano sempre.

Poi c'è il conto.

Copilot costa dieci euro al mese, Cursor venti, Claude Code viaggia dentro un piano da cento.

Se paghi cento euro al mese e usi il trenta per cento di quello che hai comprato, non stai investendo: stai facendo beneficenza ad un fornitore.

La scelta giusta dipende dal tuo profilo d'uso, non dall'entusiasmo di chi parla dal palco di una conferenza sponsorizzata dal produttore.

Una premessa onesta: questa è la fotografia dei prezzi di agosto 2026.

Questo settore si muove in fretta, alcune funzionalità che descrivo possono essere già migrate su piani diversi, e i prezzi vanno sempre verificati sui siti ufficiali prima di sottoscrivere qualsiasi cosa.

Completamento, IDE, agente da terminale: le tre categorie che le comparative non distinguono

Copilot, Cursor e Claude Code finiscono in tabella uno accanto all'altro, ma fanno tre mestieri diversi: il completamento dentro l'ambiente che usi già, l'ambiente di sviluppo costruito attorno al modello, l'agente che lavora da solo nel terminale.

È la differenza tra un cacciavite elettrico, un banco da lavoro e l’artigiano a cui affidi il pezzo.

Tre anni fa si discuteva se questi strumenti avrebbero sostituito gli sviluppatori.

Quella discussione è finita, e non con un verdetto drammatico: chi li usa bene produce di più di chi non li usa.

Punto.

La domanda utile oggi è molto più pratica, e nessuno te la imposta correttamente perché sbaglia il paragone fin dall'inizio: confronta i tre come se facessero lo stesso mestiere, ed è il motivo per cui tanti team comprano male.

La prima categoria è il completamento intelligente dentro l'ambiente che usi già. Scrivi, e lo strumento propone il resto della riga o del metodo.

GitHub Copilot domina qui, con oltre 1,3 milioni di abbonati nel 2024 e una presenza in tutti i principali ambienti di sviluppo.

La seconda è quella degli ambienti costruiti attorno all'intelligenza artificiale, dove il modello non è un componente aggiuntivo, ma il centro dell'esperienza.

Cursor ha inventato questa categoria, Windsurf di Codeium è il concorrente principale.

La terza è quella degli agenti da terminale: programmi che lavorano da soli sul filesystem, eseguono comandi, leggono e modificano file senza che tu apra una finestra.

Claude Code di Anthropic è il riferimento, insieme a OpenAI Codex CLI e Gemini CLI.

Messe una accanto all'altra, le tre categorie si distinguono per una cosa sola, quanto lavoro sei disposto a delegare:

Queste tre categorie non si escludono.

Molti senior nel 2026 ne tengono due aperte contemporaneamente e scelgono in base al compito, come faresti con gli attrezzi in officina.

Capire quale categoria copre quale tipo di lavoro è il prerequisito di qualsiasi scelta sensata: senza quello, stai solo confrontando prezzi.

E il tuo contesto pesa più di quanto ti dicano.

Se apri Visual Studio ogni mattina la partita è diversa che in VS Code.

Se lavori su un gestionale enterprise da centinaia di migliaia di righe hai bisogni diversi da chi sviluppa un prodotto giovane da ventimila.

Le comparazioni generiche ignorano le variabili che decidono la risposta.

GitHub Copilot nel 2026: cosa fa ancora meglio di tutti e dove ti lascia a piedi

GitHub Copilot resta la porta d'ingresso più naturale per chi non ha ancora messo l'intelligenza artificiale dentro il proprio modo di lavorare, e il motivo è banale: non ti costringe a cambiare niente.

Lo installi come estensione nell'ambiente che già usi, e la prima settimana ti sei già ripagato l'abbonamento se scrivi codice per mestiere.

Il completamento mentre scrivi, dove è ancora il migliore

Il completamento di Copilot oggi non è quello dei primi tempi.

Guarda il file su cui stai lavorando, i file che hai aperto e, nella versione Business con l'indicizzazione dello spazio di lavoro, l'intero progetto indicizzato.

Su C# questo si sente: tipi, interfacce e schemi di ASP.NET Core vengono riconosciuti con precisione.

Dentro Visual Studio l'integrazione è la più fluida che trovi in giro per chi lavora in .NET.

Funziona bene nei file C#, nei test xUnit e NUnit, nelle viste CSHTML e nei file di configurazione.

Sui tipi nullable, sulle catene LINQ e sui generics è sopra la media dei concorrenti.

Chat e modalità Agent

La chat di Copilot risponde dentro l'ambiente di sviluppo con il contesto del file aperto.

La modalità Agent, arrivata nel 2024 e migliorata nel 2025, ti permette di descrivere un compito più articolato che lo strumento esegue in più passaggi.

Qui però la festa finisce, e non te lo dice nessuno: la modalità Agent di Copilot vede meno codice attorno a sé, pianifica peggio le modifiche distribuite su molti file rispetto a Cursor, e tocca il filesystem in modo molto più timido di Claude Code.

Per i compiti agentici seri non è lo strumento giusto. Prendersela con lui è come prendersela con il cacciavite perché non pianta i chiodi.

Quando Copilot è la risposta onesta

Copilot è la scelta giusta in quattro situazioni precise:

• Stai in Visual Studio o in Rider di JetBrains e non hai nessuna intenzione di cambiare;
• Il team è già su GitHub e ti serve una governance centralizzata;
• Il budget per questi strumenti è contenuto;
• Vuoi qualcosa che non ti stravolga la giornata.

Il piano individuale costa quanto un abbonamento allo streaming, e il ritorno lo verifichi nella prima settimana.

La versione per team costa circa il doppio a persona e aggiunge gestione delle regole, tracciamento degli utilizzi del team e integrazione con GitHub Enterprise.

Se qualcuno ti racconta che è una spesa da valutare a lungo, non ha mai contato quanto costa un'ora del tuo tempo.

GitHub Copilot vs Cursor: quando conviene pagare il doppio

La differenza tra Copilot e Cursor non è una lista di funzionalità in più. È che smetti di suggerire righe e inizi ad assegnare compiti.

Dimentica l'idea del plugin: Cursor è un ambiente di sviluppo completo, costruito su VS Code, dove il modello fa parte della struttura invece di stare appiccicato sopra.

Da lì nascono capacità che un'estensione non può replicare, per quanto bene sia scritta.

Il Composer e la modalità Agent

La funzione che separa Cursor da tutto il resto della sua categoria è il Composer, oggi ribattezzato modalità Agent.

Immagina la differenza tra dettare parola per parola a un collega e dargli la specifica del lavoro: è quella.

Un caso concreto su un progetto .NET, dove i DTO sono gli oggetti che trasportano dati tra gli strati: “aggiungi la validazione a tutti i DTO del progetto usando FluentValidation, seguendo lo stesso schema del validatore che ho già scritto per OrderDto”.

Cursor legge tutto il progetto, trova ogni DTO, studia lo schema di OrderDto e propone le modifiche su tutti i file insieme.

Le rivedi nel confronto affiancato e le applichi con un click.

Lo stesso lavoro con Copilot richiede decine di passaggi manuali, uno alla volta, con te che fai da nastro trasportatore.

La chat che conosce tutto il repository

Cursor indicizza il repository in locale, e questo cambia il tipo di domande che puoi fare.

“Perché OrderService dipende da CustomerRepository invece di usare un evento di dominio?” puoi ricevere una risposta che ragiona sull'architettura che hai davvero scritto, con i riferimenti ai file dove sta la roba che conta.

È il momento in cui questa funzione ti salva la giornata: primo giorno su un progetto con 200 file, la documentazione è un README del 2023, e la persona che l'ha scritto è andata via da qualche mese.

Poter fare domande architetturali e ricevere risposte ancorate al codice fa risparmiare giorni di lettura.

Cursor e .NET: il prezzo che non è in listino

Il limite vero di Cursor per chi sviluppa in .NET sta nella base su cui è costruito, non nel modello.

Passando a Cursor lasci il debugger avanzato di Visual Studio, il profiler integrato, le finestre diagnostiche per ASP.NET e il supporto nativo per WPF e Windows Forms.

Se il tuo lavoro poggia su quelle cose, Cursor non sostituisce Visual Studio, e chiunque ti dica il contrario non ha mai dovuto profilare un servizio in produzione a fine trimestre.

Se invece sei già in VS Code per .NET, o sei disposto a starci per le sessioni di sviluppo principali, Cursor è nettamente più potente di Copilot sui lavori complessi.

La valutazione tra quello che perdi e quello che guadagni lo puoi fare solo tu, guardando cosa fai in una settimana tipo.

Cursor Pro costa il doppio di Copilot, e la differenza si giustifica al primo refactoring serio: quello che, solitamente, ti porta via un'ora, in modalità Agent te lo giochi in dieci minuti.

Il resto del mese è guadagnato.

Fermati un secondo e rispondi: sapresti dire adesso, senza esitare, quale dei tre userai domani mattina e per fare cosa?

Se la risposta tarda non è colpa degli strumenti.

Manca il criterio che sta sopra, e quel criterio si costruisce su un sistema, con qualcuno che ti dice dove stai sbagliando mentre lo fai: è la ragione per cui esiste il Corso Architetto Software Ai.

Pensato per progettare sistemi .NET dove l'AI è parte dell'architettura, non un accessorio appiccicato sopra.

Più aspetti, più codice generato dovrai rileggere con le regole di adesso.

Claude Code: l'agente da terminale che pianifica il lavoro invece di suggerirti righe

Claude Code non gioca lo stesso campionato di Copilot e Cursor, e chi lo mette nella stessa tabella sta confrontando un consulente con un cacciavite.

Vive nel terminale e lavora direttamente sui file del tuo progetto: legge, esegue comandi, modifica e naviga il repository con un'autonomia che decidi tu.

Ma come lavora?

Lo lanci con il comando claude dentro la cartella del progetto.

Gli descrivi cosa vuoi, e da lì parte: apre i file che servono, ricostruisce l'architettura, decide quali modifiche fare e in che ordine, e le esegue chiedendoti conferma quando la posta è alta.

Può compilare, lanciare i test, fare commit, installare dipendenze.

Un plugin dentro l'ambiente di sviluppo queste cose non le tocca nemmeno.

La caratteristica che conta è la pianificazione a più passi. Se gli chiedi una funzionalità nuova, non ti restituisce un blocco di codice da incollare.

Ragiona sul contesto, elenca i file da creare o modificare, tiene conto delle dipendenze tra le modifiche e procede in ordine.

È il lavoro per cui è stato costruito, ed è anche il lavoro che ti consuma di più le giornate quando lo fai a mano.

I tre compiti dove Claude Code stacca gli altri

Il codice esistente che nessuno ha documentato: “Spiegami come funziona l'autorizzazione in questo progetto” produce una ricostruzione che attraversa i file rilevanti, riconosce gli schemi usati e ti segnala cosa non torna.

Se erediti sistemi altrui per mestiere, questa cosa da sola cambia il tuo mese.

Il refactoring architetturale: “Porta questo sistema da un repository pattern fatto a mano a MediatR”, oppure “estrai questo modulo in un servizio separato seguendo lo schema Strangler Fig”.

Qui il vantaggio è netto: capire l'architettura che c'è e pianificare modifiche coerenti su molti file è esattamente ciò che gli altri due fanno peggio.

I test scritti da zero: Claude Code legge la logica di business, scrive test unitari e di integrazione sui casi che contano davvero, li esegue e sistema quelli che falliscono.

Non è il boilerplate che ti riempie la cartella di test e ti lascia la copertura vera dov'era.

Il limite, detto senza giri di parole

Non c'è interfaccia grafica.

Se non sei abituato al terminale, il ritmo di lavoro ti sembrerà scomodo per un po', e come primo strumento in assoluto è la scelta sbagliata.

Il motivo non è che sia roba da veterani: è che impareresti a programmare e a guidare un agente nello stesso momento, e nessuna delle due cose verrebbe bene.

A chi si rivolge non lo dice il prezzo: Claude Code è incluso anche nel piano base di Claude, e salendo di piano non compri funzioni in più, compri margine prima di trovare il limite d'uso.

Lo dice l'uso che ne fai.

Per un senior o un tech lead che ci lavora ogni giorno su questioni architetturali il piano alto si ripaga alla prima settimana, per chi lo apre due volte al mese il piano base basta e avanza.

Se invece quello che cerchi è il completamento mentre scrivi, Claude Code è lo strumento sbagliato a qualunque prezzo: quel lavoro lo fa meglio, e per meno, un completamento dentro l'ambiente.

Windsurf, Continue.dev e Zed: le alternative che hanno senso e per chi

I tre nomi grossi non esauriscono il mercato, e in tre situazioni precise ti conviene guardare altrove.

Il motivo è banale: hai un vincolo che Copilot e Cursor non sono stati progettati per rispettare.

Windsurf conviene se Cursor costa troppo, Continue.dev se il codice non può uscire dall'azienda, Zed se la macchina è lenta.

In queste tre situazioni non stai scegliendo lo strumento migliore, stai scegliendo quello che passa dalla porta di casa tua: hai un vincolo che Copilot e Cursor non sono stati progettati per rispettare.

Windsurf, il concorrente diretto di Cursor

Windsurf di Codeium fa più o meno le stesse cose di Cursor: modalità Agent su più file, chat che conosce il repository, completamento evoluto.

La differenza sta nel prezzo e nella politica sui modelli.

Il piano gratuito è più generoso di quello di Cursor, e questo lo rende il modo più economico per capire se un ambiente costruito attorno all'intelligenza artificiale fa per te prima di mettere mano al portafoglio.

Su molti compiti la modalità Agent regge il confronto, anche se l'ecosistema di integrazioni e la comunità sono più giovani.

Un fattore che i confronti tecnici non considerano mai: Codeium è un'azienda più piccola di Anysphere, che sta dietro Cursor, e di GitHub, che sta dentro Microsoft.

Quanto durerà lo strumento è una domanda legittima. Per un team enterprise che deve standardizzare per tre anni, può essere la domanda decisiva.

Continue.dev, quando il codice non può uscire

Continue.dev è un'estensione libera per VS Code e JetBrains che ti lascia collegare il modello che vuoi, compresi modelli che girano sulla tua macchina con Ollama.

È la risposta per i team che hanno un vincolo vero sulla riservatezza del codice e non possono spedirlo a un servizio esterno, o per chi vuole abbattere i costi usando modelli locali.

Il prezzo di questa libertà è la configurazione: richiede più lavoro iniziale di Copilot o Cursor, e la qualità di quello che ottieni dipende parecchio dal modello che scegli.

Se cerchi qualcosa che funzioni subito senza pensarci, non è questa la strada giusta.

Zed, per chi ha lasciato l'ecosistema VS Code

Zed è un editor nato con la velocità come ossessione, scritto in Rust, con l'intelligenza artificiale integrata in modo nativo.

Su macchine con poche risorse è sensibilmente più rapido di VS Code e di Cursor.

Il rovescio è il supporto a .NET: fuori dagli editor Microsoft l'analisi del codice C# e il debug si appoggiano a componenti meno completi, e Zed eredita quel limite.

Da tenere d'occhio, non da adottare come editor principale.

GitHub Copilot vs Cursor, e dove Claude Code li stacca entrambi

Ogni classifica generale su questi strumenti è aria fritta, e il motivo è semplice: cambiando il compito cambia il vincitore.

Quindi niente podi.

Cinque lavori che fai davvero in una settimana su .NET, e chi se la cava meglio su ciascuno.

Costruire e far crescere una nuova funzionalità

Devi aggiungere un nuovo endpoint al progetto ASP.NET Core, usando la struttura già presente nel progetto e preparando anche i test di base.

GitHub Copilot: con la modalità Agent porta a casa buona parte del lavoro, ma se non gli dai contesto particolareggiato, tende a produrre file che seguono schemi generici invece dei tuoi.

Ti serve stare lì a guidarlo.

Cursor in modalità Agent: qui è nel suo elemento. Prende un endpoint esistente come modello, riconosce le convenzioni e genera tutto rispettandole.

Il confronto affiancato rende veloce la revisione prima di applicare.

Claude Code: risultato simile a Cursor, con un'aggiunta che pesa: esegue subito i test che ha scritto e corregge quelli che falliscono.

Quel ciclo compila, prova, sistema; è il suo vantaggio.

Potremmo dire: Cursor e Claude Code a pari merito, Copilot terzo.

Due: rifattorizzare su molti file

Devi rinominare e spostare una classe di dominio usata in 40 file, aggiornare tutti i riferimenti e le iniezioni di dipendenza tenendo in ordine i namespace.

GitHub Copilot: per questo lavoro gli strumenti di refactoring di Visual Studio o Rider sono migliori dell'intelligenza artificiale.

Copilot non aggiunge molto a un compito meccanico che l'ambiente già risolve bene.

Cursor in modalità Agent: se la cava, anche quando si tratta solo di rinominare gli strumenti nativi sono più precisi.

Cursor comincia a rendere quando il refactoring porta con sé modifiche di logica, non solo di nome.

Claude Code: quando devi estrarre una classe in un contesto delimitato separato, aggiornare tutti i punti di iniezione e aggiungere il mapping giusto, la pianificazione contestuale fa la differenza.

Sul refactoring complesso passa Claude Code.

Quando è solo una rinomina meccanica, tieniti gli strumenti nativi dell'ambiente, e va benissimo così.

Tre: capire perché quella cosa non funziona

Un endpoint restituisce un risultato sbagliato in condizioni specifiche. Devi trovare la causa.

GitHub Copilot: in chat ti aiuta a ragionare se gli incolli log e codice.

Il suo asso è l'integrazione con il debugger di Visual Studio: suggerimenti contestuali mentre avanzi passo passo.

Cursor: la chat che conosce il repository ti evita il copia e incolla continuo di frammenti.

Poter chiedere “mostrami tutti i punti dove questo valore viene modificato” è comodissimo.

Claude Code: superiore quando il bug è architetturale.

“Perché questo servizio riceve valori null nonostante la validazione?” produce un'analisi che segue il flusso lungo tutta la catena di chiamate, che è precisamente il punto in cui, di solito, tu perdi il pomeriggio.

Vince Claude Code sui problemi architetturali, Copilot quando stai già dentro il debugger.

Quattro: scrivere i test

Devi coprire con test unitari un servizio di logica di business con 15 metodi, casi limite compresi.

GitHub Copilot: va bene sui metodi semplici, ma resta in superficie: copre i percorsi felici e ti lascia scoperti proprio i casi che poi esplodono.

Cursor in modalità Agent: meglio di Copilot sui casi limite quando gli spieghi le regole di business.

Vedere l'implementazione completa del servizio lo aiuta parecchio.

Claude Code: il migliore, senza discussione.

Analizza la logica, individua i casi limite che contano, scrive i test, li esegue e sistema quelli rossi in autonomia.

La qualità di quello che resta a terra è di un altro livello.

Qui non c'è partita: Claude Code.

Cinque: documentare

Devi aggiungere documentazione XML ai metodi pubblici di una libreria, scrivere il README di un modulo, spiegare gli schemi meno ovvi.

GitHub Copilot: sui commenti XML in C# è imbattibile. Il completamento dei tag è preciso e non ti rallenta.

Per questo compito specifico è il più scorrevole dei tre.

Cursor: buono, ma sulla documentazione meccanica il completamento di Copilot scorre meglio.

Claude Code: ottimo sulla documentazione di alto livello e sulle spiegazioni architetturali, meno adatto a riempire commenti riga per riga.

Copilot sui commenti, Claude Code sulla documentazione architetturale.

Cinque compiti, tre vincitori diversi. Chiunque ti venda un vincitore assoluto non ha provato tutti e cinque.

Se lo vuoi a colpo d'occhio, il riepilogo è questo:

Quanto costano davvero Copilot, Cursor e Claude Code: listino e costi nascosti

I prezzi qui sotto sono quelli di agosto 2026 e cambiano spesso: prima di decidere, controlla i siti ufficiali.

Il listino però è la parte facile. Quella che ti frega sta sotto.

GitHub Copilot

Individual costa circa dieci euro al mese, o cento all'anno.

Comprende completamento, chat e modalità Agent, con un tetto mensile sulle richieste ai modelli più costosi.

Business, diciannove euro a persona, aggiunge gestione centralizzata delle policy, tracciamento degli utilizzi, esclusione di repository specifici e integrazione con GitHub Enterprise.

C'è un vantaggio economico che non compare in nessuna tabella: su Visual Studio Copilot è integrato nativamente.

Non devi comprare, imparare e mantenere un secondo ambiente di sviluppo, e quel costo lì è reale anche se nessuno lo fattura.

Cursor

Il piano gratuito include un numero limitato di richieste mensili ai modelli avanzati.

Pro, circa venti euro al mese, dà crediti mensili sui modelli migliori e la modalità Agent senza limiti pratici per un uso normale.

Business aggiunge governance di squadra e fatturazione centralizzata.

Qui sta il costo nascosto: quando i crediti mensili finiscono, continui pagando a richiesta.

Se usi la modalità Agent in modo intensivo, la cifra reale a fine mese può staccarsi parecchio dai venti euro del listino.

Nessuno ti sta truffando, il modello a consumo è dichiarato. Ma se non lo sai in anticipo, lo scopri dall'estratto conto.

Claude Code

Claude Code non è più disponibile solo nel piano più caro.

È incluso in Claude Pro, circa venti euro al mese, e in Claude Max, che parte da cento e arriva a duecento: quello che cambia tra i due non è l'accesso allo strumento ma quanto puoi usarlo prima di trovare il limite.

Se ci lavori ogni giorno sui compiti architetturali il piano più costoso si ripaga.

Se lo apri due volte al mese, il piano da cento euro non ti serve, e nessuno dovrebbe raccontarti il contrario.

Resta la strada della chiave API pagata a consumo, con lo strumento configurato per conto proprio.

Da quando Claude Code è entrato nel piano Pro quella convenienza si è ristretta parecchio: ha senso solo se l'uso è davvero sporadico e concentrato in poche sessioni all'anno.

Fai il conto prima di mettertici.

Tre voci che nessun listino ti mostra e che cambiano il conto:

• su Visual Studio Copilot è integrato nativamente, quindi non paghi il secondo ambiente di sviluppo da comprare, imparare e mantenere;
• il consumo oltre il credito incluso non riguarda più solo Cursor: da giugno 2026 anche Copilot fattura a crediti; quindi, su entrambi la cifra reale di fine mese si stacca dal listino se usi la modalità Agent tutti i giorni;
• Claude Code non richiede il piano da cento euro: è incluso in Claude Pro, e per un uso saltuario quello basta.

Il conto vero si fa in ore

Confrontare dieci, venti e cento euro tra loro non significa niente.

L'unico confronto che conta è tra quello che paghi e quello che recuperi.

Un refactoring da quattro ore che ne diventa mezza vale molto più di cento euro al mese per chiunque abbia un costo orario sopra i trenta euro, e questo è aritmetica, non entusiasmo.

Nel 2026 il prezzo di questi strumenti è l'ultimo dei problemi. Il problema è sapere quale usare per cosa, e su quello nessun listino ti aiuta.

Uno strumento da cento euro usato bene ti restituisce più di uno da dieci usato male, e a fare la differenza è chi lo guida.

Cento euro al mese buttati sono un problema piccolo.

Quello grosso è la traiettoria: un anno di strumenti usati al trenta per cento ti lascia esattamente dove sei adesso, con più righe da rivedere.

Se vuoi invertirla, il Corso Architetto Software Ai è la strada giusta, perché parte dal tuo codice e non da un caso di studio.

Un architetto software che guarda le tue decisioni e ti dice dove stai sbagliando.

Aspettare non è gratis, è solo un costo che non compare in fattura.

Junior, senior, team lead o freelance: quale strumento AI ha senso per te

Qui la variabile non è la tecnologia. Sei tu: dove sei arrivato, che tipo di problemi ti arrivano sulla scrivania, chi ti chiede conto quando qualcosa si rompe.

Stessa domanda, quattro risposte diverse.

Se stai iniziando

GitHub Copilot. Curva di apprendimento minima, nessun cambio di ambiente, costo accessibile.

Il ritorno lo vedi subito sui lavori ripetitivi: in un progetto ASP.NET Core sono i DTO che rispecchiano le entità, i profili AutoMapper che li mappano campo per campo, i test di base, i commenti XML.

Il più potente sta altrove, ma nessuno ti dà altrettanto cambiandoti così poco.

Un avvertimento che ti do volentieri, perché è la cosa che vedo rovinare più carriere giovani: accettare completamenti che non capisci ti sembra velocità e invece è debito.

Lo strumento deve accelerare quello che sai già fare, non coprire quello che non hai ancora imparato.

La differenza tra le due cose diventa visibile quando, al primo colloquio tecnico serio, ti chiedono perché hai scritto quella riga.

Se sei a metà strada e vuoi spingere

Cursor Pro.

La modalità Agent cambia in modo tangibile come affronti i lavori complessi.

Se operi già in VS Code, o sei disposto a farlo, il salto da Copilot a Cursor si ripaga alla prima sessione di refactoring seria: dieci euro in più al mese sono niente.

Se invece lavori in Visual Studio e non puoi muoverti, Copilot Business resta la scelta pratica.

Sappi solo che stai lasciando qualcosa sul tavolo, e che è una scelta, non una decisione definitiva.

Se sei senior su progetti complessi

Claude Code come strumento principale sui lavori architetturali, con Copilot o Cursor nell'ambiente per il quotidiano.

I problemi che arrivano a te sono di un altro tipo: sistemi legacy da decifrare, refactoring che toccano mezzo progetto, feature nuove con impatto su moduli che nessuno guarda da due anni.

Claude Code è nato per quello, e su quei compiti il distacco è netto.

La combinazione pratica: Copilot o Cursor aperto tutto il giorno per il completamento, Claude Code nel terminale quando ti siedi a fare la cosa difficile.

Se guidi un team

Claude Code, per il lavoro che fa un tech lead.

Revisione assistita del codice: “cosa non torna in questa implementazione rispetto allo schema che abbiamo deciso?”.

Inserimento di persone nuove: “spiega a un nuovo arrivato come funziona questo sistema”.

Documentazione architetturale generata dal codice che esiste, non da quello che speravi di avere.

Poi c'è la parte di governo: GitHub Copilot Business per le regole a livello di organizzazione e il controllo centralizzato. Sono due mestieri diversi e servono entrambi.

Ed è qui che si vede la differenza tra un tech lead che regge e uno che affoga, e non si vede dalla riga dell'abbonamento.

Si vede dalla capacità di decidere quale lavoro deleghi alla macchina e quale resta un giudizio tuo.

Quella capacità la costruisci in un modo solo: qualcuno con più chilometri di te guarda le tue decisioni sul tuo progetto e ti dice dove stai sbagliando.

Se lavori in proprio

Dipende dal volume e dal tipo di clienti, e per una volta il "dipende" è la risposta giusta.

Se salti da un codice altrui all'altro, Claude Code ti fa risparmiare i giorni peggiori, quelli in cui non capisci ancora dove mettere le mani.

Se invece lavori a lungo sugli stessi progetti che conosci a memoria, Cursor Pro è quasi sempre la scelta più efficiente.

Usare due strumenti insieme senza impazzire: il flusso di lavoro a due livelli

Tenere due strumenti aperti sembra indecisione, e invece è il modo in cui lavorano i senior più efficaci nel 2026.

Quello che serve è una regola su quando usare cosa, altrimenti passi la giornata a scegliere invece che a lavorare.

I due livelli

Livello uno, il completamento nell'ambiente.

Copilot o Cursor per il lavoro di ogni giorno: cose veloci, completamento mentre scrivi, test di base, documentazione.

Resta acceso in sottofondo, non ci pensi.

Livello due, le sessioni con l'agente.

Claude Code quando ti fermi per una cosa che richiede testa: refactoring architetturale, analisi di un sistema che non conosci, impalcatura di qualcosa di grosso, un bug che non si fa trovare.

Lo apri quando hai un obiettivo, non per curiosare.

Così i due strumenti non si pestano i piedi, perché coprono lavori diversi. La ridondanza sparisce da sola.

La regola dei cinque minuti

La regola pratica sta in tre righe:

• Meno di cinque minuti: usa quello che hai già aperto nell'ambiente;
• Più di trenta minuti: valuta Claude Code;
• Complesso ma dentro l'ambiente, e Cursor ce l'hai: modalità Agent.

E non cambiare cavallo a metà corsa. Scegli prima di iniziare, porta a termine, poi valuta se per il prossimo la scelta era giusta.

Cambiare strumento nel mezzo è il modo più elegante di perdere un'ora senza accorgertene.

I file che non devono mai finire nel contesto

C'è un dettaglio pratico che salta fuori solo quando è tardi. Tutti e tre gli strumenti mandano il tuo codice a un servizio esterno per elaborarlo.

Variabili d'ambiente con le credenziali, file di configurazione con chiavi API, dati di test con informazioni sensibili: quella roba non deve entrare in quello che lo strumento legge e spedisce.

Tutti e tre hanno un meccanismo per escludere file, simile a .gitignore.

Configurarlo è responsabilità del team, non qualcosa da lasciare ai valori predefiniti e alla buona sorte.

È la classica cosa che costa dieci minuti prima e una settimana dopo.

Il 55% di GitHub e il 20-45% di McKinsey: cosa dicono i dati e cosa non dicono

Due numeri girano in ogni presentazione su questo tema, il 55% di GitHub e il 20-45% di McKinsey.

Trattali come i consumi dichiarati di un'auto: misurati sul serio, ma su un percorso che non è il tuo tragitto per l'ufficio.

Guardali bene prima di appoggiarci sopra una decisione di budget.

I dati che esistono

Il 55% viene da un esperimento controllato di GitHub, pubblicato nel settembre 2022 e poi confluito in un paper con Microsoft Research: 95 sviluppatori professionisti, un compito solo, scrivere un server HTTP in JavaScript.

Chi aveva Copilot ha chiuso in un'ora e undici minuti, chi non l'aveva in due ore e quarantuno.

Il 20-45% viene da Unleashing developer productivity with generative AI, McKinsey Digital, giugno 2023: dal 20-30% di tempo risparmiato sul refactoring al 35-45% sulla scrittura di codice nuovo.

Sulla documentazione McKinsey arriva al 45-50%, che è il caso più favorevole di tutti e infatti è quello che finisce nelle slide.

Vanno presi per quello che sono.

Un server HTTP in JavaScript scritto da zero non somiglia al tuo martedì mattina dentro una solution .NET da trecentomila righe: i test in condizioni controllate misurano compiti puliti, isolati, senza riunioni in mezzo e senza un collega che ti chiede una cosa al volo, e tendono a sovrastimare quello che succede nel lavoro vero.

Il dato più interessante arriva dalle aziende che hanno misurato in casa.

Il beneficio maggiore, però, sta altrove: nel tempo che non perdi più a rimetterti in testa un contesto che avevi lasciato, e in quello che risparmi quando atterri su codice che non conosci.

Come si misura nel tuo team

Cronometra i compiti veri, prima e dopo. Dall'inizio alla fine: capire il problema, scriverlo, testarlo, farlo rivedere.

La velocità di battitura non c'entra niente.

Un metodo che funziona: scegli cinque compiti tipici del tuo flusso, per esempio impalcatura di una feature, refactoring di un modulo, scrittura dei test, caccia a un bug.

Misura senza lo strumento.

Misura con lo strumento.

La differenza è il tuo ritorno reale, non quello del comunicato stampa.

Attenzione a due distorsioni: guidati dall’entusiasmo tendiamo tutti a sottostimare quanto duravano le cose prima, e a sopravvalutare i benefici di uno strumento nuovo nei primi giorni.

Le misure che valgono qualcosa arrivano dopo due o quattro settimane di uso regolare.

Quando il ritorno non arriva

Non è automatico, e quando non c’è i motivi sono quasi sempre gli stessi tre.

Usi lo strumento su compiti talmente semplici che a mano facevi prima.

Non hai mai imparato le funzioni che contano, modalità Agent e chat sul repository, e usi il dieci per cento di quello che paghi.

Oppure lo usi per aiutarti nella comprensione di qualcosa, invece che per accelerarla.

Vale per il codice che scrivi tu e vale, doppiamente, per quello che ti scrive un modello al posto tuo.

Questo è anche il motivo per cui la formazione tecnica seria oggi vale più di prima, non meno.

Un moltiplicatore applicato a poco resta poco. Applicato a competenze solide, ti mette in una categoria di professionisti che nel 2026 sono pochi e si vedono da lontano.

Cosa succede al tuo codice quando usi Copilot, Cursor o Claude Code?

Nessuna comparativa affronta questo capitolo, e capisco il motivo: non aiuta a vendere abbonamenti.

Ma è la prima cosa che ti chiede un CTO o un responsabile sicurezza appena senti nominare questi strumenti in riunione.

Dove finisce il codice? Chi lo legge? Serve ad addestrare i modelli? Quanto resta memorizzato?

Le risposte cambiano da strumento a strumento, e in un contesto enterprise le differenze pesano.

Non è un dettaglio da rimandare a dopo l'acquisto: la privacy è uno dei sette criteri con cui si sceglie l'AI con cui programmare, non un allegato al contratto.

GitHub Copilot: il più attrezzato sul governo

Copilot Individual e Business mandano frammenti di codice ai server di GitHub e Microsoft per generare i completamenti, con il contesto attorno: il file aperto, gli altri file in editor e, con l'indicizzazione dello spazio di lavoro, un indice del repository.

Sull'addestramento GitHub ha una posizione esplicita: i suggerimenti generati non alimentano il modello di base, e nei piani Business ed Enterprise i prompt inviati non restano memorizzati in modo persistente.

Sta nelle condizioni di servizio ufficiali, che conviene leggere direttamente invece di fidarsi del riassunto di qualcuno.

Business aggiunge quello che rende Copilot gestibile in azienda: esclusione di file e cartelle dall'indicizzazione, tracciamento centralizzato degli utilizzi per utente, policy a livello di organizzazione, per esempio disattivare i suggerimenti che riproducono codice open source con certe licenze, e integrazione con l'autenticazione aziendale.

Per chi lavora su dati sanitari, finanziari o pubblici, Copilot Enterprise aggiunge elaborazione isolata, possibilità di scegliere la regione dell'infrastruttura per i requisiti di residenza dei dati, e livelli di servizio compatibili con un audit.

Cursor: la modalità privata e cosa resta fuori dal tuo controllo

Cursor ha una modalità privata che, se attiva, garantisce che il codice non finisca nei log dei loro server e non venga usato per migliorare il modello.

Nei piani Business è attiva di serie.

C'è però un passaggio da capire prima di sottoscrivere l’abbonamento.

Cursor non genera con modelli propri: usa modelli di terzi, principalmente quelli di Anthropic e OpenAI.

Il codice che mandi a Cursor arriva poi a quei fornitori per l'elaborazione.

Con la modalità privata Cursor dichiara di non conservarlo, ma l'elaborazione avviene comunque sui server dei modelli sottostanti.

Se hai vincoli stringenti su dove possono transitare i dati, questo è il punto da portare in riunione.

In pratica, per un team: attiva la modalità privata dall'impostazione centralizzata, e metti un file .cursorignore nella radice del repository per tenere fuori credenziali, configurazioni di produzione e dati di test sensibili.

Il formato è lo stesso di .gitignore.

Cosa escludere di norma: appsettings.Production.json, .env, i certificati, le cartelle con dati di test che contengono dati personali, qualsiasi file con chiavi o stringhe di connessione di produzione.

Questa configurazione la standardizza il team di piattaforma una volta per tutti, non ogni sviluppatore per conto suo.

Claude Code: cosa cambia quando lo strumento legge da solo

Claude Code lavora in locale sul filesystem e manda ad Anthropic il codice che gli serve.

Le regole sono quelle delle condizioni di servizio di Anthropic: per i clienti con piani API standard, il codice inviato non viene usato per addestrare i modelli.

Il punto di attenzione è la sua stessa natura. Claude Code legge attivamente per costruirsi il contesto, e in una sessione normale può aprire decine di file prima di risponderti.

Il volume di codice che esce in una sessione è quindi più alto di quello di un completamento che guarda solo il file aperto.

Funziona così, ed è legittimo: ma va saputo prima, non dopo.

Lo strumento legge un file CLAUDE.md nella radice del progetto e a livello di utente, dove metti le istruzioni di progetto.

Lì dentro vanno anche le indicazioni esplicite su cosa non deve leggere. È uno standard di team da fissare prima di distribuire lo strumento, non dopo il primo incidente.

Messe una accanto all'altra, le tre posizioni sul tuo codice sorgente si leggono così:

Le tre domande da farsi prima di adottarli in squadra

Il codice contiene segreti o proprietà intellettuali che non devono uscire dall'infrastruttura aziendale?

Allora guarda gli strumenti che girano in locale, Continue.dev con modelli locali via Ollama, o le versioni enterprise con garanzie di isolamento.

Il progetto ricade sotto normative specifiche, GDPR, HIPAA, PCI-DSS, NIS2?

Verifica le certificazioni del fornitore e che il contratto includa un accordo sul trattamento dei dati adeguato.

GitHub e Anthropic lo forniscono per i piani Business ed Enterprise.

Lavorate su repository di clienti o partner con obblighi di riservatezza? Mandare quel codice a un servizio esterno può violare il contratto che avete firmato.

Questa la verifichi con chi si occupa di legale prima, non dopo che qualcuno se ne accorge.

Quattro pratiche valgono sempre, qualunque strumento scegliate: mai mandare credenziali, chiavi API o stringhe di connessione nel contesto, mai usare dati di produzione veri nelle sessioni assistite, configurare l'esclusione dei file prima di iniziare, non dopo.

Spiegare al team cosa non deve mai entrare nel contesto, perché finché non gliel'hai detto non è ovvio per nessuno.

I professionisti che nel 2026 si vedono da lontano non sono quelli con l'abbonamento giusto.

Sono quelli a cui puoi mettere in mano un sistema che non hanno mai visto e che, in due giorni, ti dicono dove si romperà.

Quel modo di ragionare è insegnabile, e il Corso Architetto Software Ai è dove lo insegno, su codice vero e non su slide.

Chi comincia adesso, tra sei mesi guida il team. Chi comincia tra sei mesi, guarda.

Cursor più Claude Code, oppure Copilot più Claude Code: i due setup che reggono

I due setup che reggono nel tempo si distinguono per un dettaglio solo: cosa tieni aperto nell'ambiente. Cursor se stai in VS Code, Copilot se stai in Visual Studio. Claude Code nel terminale è la costante di entrambi.

Chi ottiene i risultati migliori ha deciso in anticipo quale lavoro va dove, e poi ha smesso di pensarci.

Il primo: Cursor nell'ambiente, Claude Code per l'architettura

È la combinazione più diffusa tra chi lavora su progetti .NET complessi nel 2026.

Cursor copre la giornata: completamento, chat sul codice, lavori su più file di media complessità.

Claude Code entra quando serve capire tutto il sistema insieme.

La divisione concreta: Cursor per implementare nuove funzionalità su componenti che esistono già, per scrivere test avendo sotto gli occhi l'implementazione, per ragionare sul codice mentre cerchi un bug, e per il refactoring fino a dieci o quindici file.

Claude Code per i sistemi legacy senza documentazione, per pianificare migrazioni architetturali, per esempio da monolite a moduli separati, per i test end-to-end che richiedono capire il dominio, e per rivedere pull request complicate.

Il secondo: Copilot nell'ambiente, Claude Code per l'architettura

Se vuoi restare in VS Code senza cambiare ambiente, questa combinazione funziona altrettanto bene.

Costa di più sulla carta, dieci euro di Copilot più cento di Claude Max, ma tieni un ambiente più leggero e non rinunci a nessuna delle estensioni che usi da anni.

Il vantaggio pratico è che la tua giornata non cambia di una virgola: la configurazione che hai passato anni a sistemare resta dov'è.

Si aggiunge solo un terminale di fianco per le sessioni che lo meritano.

Chi vive nel terminale

Una minoranza consistente di senior, soprattutto chi sta sul backend e sull'infrastruttura, usa Claude Code come strumento principale e apre l'ambiente di sviluppo quasi solo per navigare il codice e usare il debugger.

Funziona, ma richiede di essere davvero a proprio agio con il terminale e con il descrivere a parole cosa vuoi ottenere.

La giornata tipo inizia nel terminale. Descrivi l'obiettivo, per esempio “aggiungi il supporto multi-tenant al servizio di autenticazione”.

Claude Code legge il codice, ti fa le domande che gli mancano, propone un piano e comincia, chiedendo conferma quando la modifica è seria.

Tu supervisioni, poi apri l'ambiente per rivedere e fare il commit.

Portare qualcuno dentro senza bruciarlo

Qui succede il disastro più comune, e non è colpa di chi arriva.

Dai accesso a Cursor o Claude Code a una persona nuova senza spiegarle niente, e quella li userà in superficie: domande generiche, nessun contesto, e l'aspettativa di ricevere la risposta perfetta al primo colpo.

I risultati deludono, la conclusione è “non vale i soldi”, e lo strumento finisce nel cassetto per un anno.

Un percorso che funziona sta in tre settimane.

La prima solo completamento mentre scrivi, niente modalità Agent e niente chat complesse: l'obiettivo è prendere il ritmo senza perdere il controllo di quello che finisce nel file.

La seconda si aggiunge la chat sul file aperto per le domande sul codice, il debug assistito, la spiegazione degli schemi che non conosci.

La terza si passa a compiti completi in modalità Agent su feature contenute, con revisione sistematica prima di ogni commit.

I tempi veri, perché tanto li scopriresti da solo: due o quattro settimane di uso regolare per essere produttivo con la modalità Agent di Cursor.

Quattro o sei per Claude Code sui lavori architetturali, perché lì devi anche imparare a descrivere i compiti in modo che siano pianificabili.

È una competenza, e come tutte le competenze si può imparare da soli sbattendo la testa, oppure con qualcuno che ti dice dove stai sbagliando mentre lo fai.

Tre regole che i team migliori hanno pagato per imparare

Mai fare commit di codice generato senza averlo letto e capito.

Quello che esce è un punto di partenza, non un prodotto finito, e la revisione del codice assistito va fatta con più attenzione, non con meno.

Scrivi le istruzioni di progetto. Cursor legge .cursorrules nella radice, oggi rinominato .cursor/rules; Claude Code legge CLAUDE.md.

Dentro ci vanno le convenzioni, gli schemi architetturali che avete scelto, le librerie che preferite, le regole di nomenclatura.

Senza quel file lo strumento produce codice generico, e tu passi il tempo a correggere uno stile che non è il vostro.

Tieni separate le sessioni con l'agente dal lavoro normale. Non stare tutto il giorno con Claude Code aperto: usalo in blocchi da trenta a novanta minuti, su obiettivi definiti.

Il valore esce quando sai dove stai andando, non quando esplori. Nessuno di questi strumenti ti rende un ingegnere migliore.

Ti rende più veloce a essere quello che sei già.

Se quello che sei già è solido, ti moltiplicano il lavoro che chiudi in una settimana.

Se non lo è, la velocità peggiora soltanto la traiettoria, e lo si vede prima di quanto pensi.

C'è chi passa gli anni a inseguire lo strumento nuovo, e c'è chi costruisce il mestiere sotto e poi sceglie gli strumenti con calma.

Decidi tu da che parte stare, ma decidilo adesso.