03 - Agent Mode: Modificare la Codebase con un Comando
Immagina di poter dire al tuo IDE: "Aggiungi l'autenticazione JWT a questa applicazione Angular" e osservare mentre l'editor crea i file, scrive i servizi, aggiorna i componenti, esegue i test e corregge gli errori da solo, senza che tu debba toccare una singola riga di codice. Questo non e fantascienza: e Agent Mode di Cursor, una delle feature più trasformative nell'ecosistema degli AI-native IDE del 2025.
A differenza del semplice autocompletamento o della chat testuale con l'AI, Agent Mode porta l'intelligenza artificiale a un livello completamente nuovo: l'agente ha accesso al file system, può eseguire comandi nel terminale, leggere l'output degli errori, e iterare autonomamente fino a quando il task non e completato correttamente. E come avere un developer senior che lavora in parallelo con te, capace di gestire task complessi su più file con una comprensione profonda del contesto del progetto.
In questo articolo esploreremo Agent Mode in ogni suo aspetto: dall'architettura interna alle capacità pratiche, dai casi d'uso reali alle strategie avanzate per massimizzare la produttività. Vedremo come integrarlo con il sistema di Cursor Rules, come gestire i suoi limiti, e come si confronta con i competitor come GitHub Copilot Agent e Claude Code.
Cosa Imparerai in Questo Articolo
- L'architettura di Agent Mode: come LLM + tool use + file system access lavorano insieme
- La differenza tra Ask Mode, Edit Mode e Agent Mode e quando usare ciascuno
- Come attivare e configurare Agent Mode con i modelli giusti
- Le capacità complete dell'agente: file creation, multi-file editing, terminal, web search
- Casi d'uso pratici con esempi di codice Angular completi
- Come le Cursor Rules amplificano l'efficacia dell'agente
- Limiti, workaround e modalità avanzate come YOLO Mode e Max Mode
- Confronto con GitHub Copilot Agent e Claude Code
- Best practices per prompt efficaci e workflow professionali
Panoramica della Serie Cursor IDE e AI-Native Development
| # | Articolo | Focus |
|---|---|---|
| 1 | Guida Completa Cursor IDE | Panoramica completa |
| 2 | Cursor Rules | Configurazione AI personalizzata |
| 3 | Sei qui - Agent Mode | Automazione avanzata multi-file |
| 4 | Plan Mode e Background Agents | Pianificazione e parallelismo |
| 5 | Cursor Hooks | Automazione del workflow |
| 6 | MCP e Cursor | Integrazioni database e API |
| 7 | Debugging con Cursor AI | Debug 3x più veloce |
| 8 | Cursor vs Windsurf vs Copilot | Confronto strumenti 2026 |
| 9 | Workflow Angular Professionale | Progetto completo con Cursor |
L'Architettura di Agent Mode: Come Funziona Davvero
Per usare Agent Mode in modo efficace, e fondamentale capire cosa succede sotto il cofano. Agent Mode non e semplicemente "l'AI che scrive più codice": e un sistema multi-componente dove un Large Language Model viene dotato di strumenti concreti per interagire con l'ambiente di sviluppo.
Il Modello di Tool Use
Il cuore di Agent Mode e il concetto di tool use (o function calling). Il modello LLM alla base di Cursor — che sia Claude Sonnet, GPT-4o, o Gemini — non genera solo testo: viene addestrato a riconoscere quando deve usare uno strumento esterno per completare un task. Invece di "inventare" il contenuto di un file, l'agente può effettivamente leggere quel file. Invece di immaginare l'output di un comando, può eseguirlo e leggerne il risultato.
Gli strumenti disponibili per l'agente di Cursor includono:
- read_file: Legge il contenuto di un file specifico
- write_file: Crea o sovrascrive un file con nuovo contenuto
- edit_file: Applica modifiche specifiche a porzioni di un file
- list_directory: Elenca i file in una directory
- search_files: Cerca pattern testuali o semantici nella codebase
- run_terminal_command: Esegue comandi nel terminale integrato
- read_terminal_output: Legge l'output del terminale (inclusi errori)
- web_search: Cerca informazioni aggiornate sul web
- create_subagent: Crea agenti specializzati per task specifici (Cursor 2.0+)
Il Loop Agentico
Agent Mode lavora attraverso un ciclo di ragionamento iterativo:
- Osserva: Legge il contesto (file, struttura del progetto, errori esistenti)
- Pianifica: Determina i passi necessari per completare il task
- Agisce: Usa i tool disponibili (crea file, esegue comandi, etc.)
- Valuta: Legge gli output, verifica errori, controlla il risultato
- Itera: Se ci sono errori, torna al passo 1 con le nuove informazioni
Questo loop continua autonomamente fino a quando il task e completato o l'agente determina che ha bisogno di input dall'utente.
Context Gathering: Come l'Agente Capisce il Progetto
Prima di scrivere una sola riga di codice, Agent Mode effettua un'analisi approfondita del contesto. Cursor indicizza la codebase usando embeddings semantici, permettendo all'agente di trovare file e pattern rilevanti anche quando non sono esplicitamente menzionati nel prompt. Questo e fondamentalmente diverso da un semplice grep: l'agente capisce le relazioni concettuali tra le diverse parti del codice.
Ad esempio, se chiedi all'agente di "aggiungere validazione al form di login", sa automaticamente di dover guardare il componente di login, il form reactive, i validatori esistenti, i modelli TypeScript e potenzialmente i test unitari associati — tutto senza che tu debba specificarlo.
Ask Mode, Edit Mode e Agent Mode: le Differenze Fondamentali
Cursor offre tre modalità principali di interazione con l'AI, ognuna ottimizzata per scenari diversi. Capire quando usare ciascuna e fondamentale per massimizzare la produttività.
Ask Mode: La Conversazione
Ask Mode (accessibile con Ctrl+L / Cmd+L) e la modalità conversazionale
di Cursor. In questa modalità, l'AI risponde alle tue domande con spiegazioni, suggerimenti
e frammenti di codice, ma non modifica direttamente i file. E la modalità ideale per:
- Capire porzioni di codice complesse o legacy
- Esplorare alternative architetturali prima di implementare
- Fare domande su librerie, API o pattern specifici
- Fare code review e ricevere feedback sul codice esistente
- Brainstorming su design e struttura del progetto
Edit Mode: L'Editing Contestuale
Edit Mode (accessibile con Ctrl+K / Cmd+K) permette modifiche
contestuali e mirate. L'AI agisce sul file corrente o su una selezione specifica, applicando
trasformazioni localizzate. E ideale per:
- Refactoring di una singola funzione o classe
- Trasformazioni di codice (es. convertire una funzione in async/await)
- Aggiungere documentazione JSDoc a metodi esistenti
- Correggere un bug specifico nel file corrente
- Quick fixes suggeriti dall'IDE
Agent Mode: L'Automazione Completa
Agent Mode (accessibile con Ctrl+I / Cmd+I, selezionando "Agent" dalla
dropdown) e la modalità più potente. L'agente può lavorare attraverso molteplici file,
eseguire comandi, iterare sugli errori e completare task complessi in modo autonomo. E
la modalità giusta per:
- Implementare feature complete che coinvolgono più file
- Refactoring su scala di codebase (es. migrare da CommonJS a ES modules)
- Setup iniziale di progetti con scaffolding completo
- Bug fixing che richiede analisi cross-file
- Aggiungere test a componenti esistenti
- Migrazioni tecnologiche (es. da RxJS 6 a RxJS 7)
DOMANDA: "Cosa fa questo operatore RxJS?"
→ Usa Ask Mode (informazione, nessuna modifica)
TASK: "Converti questa funzione callback in una Promise"
→ Usa Edit Mode (modifica localizzata, file singolo)
TASK: "Aggiungi autenticazione JWT all'intera applicazione"
→ Usa Agent Mode (multi-file, comandi, iterazione)
TASK: "Scrivi i test per questo componente"
→ Usa Agent Mode (crea file di test, esegue test, corregge errori)
TASK: "Spiega l'architettura del progetto"
→ Usa Ask Mode (analisi, nessuna modifica)
TASK: "Aggiungi validazione al form e aggiorna i tipi TypeScript"
→ Usa Agent Mode (modifica più file correlati)
Attivare e Configurare Agent Mode
Aprire la Chat e Selezionare Agent Mode
Agent Mode si attiva attraverso la Composer window di Cursor. Ecco i passi:
- Premi
Ctrl+I(Windows/Linux) oCmd+I(macOS) per aprire il Composer - Nella dropdown in alto a sinistra della chat, seleziona "Agent"
- In alternativa, in una chat esistente, clicca sulla modalità corrente e seleziona "Agent"
Puoi anche impostare Agent Mode come default nelle impostazioni di Cursor:
Settings > Features > Chat > Default Mode.
Scegliere il Modello Giusto
Agent Mode supporta diversi modelli LLM, ognuno con caratteristiche diverse. La scelta del modello influenza significativamente la qualità dei risultati:
CLAUDE SONNET 4.5 / CLAUDE OPUS 4
- Miglior comprensione del contesto complesso
- Eccellente per refactoring e architettura
- Ragionamento più approfondito
- Consigliato per: task complessi, codebase grandi
GPT-4O
- Ottimo bilanciamento velocità/qualità
- Buona gestione del contesto lungo
- Consigliato per: task medi, iterazioni rapide
GEMINI 2.0 FLASH
- Molto veloce
- Context window molto grande (1M token)
- Consigliato per: task con molti file, analisi di grandi codebase
CURSOR FAST (modello proprietario)
- Ottimizzato per velocità
- Consigliato per: completamenti rapidi, suggerimenti inline
YOLO Mode: Esecuzione Automatica dei Comandi
Per default, Agent Mode chiede conferma prima di eseguire ogni comando nel terminale. YOLO Mode rimuove questa richiesta di conferma, permettendo all'agente di eseguire comandi autonomamente. Per attivarlo:
Settings > Features > Chat & Composer > Allow agent to run commands automatically
Attenzione con YOLO Mode
YOLO Mode e potente ma richiede cautela. Configura sempre i comandi permessi
specificando una allowlist (es. npm test, ng build) e una denylist
(es. rm -rf, git push). Non attivare YOLO Mode in ambienti di
produzione o su repository con dati sensibili senza aver configurato correttamente i limiti.
Max Mode: Contesto Esteso
Introdotto con gli aggiornamenti recenti, Max Mode rimuove le limitazioni aggressive di context pruning di Cursor. Mentre nella modalità standard l'agente riduce il contesto per migliorare la velocità di risposta, Max Mode usa il contesto completo disponibile dal modello. Questo si traduce in risultati significativamente migliori per:
- Codebase grandi con molte dipendenze cross-file
- Bug complessi che richiedono comprensione di più layer applicativi
- Refactoring che deve rispettare pattern architetturali distribuiti nel progetto
Le capacità Complete dell'Agente
Creazione e Modifica di File
L'agente può creare nuovi file e modificare quelli esistenti con piena consapevolezza della struttura del progetto. Non si limita a generare codice in isolamento: legge i file esistenti, ne comprende i pattern, e genera nuovo codice coerente con lo stile e le convenzioni del progetto.
Prompt all'agente:
"Crea un sistema di notifiche in stile toast per questa applicazione Angular.
Deve includere:
- NotificationService con metodi success(), error(), warning(), info()
- NotificationComponent standalone con animazioni CSS
- Integrazione nel AppComponent
- Modello NotificationMessage con tipo, messaggio e durata
- Test unitari per il servizio
Usa standalone components, signals per lo state, e rispetta
le convenzioni Angular del progetto (OnPush, async pipe, ecc.)"
Con questo singolo prompt, Agent Mode tipicamente crea o modifica:
src/app/core/models/notification.model.ts(nuovo)src/app/core/services/notification.service.ts(nuovo)src/app/shared/components/notification/notification.component.ts(nuovo)src/app/shared/components/notification/notification.component.html(nuovo)src/app/shared/components/notification/notification.component.css(nuovo)src/app/app.component.ts(modificato per includere il componente)src/app/app.component.html(modificato per aggiungere il tag del componente)src/app/core/services/notification.service.spec.ts(nuovo)
Esecuzione di Comandi Terminale
Agent Mode può eseguire comandi nel terminale integrato di Cursor e leggerne l'output. Questo gli permette di:
- Installare dipendenze con
npm install - Eseguire la build e leggere gli errori TypeScript
- Eseguire i test e iterare fino a quando passano
- Eseguire linter e formatter automaticamente
- Usare Angular CLI per generare scaffolding
- Eseguire script personalizzati del progetto
Ricerca Web in Tempo Reale
Una capacità spesso sottovalutata e la possibilità di cercare informazioni sul web durante l'esecuzione di un task. L'agente può consultare la documentazione ufficiale, cercare soluzioni a errori specifici, o verificare la sintassi corretta di API aggiornate. Questo e particolarmente utile quando si lavora con librerie che aggiornano spesso le proprie API, come Angular, RxJS o le librerie del Material Design.
Analisi degli Errori e Auto-Correzione
Una delle caratteristiche più potenti di Agent Mode e la capacità di auto-correggersi. Dopo aver generato codice, l'agente esegue la build (se YOLO Mode e attivo o se l'utente approva), legge gli errori TypeScript o del linter, e itera modificando il codice fino a quando non ci sono più errori. Questo loop di feedback riduce drasticamente il tempo necessario per portare a zero gli errori di build.
Casi d'Uso Pratici con Angular
Caso 1: Aggiungere una Feature Completa (Component + Service + Test)
Il caso d'uso più comune per Agent Mode e l'implementazione di nuove feature. Vediamo un esempio concreto: aggiungere un sistema di paginazione a una lista Angular.
Implementa un sistema di paginazione per il componente UserListComponent.
Requisiti tecnici:
- Crea PaginationComponent standalone con signal-based state
- PaginationService per la logica di business (calcolo pagine, navigazione)
- UserListComponent deve accettare input() per totalItems e pageSize
- Emetti output() pageChange con il numero di pagina corrente
- Usa HttpClient per caricare i dati paginati dall'endpoint /api/users?page=&size=
- Gestisci loading state e error state con NgOptimizedImage per avatars
- Aggiungi ARIA labels per accessibility
- Test unitari per PaginationService (min 80% coverage)
- Test di integrazione per UserListComponent
Struttura file attesa:
- src/app/shared/components/pagination/pagination.component.ts
- src/app/shared/components/pagination/pagination.component.html
- src/app/shared/components/pagination/pagination.component.css
- src/app/core/services/pagination.service.ts
- src/app/features/users/user-list.component.ts (aggiorna)
Ecco il codice che l'agente tipicamente genera per il PaginationService:
import { Injectable, signal, computed } from '@angular/core';
export interface PaginationState {
currentPage: number;
pageSize: number;
totalItems: number;
}
@Injectable({
providedIn: 'root'
})
export class PaginationService {
private readonly _state = signal<PaginationState>({
currentPage: 1,
pageSize: 10,
totalItems: 0
});
readonly state = this._state.asReadonly();
readonly totalPages = computed(() =>
Math.ceil(this._state().totalItems / this._state().pageSize)
);
readonly hasPreviousPage = computed(() =>
this._state().currentPage > 1
);
readonly hasNextPage = computed(() =>
this._state().currentPage < this.totalPages()
);
readonly pageNumbers = computed(() => {
const total = this.totalPages();
const current = this._state().currentPage;
const range = 2;
const start = Math.max(1, current - range);
const end = Math.min(total, current + range);
return Array.from({ length: end - start + 1 }, (_, i) => start + i);
});
updateState(partial: Partial<PaginationState>): void {
this._state.update(state => ({ ...state, ...partial }));
}
goToPage(page: number): void {
const total = this.totalPages();
if (page >= 1 && page <= total) {
this._state.update(state => ({ ...state, currentPage: page }));
}
}
nextPage(): void {
if (this.hasNextPage()) {
this.goToPage(this._state().currentPage + 1);
}
}
previousPage(): void {
if (this.hasPreviousPage()) {
this.goToPage(this._state().currentPage - 1);
}
}
}
import {
Component, OnInit, input, output, inject, OnChanges, SimpleChanges
} from '@angular/core';
import { CommonModule } from '@angular/common';
import { PaginationService } from '@core/services/pagination.service';
@Component({
selector: 'app-pagination',
standalone: true,
imports: [CommonModule],
templateUrl: './pagination.component.html',
styleUrl: './pagination.component.css',
changeDetection: ChangeDetectionStrategy.OnPush
})
export class PaginationComponent implements OnChanges {
readonly totalItems = input.required<number>();
readonly pageSize = input<number>(10);
readonly pageChange = output<number>();
private readonly paginationService = inject(PaginationService);
readonly state = this.paginationService.state;
readonly totalPages = this.paginationService.totalPages;
readonly hasPrev = this.paginationService.hasPreviousPage;
readonly hasNext = this.paginationService.hasNextPage;
readonly pageNumbers = this.paginationService.pageNumbers;
ngOnChanges(changes: SimpleChanges): void {
if (changes['totalItems'] || changes['pageSize']) {
this.paginationService.updateState({
totalItems: this.totalItems(),
pageSize: this.pageSize()
});
}
}
onPageChange(page: number): void {
this.paginationService.goToPage(page);
this.pageChange.emit(page);
}
onPrevious(): void {
this.paginationService.previousPage();
this.pageChange.emit(this.paginationService.state().currentPage);
}
onNext(): void {
this.paginationService.nextPage();
this.pageChange.emit(this.paginationService.state().currentPage);
}
}
Caso 2: Refactoring Cross-File
Uno dei punti di forza più evidenti di Agent Mode e il refactoring che attraversa più file.
Considera questo scenario: devi migrare tutti i componenti di un progetto Angular da
ngModel a Reactive Forms.
Migra tutti i form dell'applicazione da Template-Driven Forms a Reactive Forms.
Analizza tutti i file in src/app/ e:
1. Identifica tutti i componenti che usano ngModel o [(ngModel)]
2. Per ogni componente trovato:
- Sostituisci ngModel con FormControl/FormGroup
- Aggiungi ReactiveFormsModule agli imports del componente
- Rimuovi FormsModule se non necessario
- Aggiorna la validazione inline con Validators
- Mantieni la stessa logica di submit
3. Aggiorna i test esistenti per usare ReactiveFormsModule
4. Verifica che la build passi dopo ogni modifica
Mantieni la retrocompatibilita dell'interfaccia utente.
Non modificare i servizi HTTP o la logica di business.
Caso 3: Bug Fixing con Context Awareness
Agent Mode eccelle nel bug fixing perchè non si limita al file dove appare l'errore: comprende le relazioni tra componenti e servizi per trovare la vera causa radice.
Ho un bug nell'applicazione: quando navigo a /users/123/settings e poi
torno indietro con il browser, il componente UserSettingsComponent
mostra i dati dell'utente precedente invece di ricaricarli.
L'errore sembra legato alla gestione del route params in combinazione
con il caching del servizio. L'errore si manifesta SOLO dopo la
prima navigazione - il refresh della pagina funziona correttamente.
Analizza:
- UserSettingsComponent e come gestisce ngOnInit/ActivatedRoute
- UserService e la sua strategia di caching
- Il routing configuration per questo modulo
- Eventuali Observable che potrebbero non essere ri-subscribed
Proponi e implementa la fix con relative spiegazioni.
In questo scenario, Agent Mode tipicamente:
- Legge
user-settings.component.tse identifica che usangOnInitinvece dingOnChangesotakeUntilDestroyed - Legge
user.service.tse trova che l'Observable viene completato e non ri-emette dopo la subscription - Legge
app.routes.tso il routing module per capire se il componente viene ricreato o riutilizzato - Propone la fix: usare
ActivatedRoute.paramMapcon un Observable invece disnapshot - Implementa la fix in tutti i file coinvolti
- Esegue il linter per verificare la correttezza del codice modificato
Agent Mode e Cursor Rules: Sinergia Potente
Agent Mode diventa esponenzialmente più potente quando combinato con il sistema di Cursor Rules. Le Rules fungono da "istruzioni di sistema" che guidano l'agente su come deve operare all'interno del tuo specifico progetto. Senza Rules, l'agente genera codice generico che potrebbe non rispettare le convenzioni del team. Con Rules ben configurate, il codice generato e indistinguibile da quello scritto da un developer esperto del progetto.
Come le Rules Influenzano Agent Mode
Le Rules di tipo Always vengono iniettate all'inizio di ogni sessione
dell'agente, fornendo contesto costante. Le Rules Agent Requested vengono
caricate dinamicamente quando l'agente determina che sono rilevanti per il task corrente.
Questo permette di avere regole specializzate per diversi aspetti del progetto senza
gonfiare inutilmente il context window.
Vediamo un esempio completo di configurazione Rules per un progetto Angular con Agent Mode.
Nella nuova struttura di Cursor (post 0.45), le rules vanno nella directory
.cursor/rules/ come file .mdc:
---
description: Regole fondamentali per lo sviluppo Angular in questo progetto
globs: ["src/**/*.ts", "src/**/*.html"]
alwaysApply: true
---
# Regole Angular - Sempre Attive
## Framework e Versione
- Progetto Angular 19+ con standalone components (NO NgModules)
- TypeScript strict mode abilitato
- RxJS 7.8+ (evita operatori deprecated)
## Component Guidelines
- SEMPRE OnPush change detection
- SEMPRE standalone: true
- USA signals (signal(), computed(), effect()) per lo stato locale
- USA input() e output() invece di @Input/@Output decorators
- EVITA constructor injection, usa inject()
- USA takeUntilDestroyed() per gestire le subscription
## Service Guidelines
- providedIn: 'root' per servizi globali
- USA HttpClient con typed responses HttpClient.get<T>()
- Gestisci SEMPRE gli errori con catchError
- Usa interceptors per auth headers, non logica nei servizi
## File Naming
- Components: kebab-case, es. user-profile.component.ts
- Services: kebab-case con .service.ts suffix
- Models: kebab-case con .model.ts suffix
- Separati file HTML e CSS (non inline templates/styles)
## Testing
- Usa jasmine + karma (non jest, non vitest)
- Minimo 80% coverage per i servizi
- Usa TestBed per i component tests
- Mock i servizi HTTP con HttpClientTestingModule
---
description: Pattern avanzati per Agent Mode in questo progetto Angular
globs: ["src/app/**/*.ts"]
alwaysApply: false
---
# Pattern Architetturali del Progetto
## Struttura Directory
```
src/app/
├── core/ # Servizi singleton, guards, interceptors
├── shared/ # Componenti e pipe riusabili
├── features/ # Feature modules (lazy loaded)
│ ├── auth/
│ ├── users/
│ └── dashboard/
└── models/ # Interfacce TypeScript condivise
```
## State Management
- Usa signals per state locale ai componenti
- Usa servizi con BehaviorSubject/signal per state condiviso
- NO NgRx a meno che non sia già nel progetto
## HTTP Patterns
```typescript
// PATTERN CORRETTO per le chiamate HTTP
getData(): Observable<User[]> {
return this.http.get<User[]>('/api/users').pipe(
catchError(err => {
console.error('Failed to fetch users:', err);
return throwError(() => new Error('Failed to fetch users'));
})
);
}
```
## Routing
- Usa lazy loading per tutte le feature routes
- Guards come funzioni arrow (functional guards), non classi
- Usa withComponentInputBinding() per route params come inputs
## Quando l'Agent crea un nuovo componente:
1. Verifica se esiste già un componente simile in shared/
2. Aggiungi SEMPRE all'export di un barrel file (index.ts)
3. Aggiorna il routing se il componente e una pagina
4. Genera il file di test corrispondente
---
description: Convenzioni per commit messages e PR
alwaysApply: false
---
# Commit Conventions
## Formato
<type>(<scope>): <description>
Types: feat, fix, refactor, test, docs, chore, perf
## Esempi
feat(auth): add JWT refresh token support
fix(users): resolve pagination state after navigation
refactor(shared): migrate to signal-based pagination
test(notification): add unit tests for NotificationService
## Prima di completare un task
- Verifica che non ci siano console.log rimanenti
- Controlla che tutti i TODO siano risolti o documentati
- Esegui ng build --configuration=production prima del commit
Con questa configurazione di Rules, quando l'agente riceve un prompt come "Crea un componente per la lista degli ordini", generer automaticamente:
- Un componente standalone con OnPush change detection
- Signals per lo state locale
- input()/output() invece di decoratori
- inject() per la dependency injection
- takeUntilDestroyed() per le subscription
- Il file di test corrispondente
- L'aggiornamento del barrel file
Tutto questo automaticamente, senza che tu debba specificarlo nel prompt.
Limiti di Agent Mode e Come Superarli
Context Window e File Grandi
Il limite più comune di Agent Mode e il context window. Quando la codebase e molto grande, l'agente potrebbe non avere spazio sufficiente per caricare tutti i file rilevanti contemporaneamente. Questo può portare a modifiche inconsistenti o alla perdita di contesto tra diverse parti del task.
Strategie per Gestire il Context Window
- Suddividi i task grandi: Invece di un unico prompt mega-task, spezza il lavoro in step logici. Completa e verifica ogni step prima di passare al successivo.
-
Usa @file per context esplicito: Indica esplicitamente i file rilevanti
con
@nomefilenel prompt per aiutare l'agente a prioritizzare il contesto. - Attiva Max Mode: Per task complessi che richiedono molto contesto, Max Mode riduce il pruning aggressivo e migliora la qualità dei risultati.
-
Crea documenti di contesto: Per progetti molto grandi, crea file
ARCHITECTURE.mdoCONTEXT.mdche riassumono la struttura del progetto. L'agente può leggerli all'inizio del task.
Azioni Potenzialmente Distruttive
Agent Mode può modificare o eliminare file critici se non viene guidato correttamente. Alcune misure preventive fondamentali:
-
Commit prima di delegare all'agente: Fai sempre un commit o uno stash
dei tuoi cambiamenti prima di lanciare Agent Mode su task significativi. Questo ti permette
di tornare allo stato precedente con un semplice
git checkout. - Usa le Rules per definire file protetti: Aggiungi una rule che indica all'agente i file che non deve mai modificare (es. file di configurazione critici, file di migrazione del database).
- Revisiona prima di applicare: Cursor mostra sempre un diff delle modifiche proposte prima di applicarle. Prenditi il tempo di rivedere, specialmente per file critici come configurazioni o schema del database.
Errori di Ragionamento e Allucinazioni
Come qualsiasi sistema AI, Agent Mode può commettere errori. Può "allucinare" API inesistenti, usare versioni obsolete di librerie, o misinterpretare requisiti ambigui. Le contromisure:
- Prompt specifici: Quanto più specifico e il tuo prompt, tanto minore e il margine per interpretazioni errate. Includi versioni delle librerie, pattern preferiti, e vincoli espliciti.
- Abilita web search: Permettere all'agente di consultare la documentazione aggiornata riduce significativamente il rischio di usare API obsolete.
- Verifica l'output: Non applicare mai le modifiche senza averle riviste. Questo e particolarmente importante per logica di business critica o codice di sicurezza.
Non Delegare Codice di Sicurezza all'Agente Senza Review
Autenticazione, autorizzazione, crittografia, e gestione dei segreti sono aree dove l'AI può produrre codice funzionalmente corretto ma con vulnerabilità di sicurezza sottili. Rivedi sempre attentamente il codice di sicurezza generato dall'agente e, se possibile, fallo revisionare da un security expert.
Agent Mode vs GitHub Copilot Agent vs Claude Code
Il panorama degli AI agent per lo sviluppo software nel 2025-2026 e competitivo. Vediamo come Agent Mode di Cursor si confronta con le alternative principali.
capacità CURSOR AGENT COPILOT AGENT CLAUDE CODE
─────────────────────────────────────────────────────────────────────
Agenti paralleli 8 (con worktrees) 1 1 (task)
File system access Si Si Si
Terminal execution Si (YOLO Mode) Limitato Si (bash)
Web search Si No Si
Codebase indexing Si (semantico) Si No (manuale)
Multi-repo support Si (worktrees) No Parziale
Context window 200K+ (Max Mode) 128K 200K (Claude 3.5)
Background agents Si No No
Cursor Rules integration Si (nativa) No CLAUDE.md
MCP support Si (nativa) Limitato Si
Prezzo $20/mese (Pro) $10/mese API usage
IDE integration Editor dedicato VS Code plugin CLI/API
Controllo sul modello Si (scelta LLM) Limitato Si (Claude)
─────────────────────────────────────────────────────────────────────
Cursor Agent: Punti di Forza
Il vantaggio principale di Cursor e l'integrazione nativa tra IDE, agente, e sistema di Rules. L'agente ha accesso all'intera codebase indicizzata semanticamente, può modificare file direttamente nell'editor, eseguire comandi nel terminale integrato, e iterare su errori in un loop chiuso. La capacità di gestire fino a 8 agenti paralleli con git worktrees (introdotta in Cursor 2.0) permette di esplorare implementazioni alternative in parallelo.
GitHub Copilot Agent: Punti di Forza
Copilot Agent, integrato direttamente in GitHub Workflow, eccelle nella risoluzione autonoma di GitHub Issues. Può aprire PR direttamente, lavorare su task definiti in issues, e integrarsi nativamente con i processi di code review GitHub. Per team che lavorano già nell'ecosistema GitHub, questo workflow e molto fluido.
Claude Code: Punti di Forza
Claude Code (lo strumento da CLI di Anthropic, distinto dall'accesso a Claude via API) brilla per la sua flessibilità e il profondo ragionamento su task complessi. Funziona bene per task di lunga durata, analisi architetturali, e situazioni dove serve massima qualità del ragionamento piuttosto che velocità di esecuzione. Può essere integrato in qualsiasi IDE tramite terminale.
Quando Scegliere Cosa
- Cursor Agent: Sviluppo quotidiano, feature implementation, refactoring, debug. La scelta migliore per chi vuole un'esperienza integrata nell'IDE.
- Copilot Agent: Team GitHub-centric, risoluzione Issues automatizzata, workflow PR. Ideale come complemento a Cursor per il layer GitHub.
- Claude Code: Task ad alto ragionamento, analisi architetturali, script automation, ambienti dove non si può cambiare IDE.
Best Practices per Agent Mode
1. L'Arte del Prompt Efficace
La qualità dell'output di Agent Mode e direttamente proporzionale alla qualità del prompt. Un prompt vago produce codice generico; un prompt specifico produce codice che sembra scritto da qualcuno che conosce il progetto a fondo.
STRUTTURA RACCOMANDATA:
[CONTESTO]
Sto lavorando su un'applicazione Angular 19 per la gestione delle risorse
umane. Il componente EmployeeListComponent attualmente mostra solo una
lista statica.
[TASK SPECIFICO]
Aggiungi funzionalità di ricerca e filtraggio alla lista dipendenti.
[REQUISITI TECNICI]
- Ricerca in tempo reale con debounce di 300ms (usa debounceTime da RxJS)
- Filtri multipli: dipartimento (select), stato (active/inactive), ruolo
- I filtri devono essere combinabili (AND logic)
- Lo stato dei filtri deve persistere nella URL come query params
- Usa signals per lo state locale, ActivatedRoute per sync con URL
[VINCOLI E LIMITAZIONI]
- Non modificare EmployeeService (ha i suoi test)
- Mantieni la compatibilità con il componente di paginazione esistente
- Non aggiungere nuove dipendenze npm
[OUTPUT ATTESO]
- Aggiorna EmployeeListComponent
- Crea EmployeeFilterComponent se necessario
- Aggiorna i test di EmployeeListComponent
---
ESEMPIO DI PROMPT INEFFICACE (da evitare):
"Aggiungi ricerca alla lista"
2. Usa Checkpoint Git Frequenti
Prima di ogni sessione di Agent Mode su task significativi, crea un checkpoint git:
# Prima di lanciare Agent Mode su un task significativo
git add -A
git commit -m "chore: checkpoint prima di agent mode - feature X"
# Oppure, per un branch temporaneo di backup
git stash push -m "backup prima di agent mode"
# Dopo che l'agente ha completato
# Rivedi le modifiche
git diff HEAD
# Se soddisfatto, committa
git add -A
git commit -m "feat(users): add pagination via agent mode"
# Se qualcosa e andato storto
git checkout . # Annulla tutte le modifiche non committate
# Oppure
git stash pop # Ripristina lo stash
3. Revisiona Prima di Applicare
Cursor mostra sempre un diff delle modifiche proposte dall'agente. Prenditi sempre il tempo di rivedere queste modifiche, specialmente per:
- File di configurazione (angular.json, tsconfig.json, package.json)
- Codice di autenticazione e autorizzazione
- File di migrazione del database
- Logica di business critica
- Variabili d'ambiente e configurazioni sensibili
4. Itera e Affina il Task
Non aspettarti che Agent Mode completi task complessi con un singolo prompt perfetto. Il workflow più produttivo e iterativo:
ITERAZIONE 1: Implementazione base
Prompt: "Crea il NotificationService base con metodi success/error"
→ Rivedi, approva, committa
ITERAZIONE 2: Aggiunta feature
Prompt: "Aggiungi al NotificationService il supporto per notifiche
persistenti (che non si chiudono automaticamente) e per
la gestione della coda (max 3 notifiche visibili)"
→ Rivedi, approva, committa
ITERAZIONE 3: Test e fix
Prompt: "Scrivi i test unitari per NotificationService.
Verifica che ng test passi senza errori"
→ L'agente scrive i test, li esegue, corregge eventuali errori
→ Rivedi, approva, committa
ITERAZIONE 4: Integrazione
Prompt: "Integra NotificationService in AuthService per
mostrare una notifica di successo dopo il login
e una di errore in caso di credenziali invalide"
→ Rivedi, approva, committa
5. Configura Rules Specifiche per Agent
Come abbiamo visto nella sezione precedente, le Rules sono il moltiplicatore di produttività più potente per Agent Mode. Dedica tempo a costruire una buona base di Rules per il tuo progetto. Una buona regola empirica: ogni volta che correggi qualcosa che l'agente ha fatto "male" rispetto alle convenzioni del progetto, aggiungi quella correzione come Rule.
Workflow Professionale con Agent Mode
La Giornata Tipo di un Developer con Agent Mode
Vediamo come Agent Mode si integra nel workflow quotidiano di un developer Angular:
09:00 - PLANNING
- Apri il backlog, seleziona la task del giorno
- Usa Ask Mode per analizzare l'impatto della task sulla codebase
Prompt: "Analizza la codebase e dimmi quali file dovro modificare
per implementare [feature X]. Identifica dipendenze e rischi."
09:15 - CHECKPOINT GIT
git checkout -b feature/user-search
git add -A && git commit -m "chore: init feature branch"
09:20 - IMPLEMENTAZIONE CON AGENT MODE
- Attiva Agent Mode
- Usa il prompt strutturato (contesto + task + vincoli)
- Lascia lavorare l'agente (5-15 minuti per feature medie)
09:40 - REVIEW E RAFFINAMENTO
- Rivedi il diff generato file per file
- Accetta le modifiche corrette, rigetta quelle problematiche
- Per modifiche parzialmente corrette, usa Edit Mode per aggiustamenti
- Chiedi chiarimenti con Ask Mode se qualcosa non e chiaro
10:00 - TESTING
Prompt Agent Mode: "Esegui ng test e correggi tutti gli errori che
trovi. Assicurati che la coverage dei file modificati sia >= 80%"
10:20 - COMMIT E PR
git add -A
git commit -m "feat(users): add real-time search with URL sync"
git push origin feature/user-search
# Apri PR su GitHub
10:30 - PROSSIMA TASK
Pattern: Agent Mode per Code Review Assistita
Un uso meno ovvio ma molto efficace di Agent Mode e la code review assistita. Prima di fare una PR, chiedi all'agente di revisionare il tuo lavoro:
Fai una code review dei file che ho modificato in questo branch.
Analizza:
1. Conformità alle Angular best practices (standalone, signals, etc.)
2. Potenziali memory leaks (subscription non chiuse, reference cycles)
3. Performance (change detection, trackBy, pure pipes)
4. Security (XSS, injection, dati sensibili nei log)
5. qualità dei test (coverage, edge cases, mock appropriati)
6. Consistenza con le convenzioni del progetto
Per ogni problema trovato:
- Indica il file e la riga
- Spiega il problema
- Proponi la fix
Alla fine, dai un rating complessivo: Approved / Needs Changes / Major Issues
Integrazione con Plan Mode
Per task particolarmente complessi, combina Agent Mode con Plan Mode (che esploreremo nel prossimo articolo della serie). Plan Mode permette all'agente di creare prima un piano strutturato del lavoro, che puoi revisionare e approvare prima che l'esecuzione cominci. Questo e particolarmente utile per:
- Migrazioni di framework o librerie importanti
- Implementazioni di feature cross-cutting che tocca molti file
- Refactoring architetturali significativi
- Setup iniziale di nuovi progetti o moduli
Agent Mode in Cursor 2.0: Le Nuove Frontiere
Cursor 2.0, rilasciato a fine 2025, ha introdotto miglioramenti significativi a Agent Mode. Queste feature rappresentano il futuro dello sviluppo AI-native.
Parallel Agents con Git Worktrees
La feature più rivoluzionaria di Cursor 2.0 e la possibilità di eseguire fino a 8 agenti in parallelo, ognuno operante su un git worktree separato. Ogni agente lavora in isolamento, permettendo di esplorare implementazioni alternative contemporaneamente senza interferenze.
Immagina di dover scegliere tra tre approcci diversi per implementare una feature critica. Con gli agenti paralleli, puoi avviare tre agenti contemporaneamente, ognuno con un prompt diverso che specifica un approccio differente. Dopo 15-20 minuti, hai tre implementazioni complete da confrontare e scegliere la migliore.
Background Agents
I Background Agents di Cursor 2.0 permettono di delegare task a lungo termine che girano in background mentre continui a lavorare su altro. Puoi lanciare un agente per "aggiornare tutti i test del progetto per la nuova versione di Angular" e continuare a sviluppare features nel frattempo. L'agente ti notifica quando ha completato o quando ha bisogno di input.
Subagents Specializzati
Agent Mode ora supporta la creazione di subagenti specializzati. Un agente "orchestratore" può delegare parti specifiche del task a subagenti specializzati: uno per la scrittura dei test, uno per l'ottimizzazione delle performance, uno per la documentazione. I subagenti possono essere configurati con modelli, regole e tool access diversi dall'agente principale.
Conclusioni e Prossimi Passi
Agent Mode di Cursor rappresenta uno dei salti di produttività più significativi disponibili oggi per i developer. Non si tratta di "AI che scrive codice al posto tuo", ma di un collaboratore intelligente che accelera il tuo workflow, gestisce la complessità tecnica, e libera il tuo tempo per concentrarti su architettura, design e decisioni ad alto valore.
I punti chiave da ricordare:
- Agent Mode = LLM + Tool Use + Context: Non e magia, e un sistema ben progettato dove l'AI usa strumenti concreti per interagire con la codebase.
- La qualità del prompt determina la qualità dell'output: Prompt specifici, contestuali e con vincoli espliciti producono risultati significativamente migliori dei prompt vaghi.
- Cursor Rules sono il moltiplicatore di produttività: Una buona configurazione di Rules trasforma l'agente da "AI generica" a "developer esperto del tuo progetto specifico".
- Review sempre prima di applicare: Agent Mode e uno strumento potente ma non infallibile. La tua revisione critica e fondamentale, specialmente per codice di sicurezza e logica di business critica.
- Itera in piccoli step: Il workflow più efficace divide task complessi in step iterativi, con review e commit a ogni step.
Continua la Serie: Prossimo Articolo
Nel prossimo articolo della serie esploreremo Plan Mode e Background Agents: come usare la pianificazione strutturata per task complessi e come delegare lavoro agli agenti background di Cursor 2.0 per massimizzare la produttività. Se Agent Mode e il motore, Plan Mode e il volante.
Articoli Correlati della Serie
- Cursor Rules (articolo 2): Approfondisci la configurazione del sistema di Rules per amplificare Agent Mode nel tuo progetto specifico.
- Plan Mode e Background Agents (articolo 4): Il passo successivo per automatizzare task ancora più complessi con pianificazione strutturata.
- MCP e Cursor (articolo 6): Come collegare Agent Mode a database, API esterne e strumenti personalizzati tramite il Model Context Protocol.
- Workflow Angular Professionale (articolo 9): Un progetto Angular completo sviluppato interamente con Cursor Agent Mode, dalla creazione al deploy.