03 - Modul agent: Modificați baza de cod cu o comandă
Imaginați-vă că puteți spune IDE-ului dvs.: „Adăugați autentificare JWT la această aplicație Angular” și observați în timp ce editorul creează fișiere, scrie servicii, actualizează componente, execută teste și remediază erori pe cont propriu, fără a fi nevoie să atingeți o singură linie de cod. Aceasta nu este science fiction: e Modul agent de Cursor, una dintre cele mai transformatoare caracteristici din ecosistemul IDE nativ AI din 2025.
Spre deosebire de completarea automată simplă sau chatul text cu AI, Modul Agent aduce inteligența artificială la un nivel cu totul nou: agentul are acces la sistemul de fișiere, poate rulați comenzi în terminal, citiți rezultatul erorii și repetați pe cont propriu până când sarcina nu s-a finalizat corect. Și ca și cum ai avea un dezvoltator senior care lucrează în paralel cu tine, capabil să gestioneze sarcini complexe cu mai multe fișiere, cu o înțelegere profundă a contextului proiectului.
În acest articol vom explora modul agent în toate aspectele: de la arhitectura internă la capacitățile practice, de la cazuri reale de utilizare la strategii avansate pentru a maximiza productivitatea. Vom vedea cum să-l integrăm cu sistemul Cursor Rules, cum să-și gestioneze limitările și cum se compară cu concurenții precum Agent de pilot GitHub și cod Claude.
Ce veți învăța în acest articol
- Arhitectura modului agent: cum funcționează împreună LLM + utilizarea instrumentului + accesul la sistemul de fișiere
- Diferența dintre Modul Întrebare, Modul Editare și Modul Agent și când să folosiți fiecare
- Cum să activați și să configurați modul agent cu șabloanele potrivite
- Capacitățile complete ale agentului: creare de fișiere, editare de mai multe fișiere, terminal, căutare pe web
- Cazuri practice de utilizare cu exemple complete de cod Angular
- Cum Regulile cursorului amplifică eficacitatea agentului
- Limite, soluții alternative și moduri avansate, cum ar fi Modul YOLO și Modul Max
- Comparație cu GitHub Copilot Agent și Claude Code
- Cele mai bune practici pentru solicitări eficiente și fluxuri de lucru profesionale
Prezentare generală a seriei Cursor IDE și AI-Native Development
| # | Articol | Concentrează-te |
|---|---|---|
| 1 | Ghid complet al cursorului IDE | Prezentare generală completă |
| 2 | Regulile cursorului | Configurare personalizată AI |
| 3 | Sunteți aici - Modul Agent | Automatizare avansată pentru mai multe fișiere |
| 4 | Modul Plan și agenți de fundal | Planificare și paralelism |
| 5 | Cârlige pentru cursor | Automatizarea fluxului de lucru |
| 6 | MCP și Cursor | Integrare baze de date și API |
| 7 | Depanare cu Cursor AI | Depanare de 3 ori mai rapidă |
| 8 | Cursor vs Windsurf vs Copilot | Comparația instrumentelor 2026 |
| 9 | Flux de lucru unghiular profesional | Finalizați proiectul cu Cursor |
Arhitectura modului agent: cum funcționează cu adevărat
Pentru a utiliza modul agent eficient, este esențial să înțelegeți ce se întâmplă sub capotă. Modul agent nu este pur și simplu „AI care scrie mai mult cod”: este un sistem cu mai multe componente în care un limbaj mare Modelul vine echipat cu unelte de beton pentru a interacționa cu mediul de dezvoltare.
Modelul de utilizare a instrumentului
Inima modului agent și conceptul de utilizarea instrumentului (sau apelarea funcției). Modelul LLM în centrul Cursor - fie că este Claude Sonnet, GPT-4o sau Gemini - nu generează doar text: este antrenat să recunoască când trebuie să folosească un instrument extern pentru a finaliza o sarcină. În loc să „inventăm” conținutul unui fișier, agentul poate citi efectiv acel fișier. În loc să-ți imaginezi rezultatul a unei comenzi, o poate executa și citi rezultatul.
Instrumentele disponibile pentru agentul Cursor includ:
- read_file: Citește conținutul unui anumit fișier
- scrie_fisier: Creează sau suprascrie un fișier cu conținut nou
- edit_file: Aplicați modificări specifice unor porțiuni dintr-un fișier
- list_directory: Listează fișierele dintr-un director
- search_files: Căutați modele textuale sau semantice în baza de cod
- run_terminal_command: Execută comenzi în terminalul încorporat
- read_terminal_output: Citește ieșirea terminalului (inclusiv erori)
- căutare_web: Căutați informații actualizate pe web
- create_subagent: Creați agenți specializați pentru sarcini specifice (Cursor 2.0+)
Bucla Agentică
Modul agent funcționează prin a ciclu de raționament iterativ:
- Observati: Citește contextul (fișier, structura proiectului, erori existente)
- Plan: Determinați pașii necesari pentru a finaliza sarcina
- Funcționează: Utilizați instrumentele disponibile (creați fișiere, executați comenzi etc.)
- Valută: Citește ieșirile, verifică erorile, verifică rezultatul
- Repeta: Dacă există erori, reveniți la pasul 1 cu noile informații
Această buclă continuă în mod autonom până la finalizarea sarcinii și a agentului determină care necesită intrare din partea utilizatorului.
Colectarea contextului: Cum înțelege agentul proiectul
Înainte de a scrie o singură linie de cod, Agent Mode realizează o analiză amănunțită a contextului. Cursorul indexează baza de cod folosind înglobări semantice, permițând agentului să găsească fișiere și modele relevante chiar și atunci când nu sunt menționate în mod explicit în prompt. Aceasta este fundamental diferit de un simplu grep: agentul înțelege relațiile conceptual între diferitele părți ale codului.
De exemplu, dacă îi cereți agentului „să adauge validare la formularul de conectare”, acesta știe automat de a trebui să se uite la componenta de autentificare, formularul reactiv, validatorii existenți, șabloanele TypeScript și testele unitare potențial asociate — toate fără a fi necesar să specificați.
Modul Întrebare, Modul Editare și Modul Agent: Diferențele fundamentale
Cursorul oferă trei moduri principale de interacțiune cu AI, fiecare optimizat pentru diferite scenarii. Înțelegerea când să folosiți fiecare este esențială pentru maximizarea productivității.
Modul Întrebare: Conversația
Modul Întrebare (accesibil cu Ctrl+L / Cmd+L) și modul conversațional
de Cursor. În acest mod, AI vă răspunde la întrebări cu explicații, sugestii
și fragmente de cod, dar nu modifică direct fișierele. Și modul ideal pentru:
- Înțelegeți fragmente de cod complexe sau vechi
- Explorați alternativele arhitecturale înainte de implementare
- Pune întrebări despre anumite biblioteci, API-uri sau modele
- Efectuați recenzii de cod și primiți feedback despre codul existent
- Brainstorming asupra designului și structurii proiectului
Mod Editare: Editare contextuală
Mod Editare (accesibil cu Ctrl+K / Cmd+K) permite modificări
contextuală și vizată. AI acționează asupra fișierului curent sau a unei selecții specifice, aplicând
transformări localizate. Este ideal pentru:
- Refactorizarea unei singure funcții sau clase
- Transformări de cod (de exemplu, conversia unei funcții în async/wait)
- Adăugați documentația JSDoc la metodele existente
- Remediați o anumită eroare în fișierul curent
- Remedieri rapide sugerate de IDE
Mod agent: automatizare completă
Modul agent (accesibil cu Ctrl+I / Cmd+I, selectând „Agent” din
dropdown) și cel mai puternic mod. Agentul poate lucra mai multe fișiere,
executa comenzi, repetă peste erori și îndeplini sarcini complexe în mod independent. E
modul potrivit pentru:
- Implementați funcții complete care implică mai multe fișiere
- Refactorizarea la scară de bază de cod (de exemplu, migrarea de la modulele CommonJS la modulele ES)
- Configurarea inițială a proiectelor complet schelete
- Remedierea erorilor care necesită analiză între fișiere
- Adăugați teste la componentele existente
- Migrari de tehnologie (de exemplu, de la RxJS 6 la 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)
Activați și configurați modul agent
Deschideți chat și selectați modul agent
Modul Agent este activat prin fereastra Cursor Composer. Iată pașii:
- Presa
Ctrl+I(Windows/Linux) sauCmd+I(macOS) pentru a deschide Composer - În meniul drop-down din stânga sus al chat-ului, selectați "Agent"
- Alternativ, într-un chat existent, faceți clic pe modul curent și selectați „Agent”
De asemenea, puteți seta modul agent ca implicit în setările cursorului:
Settings > Features > Chat > Default Mode.
Alegerea modelului potrivit
Modul agent acceptă mai multe modele LLM, fiecare cu caracteristici diferite. Alegerea modelului influențează semnificativ calitatea rezultatelor:
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
Modul YOLO: Execuție automată a comenzii
În mod implicit, modul agent solicită confirmarea înainte de a rula orice comandă în terminal. Modul YOLO elimină această solicitare de confirmare, permițând agentului executa comenzi independent. Pentru a-l activa:
Settings > Features > Chat & Composer > Allow agent to run commands automatically
Fii atent la modul YOLO
Modul YOLO este puternic, dar necesită prudență. Configurați întotdeauna i comenzi permise
specificarea unei liste permise (de ex. npm test, ng build) și un denylist
(de ex. rm -rf, git push). Nu activați modul YOLO în medii interioare
producție sau pe depozite cu date sensibile fără a fi configurat corect limitele.
Mod maxim: Context extins
Introdus cu actualizări recente, Mod maxim înlătură limitările tăierea agresivă a contextului Cursorului. În modul standard, agentul reduce contextul Pentru a îmbunătăți capacitatea de răspuns, Modul Max utilizează întregul context disponibil din model. Acest lucru se traduce prin rezultate semnificativ mai bune pentru:
- Baze de cod mari, cu multe dependențe între fișiere
- Erori complexe care necesită înțelegerea mai multor straturi de aplicație
- Refactorizare care trebuie să respecte tiparele arhitecturale distribuite în proiect
Capacitățile complete ale agentului
Crearea și editarea fișierelor
Agentul poate crea fișiere noi și poate modifica pe cele existente cu deplină cunoaștere a structurii a proiectului. Nu doar generează cod izolat: citește fișierele existente, le înțelege tiparele și generează cod nou în concordanță cu stilul și convențiile proiectului.
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.)"
Cu această singură solicitare, Modul Agent creează sau modifică de obicei:
src/app/core/models/notification.model.ts(nou)src/app/core/services/notification.service.ts(nou)src/app/shared/components/notification/notification.component.ts(nou)src/app/shared/components/notification/notification.component.html(nou)src/app/shared/components/notification/notification.component.css(nou)src/app/app.component.ts(modificat pentru a include componenta)src/app/app.component.html(editat pentru a adăuga eticheta de componentă)src/app/core/services/notification.service.spec.ts(nou)
Executarea comenzilor terminale
Modul Agent poate executa comenzi în terminalul încorporat al Cursorului și poate citi rezultatul acestuia. Acesta el vă permite să:
- Instalați dependențe cu
npm install - Rulați compilarea și citiți erorile TypeScript
- Rulați testele și repetați până când trec
- Rulați automat linter și formatator
- Utilizați Angular CLI pentru a genera schele
- Rulați scripturile personalizate ale proiectului dvs
Căutare Web în timp real
O abilitate adesea subestimată este abilitatea de a căuta informații pe web în timpul executarea unei sarcini. Agentul poate consulta documentația oficială, caută soluții la anumite erori sau verificați sintaxa corectă a API-urilor actualizate. Acest lucru este util în special atunci când lucrați cu biblioteci care se actualizează frecvent propriile API-uri, cum ar fi bibliotecile Angular, RxJS sau Material Design.
Analiza erorilor și autocorecția
Una dintre cele mai puternice caracteristici ale modului agent este capacitatea de a autocorecte. După generarea codului, agentul rulează construcția (dacă modul YOLO este activ sau dacă utilizatorul aprobă), citește erori TypeScript sau linter și repetă prin modificarea codului până când nu există mai multe erori. Această buclă de feedback reduce dramatic timpul necesar pentru portare zero erori de construcție.
Cazuri practice de utilizare cu Angular
Cazul 1: adăugați o funcție completă (componentă + serviciu + test)
Cel mai frecvent caz de utilizare pentru Modul Agent este implementarea de noi caracteristici. Să vedem un exemplu concret: adăugați un sistem de paginare la o listă 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)
Iată codul pe care agentul îl generează de obicei pentru 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);
}
}
Cazul 2: Refactorizarea între fișiere
Unul dintre cele mai evidente puncte forte ale modului agent este refactorizarea care se întinde pe mai multe fișiere.
Luați în considerare acest scenariu: trebuie să migrați toate componentele unui proiect Angular din
ngModel la forme reactive.
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.
Cazul 3: Remedierea erorilor cu conștientizarea contextului
Modul agent excelează la remedierea erorilor, deoarece nu se limitează la fișierul în care apare eroarea: înțelege relațiile dintre componente și servicii pentru a găsi adevărata cauză principală.
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.
În acest scenariu, modul agent de obicei:
- Drept
user-settings.component.tsși identificați pe care îl foloseștengOnInitîn loc dengOnChangesotakeUntilDestroyed - Drept
user.service.tsși constată că Observable se finalizează și nu se reemite după abonament - Drept
app.routes.tssau modulul de rutare pentru a înțelege dacă componenta este recreată sau reutilizată - El propune remedierea: folosire
ActivatedRoute.paramMapcu un Observabil în loc desnapshot - Implementați remedierea în toate fișierele afectate
- Rulează linter pentru a verifica corectitudinea codului modificat
Reguli pentru modul agent și cursor: sinergie puternică
Modul agent devine exponențial mai puternic atunci când este combinat cu sistemul Regulile cursorului. Regulile acționează ca „instrucțiuni de sistem” care vă ghidează agentul despre cum ar trebui să funcționeze în cadrul proiectului dumneavoastră specific. Fara Reguli, agentul generează cod generic care poate să nu respecte convențiile echipei. Cu Reguli bine configurate, codul generat nu se distinge de cel scris de către un dezvoltator expert în proiect.
Cum afectează regulile modul agent
Regulile de tip Always sunt injectate la începutul fiecărei ședințe
a agentului, oferind context constant. Regulile Agent Requested ei vin
încărcate dinamic atunci când agentul determină că sunt relevante pentru sarcina curentă.
Acest lucru vă permite să aveți reguli specializate pentru diferite aspecte ale proiectului fără
umflați inutil fereastra de context.
Să vedem un exemplu complet de configurare a regulilor pentru un proiect Angular cu modul agent.
În noua structură Cursor (post 0.45), regulile merg în director
.cursor/rules/ ca un dosar .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
Cu această configurare a regulilor, atunci când agentul primește un prompt like „Creați o componentă a listei de comenzi”, va genera automat:
- O componentă autonomă cu detectarea modificărilor OnPush
- Semnale pentru statul local
- input()/output() în loc de decoratori
- inject() pentru injectarea dependenței
- takeUntilDestroyed() pentru abonamente
- Fișierul de test corespunzător
- Actualizarea fișierului baril
Toate acestea automat, fără a fi nevoie să le specificați în prompt.
Limitările modului agent și cum să le depășiți
Fereastra context și fișiere mari
Cea mai comună limitare a modului agent este fereastră de context. Când baza de cod și foarte mare, agentul poate să nu aibă suficient spațiu pentru a încărca toate fișierele relevante în același timp. Acest lucru poate duce la modificări inconsecvente sau pierderi de context între diferitele părți ale sarcinii.
Strategii pentru gestionarea ferestrei de context
- Defalcați sarcinile mari: În loc de un singur prompt mega-sarcină, despărțiți-l lucrați în pași logici. Finalizați și verificați fiecare pas înainte de a trece la următorul.
-
Utilizați @file pentru context explicit: Indicați în mod explicit fișierele relevante
cu
@nomefileîn solicitarea de a ajuta agentul să prioritizeze contextul. - Activați modul maxim: Pentru sarcini complexe care necesită mult context, Modul Max reduce tăierea agresivă și îmbunătățește calitatea rezultatelor.
-
Creați documente de context: Pentru proiecte foarte mari, creați fișiere
ARCHITECTURE.mdoCONTEXT.mdcare rezumă structura a proiectului. Agentul le poate citi la începutul sarcinii.
Acțiuni potențial distructive
Modul agent poate modifica sau șterge fișierele critice dacă nu este ghidat corect. Câteva măsuri de prevenire cheie:
-
Angajați înainte de a delega către agent: Fă întotdeauna un commit sau ascunde
a modificărilor dumneavoastră înainte de a lansa Modul Agent pentru sarcini semnificative. Acest lucru vă permite
pentru a reveni la starea anterioară cu un simplu
git checkout. - Utilizați reguli pentru a defini fișierele protejate: Adăugați o regulă care indică agentului fișierele pe care nu trebuie să le modifice niciodată (de exemplu, fișiere de configurare critice, fișier de migrare a bazei de date).
- Verificați înainte de a aplica: Cursorul arată întotdeauna o diferență de modificările propuse înainte de aplicarea acestora. Fă-ți timp pentru a revizui, mai ales pentru fișiere critice, cum ar fi configurațiile sau schema bazei de date.
Erori în raționament și halucinații
Ca orice sistem AI, Modul Agent poate face greșeli. Poate „halucina” API-uri inexistente, utilizați versiuni învechite ale bibliotecilor sau interpretați greșit cerințe ambigue. Contramăsurile:
- Indemnizații specifice: Cu cât promptul dvs. este mai specific, cu atât mai puțin și marja de interpretare greșită. Includeți versiuni de bibliotecă, modele favorite și constrângeri explicite.
- Activați căutarea pe web: Permiteți agentului să consulte documentația actualizat reduce semnificativ riscul utilizării API-urilor învechite.
- Verificați ieșirea: Nu aplicați niciodată modificări fără a le revizui. Acest lucru este important în special pentru logica de afaceri critică sau codul de securitate.
Nu delegați codul de securitate agentului fără revizuire
Autentificarea, autorizarea, criptarea și gestionarea secretelor sunt domenii unde AI poate produce cod care este corect funcțional, dar are vulnerabilități de securitate subțire. Recenzie Întotdeauna cu atenție codul de securitate generat de agent și, dacă este posibil, verificați-l de către un expert în securitate.
Agent Mode vs GitHub Copilot Agent vs Claude Code
Peisajul agenților AI pentru dezvoltarea de software în 2025-2026 este competitiv. Să vedem cum se compară Modul Agent Cursor cu alternativele principale.
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)
─────────────────────────────────────────────────────────────────────
Agent cursor: puncte forte
Principalul avantaj al cursorului esteintegrare nativă între IDE, agent, și sistemul de reguli. Agentul are acces la întreaga bază de cod indexată semantic, poate edita fișiere direct în editor, poate executa comenzi în terminalul încorporat, și repetați peste erori într-o buclă închisă. Abilitatea de a gestiona până la 8 agenți paraleli cu git worktrees (introdus în Cursor 2.0) vă permite să explorați implementările alternative în paralel.
Agent GitHub Copilot: puncte forte
Copilot Agent, integrat direct în GitHub Workflow, excelează la rezoluție Probleme GitHub independente. Poate deschide PR direct, poate lucra la sarcini definite în probleme și să se integreze în mod nativ cu procesele de revizuire a codului GitHub. Pentru echipele care lucrează deja în ecosistemul GitHub, acest flux de lucru este foarte simplu.
Claude Code: Puncte forte
Claude Code (instrumentul CLI al Anthropic, diferit de accesarea Claude prin API) strălucește pentru ea flexibilitate și raționament profund asupra sarcinilor complexe. Funcționează bine pentru sarcini de lungă durată, analize arhitecturale și situații în care aveți nevoie calitatea maximă a raționamentului, mai degrabă decât viteza de execuție. Poate fi integrat în orice IDE prin terminal.
Când să alegi ce
- Agent cursor: Dezvoltare zilnică, implementare a caracteristicilor, refactorizare, depanare. Cea mai bună alegere pentru cei care doresc o experiență integrată în IDE.
- Agent copilot: Echipa centrată pe GitHub, rezolvarea automată a problemelor, Fluxul de lucru PR. Ideal ca o completare la Cursor pentru stratul GitHub.
- Cod Claude: Sarcini de raționament înalt, analize arhitecturale, automatizare script, medii în care nu puteți schimba IDE-ul.
Cele mai bune practici pentru modul agent
1. Arta promptului efectiv
Calitatea ieșirii în modul agent este direct proporțională cu calitatea promptului. Un prompt vag produce cod generic; un prompt specific produce cod care arată ca scris de cineva care cunoaște proiectul pe dinafară.
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. Utilizați puncte de control Git frecvente
Înainte de fiecare sesiune în modul agent pentru sarcini semnificative, creați un punct de control 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. Examinați înainte de a aplica
Cursorul arată întotdeauna o diferență a modificărilor propuse de agent. Ia-te mereu pe tine luați-vă timp pentru a revizui aceste modificări, în special pentru:
- Fișiere de configurare (angular.json, tsconfig.json, package.json)
- Cod de autentificare și autorizare
- Fișiere de migrare a bazei de date
- Logica de afaceri critică
- Variabile de mediu și configurații sensibile
4. Repetați și rafinați sarcina
Nu vă așteptați ca Modul Agent să finalizeze sarcini complexe cu un singur prompt perfect. Cel mai productiv și iterativ flux de lucru:
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ți reguli specifice pentru agent
După cum am văzut în secțiunea anterioară, Regulile sunt multiplicatorul productivității mai puternic pentru Modul Agent. Petreceți timp construind o bază bună de reguli pentru proiectul dvs. O regulă generală bună: ori de câte ori corectezi ceva agentul a făcut „rău” respecți la convențiile proiectului, adăugați acea remediere ca regulă.
Flux de lucru profesional cu modul agent
Ziua tipică a unui dezvoltator cu modul agent
Să vedem cum se integrează Modul Agent în fluxul de lucru zilnic al unui dezvoltator 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
Model: Modul agent pentru revizuirea codului asistată
O utilizare mai puțin evidentă, dar foarte eficientă, a modului agent și revizuirea asistată a codului. Înainte de a face un PR, cereți agentului să vă revizuiască munca:
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
Integrare cu modul Plan
Pentru sarcini deosebit de complexe, combinați Modul Agent cu Modul Plan (pe care îl vom explora în următorul articol din serie). Modul Plan permite agentului să creați mai întâi un plan de lucru structurat, pe care îl puteți revizui și aproba mai întâi să înceapă execuția. Acest lucru este util în special pentru:
- Migrații de cadre sau biblioteci importante
- Implementări de caracteristici transversale care ating multe fișiere
- Refactoriri arhitecturale semnificative
- Configurarea inițială a unor noi proiecte sau module
Modul agent în Cursor 2.0: Noile frontiere
Cursor 2.0, lansat la sfârșitul anului 2025, a introdus îmbunătățiri semnificative în modul agent. Aceste caracteristici reprezintă viitorul dezvoltării native AI.
Agenți paraleli cu Git Worktrees
Cea mai revoluționară caracteristică a Cursor 2.0 este capacitatea de a executa până la 8 agenți în paralel, fiecare operand pe un arbore de lucru git separat. Fiecare agent lucrează izolat, permițând să fie explorate implementări alternative simultan fără interferențe.
Imaginați-vă că trebuie să alegeți între trei abordări diferite pentru a implementa o caracteristică critică. Cu agenți paraleli, puteți lansa trei agenți în același timp, fiecare cu a prompt diferit care specifică o abordare diferită. După 15-20 de minute, ai trei implementări complete pentru a compara și a alege cea mai bună.
Agenți de fundal
Agenții de fundal de la Cursor 2.0 vă permit să delegați sarcini pe termen lung care rulează în fundal în timp ce continuați să lucrați la alte lucruri. Puteți lansa un agent să „actualizeze toate testele din proiect pentru noua versiune de Angular” și continuă să dezvolte funcții între timp. Agentul vă anunță când s-a finalizat sau când are nevoie de intrare.
Subagenți specializați
Modul Agent acceptă acum crearea de subagenți specializați. Un agent „orchestrator”. poate delega părți specifice ale sarcinii unor subagenți de specialitate: unul pentru scriere de teste, unul pentru optimizarea performanței, unul pentru documentare. Subagenții pot fi configurați cu diferite modele, reguli și acces la instrumente de către agentul principal.
Concluzii și pașii următori
Modul Agent al cursorului reprezintă unul dintre cele mai semnificative salturi în productivitate disponibil astăzi pentru dezvoltatori. Nu este vorba despre „AI care scrie cod pentru tine”, dar de a colaborator inteligent care vă accelerează fluxul de lucru, gestionează complexitatea tehnică și îți eliberează timp pentru a te concentra arhitectură, design și decizii de mare valoare.
Puncte cheie de reținut:
- Mod agent = LLM + Utilizare instrument + Context: Nu este magie, este un sistem bine concepute în cazul în care AI folosește instrumente concrete pentru a interacționa cu baza de cod.
- Calitatea promptului determină calitatea rezultatului: Îndemnuri specifice, contextuale și cu constrângeri explicite produc rezultate semnificativ mai bine decât îndemnurile vagi.
- Regulile cursorului sunt multiplicatorul de productivitate: Unul bun Configurația regulilor transformă agentul din „AI generic” în „dezvoltator expert a proiectului dumneavoastră specific”.
- Verificați întotdeauna înainte de a aplica: Modul agent este un instrument puternic dar nu infailibil. Revizuirea ta critică și fundamentală, mai ales pentru codul de securitate și logica de afaceri critică.
- Repetați în pași mici: Cel mai eficient flux de lucru împarte sarcinile complex în pași iterativi, cu revizuire și angajare la fiecare pas.
Continuați seria: articolul următor
În următorul articol din serie vom explora Modul Plan și agenți de fundal: cum să utilizați planificarea structurată pentru sarcini complexe și cum să delegați munca la agenții de fundal Cursor 2.0 pentru a maximiza productivitatea. Dacă Modul Agent și motorul, modul Plan și volanul.
Articole similare din serie
- Regulile cursorului (articolul 2): Aflați mai multe despre configurație a sistemului de reguli pentru a amplifica modul agent în proiectul dumneavoastră specific.
- Modul Plan și agenți de fundal (articolul 4): Următorul pas pentru a automatiza sarcini și mai complexe cu planificare structurată.
- MCP și cursor (articolul 6): Cum să vă conectați la modul agent la baze de date, API-uri externe și instrumente personalizate prin Protocolul de context model.
- Flux de lucru unghiular profesional (articolul 9): Un proiect Angular complet dezvoltat în întregime cu Cursor Agent Mode, de la creare până la implementare.