03 - Režim agenta: Upravte kódovou základnu pomocí příkazu
Představte si, že můžete svému IDE říct: „Přidejte ověřování JWT do této aplikace Angular“ a pozorujte zatímco editor vytváří soubory, zapisuje služby, aktualizuje komponenty, spouští testy a opravuje chyby samostatně, aniž byste se museli dotknout jediného řádku kódu. Toto není sci-fi: e Režim agenta kurzoru, jedna z nejvíce transformačních funkcí v ekosystému IDE nativního AI roku 2025.
Na rozdíl od jednoduchého automatického doplňování nebo textového chatu s AI přináší Agent Mode umělá inteligence na zcela novou úroveň: agent má přístup k systému souborů, může spusťte příkazy v terminálu, přečtěte si chybový výstup a iterujte sami, dokud úkol nebyl dokončen správně. A jako když s vámi paralelně pracuje senior vývojář, schopný řídit složité vícesouborové úkoly s hlubokým porozuměním kontextu projektu.
V tomto článku prozkoumáme režim agenta ve všech aspektech: od interní architektury po praktické možnosti, od skutečných případů použití po pokročilé strategie pro maximalizaci produktivity. Uvidíme, jak to integrovat se systémem pravidel kurzoru, jak řídit jeho omezení a jak se podobá konkurenci GitHub Copilot Agent a Claude Code.
Co se dozvíte v tomto článku
- Architektura režimu agenta: jak spolupracují LLM + nástroj + přístup k systému souborů
- Rozdíl mezi režimem dotazu, režimem úprav a režimem agenta a kdy je použít
- Jak aktivovat a nakonfigurovat režim agenta pomocí správných šablon
- Plné možnosti agenta: vytváření souborů, editace více souborů, terminál, vyhledávání na webu
- Praktické případy použití s kompletními příklady Angular kódu
- Jak pravidla kurzoru zesilují efektivitu agenta
- Limity, řešení a pokročilé režimy, jako je YOLO Mode a Max Mode
- Srovnání s GitHub Copilot Agent a Claude Code
- Nejlepší postupy pro efektivní výzvy a profesionální pracovní postupy
Přehled vývojových sérií Cursor IDE a AI-Native
| # | Položka | Soustředit |
|---|---|---|
| 1 | Kompletní průvodce IDE pro kurzor | Kompletní přehled |
| 2 | Pravidla kurzoru | Vlastní nastavení AI |
| 3 | Jste zde - Agent Mode | Pokročilá automatizace více souborů |
| 4 | Režim plánu a agenti na pozadí | Plánování a paralelismus |
| 5 | Háčky kurzoru | Automatizace pracovního postupu |
| 6 | MCP a kurzor | Integrace databáze a API |
| 7 | Ladění pomocí kurzoru AI | 3x rychlejší ladění |
| 8 | Cursor vs Windsurf vs Copilot | Srovnání nástrojů 2026 |
| 9 | Profesionální úhlový pracovní postup | Dokončete projekt pomocí kurzoru |
Architektura režimu agenta: Jak to skutečně funguje
Chcete-li efektivně používat režim agenta, je důležité porozumět tomu, co se děje pod kapotou. Režim agenta není to jednoduše „AI, která píše více kódu“: je to vícesložkový systém, kde je velký jazyk Model je vybaven betonové nástroje pro interakci s vývojovým prostředím.
Model použití nástroje
Srdce Agent Mode a koncept použití nástroje (nebo volání funkce). Model LLM v jádru Cursoru – ať už je to Claude Sonnet, GPT-4o nebo Gemini – negeneruje pouze text: je trénovaný rozpoznat, kdy potřebuje k dokončení úkolu použít externí nástroj. Místo "vymýšlení" obsah souboru, může agent skutečně číst tento soubor. Místo představování si výstupu příkazu, může jej provést a přečíst výsledek.
Nástroje dostupné pro agenta kurzoru zahrnují:
- read_file: Přečte obsah konkrétního souboru
- write_file: Vytvoří nebo přepíše soubor novým obsahem
- upravit_soubor: Použijte konkrétní změny na části souboru
- seznam_adresář: Vypisuje soubory v adresáři
- hledat_soubory: Hledejte textové nebo sémantické vzory v kódové základně
- run_terminal_command: Provádí příkazy ve vestavěném terminálu
- read_terminal_output: Čte výstup terminálu (včetně chyb)
- web_search: Vyhledejte aktualizované informace na webu
- create_subagent: Vytvářejte specializované agenty pro konkrétní úkoly (Cursor 2.0+)
Agentská smyčka
Režim agenta funguje prostřednictvím a iterativní cyklus uvažování:
- Pozorovat: Čte kontext (soubor, struktura projektu, existující chyby)
- Plán: Určete kroky potřebné k dokončení úkolu
- Funguje to: Používejte dostupné nástroje (vytvářejte soubory, spouštějte příkazy atd.)
- Měna: Přečte výstupy, zkontroluje chyby, zkontroluje výsledek
- Opakovat: Pokud se vyskytnou chyby, vraťte se ke kroku 1 s novými informacemi
Tato smyčka pokračuje autonomně, dokud úkol a agent nedokončí určuje, co potřebuje vstup od uživatele.
Kontextové shromáždění: Jak agent rozumí projektu
Před napsáním jednoho řádku kódu provede režim agenta důkladnou analýzu kontextu. Kurzor indexuje kódovou základnu pomocí sémantických vložení, což agentovi umožňuje najít soubory a relevantní vzory, i když nejsou výslovně uvedeny ve výzvě. Tohle je zásadně odlišné od jednoduchého grepu: agent rozumí vztahům pojmový mezi různými částmi kódu.
Pokud například agenta požádáte, aby „přidal ověření do přihlašovacího formuláře“, automaticky to ví nutnosti podívat se na přihlašovací komponentu, reaktivní formulář, existující validátory, šablony TypeScript a potenciálně související testy jednotek – to vše, aniž byste museli specifikovat.
Režim dotazu, režim úprav a režim agenta: základní rozdíly
Cursor nabízí tři hlavní způsoby interakce s umělou inteligencí, z nichž každý je optimalizován pro různé scénáře. Pro maximalizaci produktivity je rozhodující, kdy je použít.
Režim dotazu: Konverzace
Režim dotazu (přístupný pomocí Ctrl+L / Cmd+L) a konverzační režim
kurzoru. V tomto režimu AI odpovídá na vaše otázky vysvětleními a návrhy
a úryvky kódu, ale přímo nemění soubory. A ideální režim pro:
- Pochopte složité nebo starší části kódu
- Před implementací prozkoumejte architektonické alternativy
- Ptejte se na konkrétní knihovny, rozhraní API nebo vzory
- Provádějte kontroly kódu a získejte zpětnou vazbu ke stávajícímu kódu
- Brainstorming o návrhu a struktuře projektu
Režim úprav: Kontextové úpravy
Režim úprav (přístupný pomocí Ctrl+K / Cmd+K) umožňuje úpravy
kontextové a cílené. Umělá inteligence pracuje s aktuálním souborem nebo konkrétním výběrem
lokalizované transformace. Je ideální pro:
- Refaktoring jedné funkce nebo třídy
- Transformace kódu (např. převod funkce na asynchronní/asynchronní)
- Přidejte dokumentaci JSDoc ke stávajícím metodám
- Opravte konkrétní chybu v aktuálním souboru
- Rychlé opravy navržené IDE
Režim agenta: Kompletní automatizace
Režim agenta (dostupný pomocí Ctrl+I / Cmd+I, výběrem "Agent" z
rozbalovací nabídka) a nejvýkonnější režim. Agent může projít více souborů,
provádět příkazy, opakovat chyby a samostatně plnit složité úkoly. E
správný režim pro:
- Implementujte kompletní funkce zahrnující více souborů
- Refaktoring v měřítku kódové báze (např. migrace z modulů CommonJS na ES)
- Počáteční nastavení plně lešenářských projektů
- Oprava chyb vyžadující analýzu mezi soubory
- Přidejte testy ke stávajícím komponentám
- Migrace technologií (např. z RxJS 6 na 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)
Aktivujte a nakonfigurujte režim agenta
Otevřete chat a vyberte režim agenta
Režim agenta se aktivuje prostřednictvím okna Cursor Composer. Zde jsou kroky:
- Stiskněte
Ctrl+I(Windows/Linux) popřCmd+I(macOS) a otevřete Composer - V rozbalovací nabídce v levé horní části chatu vyberte "Činidlo"
- Případně ve stávajícím chatu klikněte na aktuální režim a vyberte "Agent"
Režim agenta můžete také nastavit jako výchozí v nastavení kurzoru:
Settings > Features > Chat > Default Mode.
Výběr správného modelu
Režim agenta podporuje několik modelů LLM, z nichž každý má jiné funkce. Výběr modelu výrazně ovlivňuje kvalitu výsledků:
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
Režim YOLO: Automatické provedení příkazu
Ve výchozím nastavení režim agenta požaduje potvrzení před spuštěním jakýchkoli příkazů v terminálu. Režim YOLO odstraní tuto výzvu k potvrzení a umožní agentovi provádět příkazy nezávisle. Chcete-li jej aktivovat:
Settings > Features > Chat & Composer > Allow agent to run commands automatically
Buďte opatrní s režimem YOLO
Režim YOLO je výkonný, ale vyžaduje opatrnost. Vždy konfigurujte i povoleny příkazy
zadáním seznamu povolených (např. npm test, ng build) a popírač
(např. rm -rf, git push). Neaktivujte režim YOLO ve vnitřním prostředí
produkci nebo na úložištích s citlivými daty, aniž by byly správně nastaveny limity.
Režim Max: Rozšířený kontext
Uvedeno s nedávnými aktualizacemi, Režim Max odstraňuje omezení agresivní Prořezávání kontextu kurzoru. Ve standardním režimu agent redukuje kontext Pro zlepšení odezvy využívá režim Max celý kontext dostupný z modelu. To se promítá do výrazně lepších výsledků pro:
- Velké kódové báze s mnoha závislostmi mezi soubory
- Složité chyby, které vyžadují pochopení více vrstev aplikací
- Refaktoring, který musí respektovat architektonické vzory rozmístěné v projektu
Kompletní schopnosti agenta
Vytváření a úpravy souborů
Agent může vytvářet nové soubory a upravovat stávající s plným vědomím struktury projektu. Negeneruje pouze izolovaně kód: čte existující soubory, rozumí jim vzory a generuje nový kód konzistentní se stylem a konvencemi projektu.
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.)"
Pomocí této jediné výzvy režim agenta obvykle vytváří nebo upravuje:
src/app/core/models/notification.model.ts(nový)src/app/core/services/notification.service.ts(nový)src/app/shared/components/notification/notification.component.ts(nový)src/app/shared/components/notification/notification.component.html(nový)src/app/shared/components/notification/notification.component.css(nový)src/app/app.component.ts(upraveno tak, aby zahrnovalo komponentu)src/app/app.component.html(upraveno pro přidání značky komponenty)src/app/core/services/notification.service.spec.ts(nový)
Provádění příkazů terminálu
Režim agenta může provádět příkazy ve vestavěném terminálu kurzoru a číst jeho výstup. Tohle on umožňuje:
- Nainstalujte závislosti pomocí
npm install - Spusťte sestavení a přečtěte si chyby TypeScript
- Spusťte testy a opakujte, dokud neprojdou
- Automaticky spusťte linter a formátovač
- Použijte Angular CLI ke generování lešení
- Spusťte vlastní skripty vašeho projektu
Vyhledávání na webu v reálném čase
Často podceňovanou schopností je schopnost vyhledávat informace na webu během provedení úkolu. Agent může konzultovat oficiální dokumentaci, vyhledávat řešení konkrétních chyb nebo ověřte správnou syntaxi aktualizovaných rozhraní API. To je užitečné zejména při práci s knihovnami, které se často aktualizují vaše vlastní API, jako jsou knihovny Angular, RxJS nebo Material Design.
Analýza chyb a samoopravy
Jednou z nejvýkonnějších funkcí Agent Mode je schopnost sebeopravovat. Po vygenerování kódu agent spustí sestavení (pokud je aktivní režim YOLO nebo pokud to uživatel schválí), čte chyby TypeScript nebo linter a iteruje úpravou kódu, dokud žádné nejsou více chyb. Tato smyčka zpětné vazby dramaticky zkracuje čas potřebný k přenosu nulové chyby při sestavování.
Praktické případy použití s Angular
Případ 1: Přidejte kompletní funkci (komponenta + služba + test)
Nejčastějším případem použití režimu agenta je implementace nových funkcí. Podívejme se na příklad beton: přidejte systém stránkování do seznamu 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)
Zde je kód, který agent obvykle generuje pro 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);
}
}
Případ 2: Refaktorování mezi soubory
Jednou z nejviditelnějších předností Agent Mode je refaktorování, které zahrnuje více souborů.
Zvažte tento scénář: musíte migrovat všechny součásti projektu Angular z
ngModel na Reaktivní formuláře.
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.
Případ 3: Oprava chyb pomocí uvědomění si kontextu
Agent Mode vyniká v opravě chyb, protože není omezen na soubor, kde se chyba objeví: rozumí vztahům mezi komponentami a službami, aby našel skutečnou kořenovou příčinu.
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.
V tomto scénáři režim agenta obvykle:
- Zákon
user-settings.component.tsa určit, který z nich používángOnInitmístongOnChangesotakeUntilDestroyed - Zákon
user.service.tsa zjistí, že se Observable dokončí a po předplatném se znovu nevydá - Zákon
app.routes.tsnebo směrovací modul, abyste pochopili, zda je komponenta znovu vytvořena nebo znovu použita - Navrhuje opravu: použití
ActivatedRoute.paramMaps Pozorovatelným místosnapshot - Nasaďte opravu do všech ovlivněných souborů
- Spustí linter k ověření správnosti upraveného kódu
Režim agenta a pravidla kurzoru: Výkonná synergie
Režim agenta se v kombinaci se systémem stává exponenciálně výkonnějším Pravidla kurzoru. Pravidla fungují jako „systémové pokyny“, které vás vedou agenta o tom, jak by měl fungovat v rámci vašeho konkrétního projektu. Bez pravidel, agent generuje obecný kód, který nemusí dodržovat týmové konvence. S dobře nakonfigurovanými pravidly je vygenerovaný kód k nerozeznání od napsaného odborníkem na projekt.
Jak pravidla ovlivňují režim agenta
Pravidla typu Always se aplikují na začátku každého sezení
agenta poskytující konstantní kontext. Pravidla Agent Requested přijdou
načítají se dynamicky, když agent určí, že jsou relevantní pro aktuální úlohu.
To vám umožní mít specializovaná pravidla pro různé aspekty projektu bez
zbytečně nafukovat kontextové okno.
Podívejme se na úplný příklad konfigurace pravidel pro projekt Angular s režimem agenta.
V nové struktuře kurzoru (po 0.45) jsou pravidla uložena v adresáři
.cursor/rules/ jako soubor .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
S touto konfigurací pravidel, když agent obdrží výzvu jako "Vytvořit komponentu seznamu objednávek", automaticky vygeneruje:
- Samostatná komponenta s detekcí změn OnPush
- Signály pro místní stát
- input()/output() místo dekorátorů
- inject() pro vkládání závislosti
- takeUntilDestroyed() pro předplatná
- Odpovídající testovací soubor
- Aktualizace souboru barelu
To vše automaticky, aniž byste to museli zadávat do výzvy.
Omezení režimu agenta a jak je překonat
Kontextové okno a velké soubory
Nejběžnějším omezením režimu agenta je kontextové okno. Když kódová základna a velmi velké, agent nemusí mít dostatek místa k načtení všech souborů relevantní zároveň. To může vést k nekonzistentním změnám nebo ztrátě kontextu mezi různými částmi úkolu.
Strategie pro správu kontextového okna
- Rozdělte velké úkoly: Namísto jediného mega-úkolového příkazu ho rozbijte pracovat v logických krocích. Než přejdete k dalšímu, dokončete a ověřte každý krok.
-
Použijte @file pro explicitní kontext: Explicitně uveďte příslušné soubory
s
@nomefileve výzvě, která agentovi pomůže určit prioritu kontextu. - Aktivujte režim Max: Pro složité úkoly, které vyžadují hodně kontextu, Režim Max snižuje agresivní prořezávání a zlepšuje kvalitu výsledků.
-
Vytvořte kontextové dokumenty: U velmi velkých projektů vytvořte soubory
ARCHITECTURE.mdoCONTEXT.mdkteré shrnují strukturu projektu. Agent si je může přečíst na začátku úlohy.
Potenciálně destruktivní akce
Režim agenta může upravit nebo odstranit kritické soubory, pokud nejsou správně vedeny. Některá klíčová preventivní opatření:
-
Před delegováním na agenta se zavázat: Vždy proveďte potvrzení nebo skrýš
před spuštěním režimu agenta u důležitých úkolů. To vám umožňuje
vrátit se do předchozího stavu jednoduchým
git checkout. - Použijte Pravidla k definování chráněných souborů: Přidejte pravidlo, které označuje agentovi soubory, které nesmí nikdy upravovat (např. kritické konfigurační soubory, soubor pro migraci databáze).
- Před podáním žádosti zkontrolujte: Kurzor vždy ukazuje rozdíl navrhované změny před jejich uplatněním. Udělejte si čas na recenzi, např pro kritické soubory, jako jsou konfigurace nebo schéma databáze.
Chyby v uvažování a halucinace
Jako každý systém umělé inteligence může i Agent Mode dělat chyby. Může „halucinovat“ neexistující API, používat zastaralé verze knihoven nebo nesprávně interpretovat nejednoznačné požadavky. Protiopatření:
- Konkrétní výzvy: Čím konkrétnější je vaše výzva, tím méně a prostor pro nesprávnou interpretaci. Zahrnout verze knihovny, vzory oblíbené a explicitní omezení.
- Povolit vyhledávání na webu: Umožněte agentovi nahlédnout do dokumentace aktualizace výrazně snižuje riziko používání zastaralých API.
- Zkontrolujte výstup: Nikdy nepoužívejte změny, aniž byste je zkontrolovali. To je zvláště důležité pro kritickou obchodní logiku nebo bezpečnostní kód.
Nedelegujte bezpečnostní kód agentovi bez kontroly
Autentizace, autorizace, šifrování a správa tajemství jsou oblasti kde umělá inteligence dokáže vytvořit kód, který je funkčně správný, ale má slabá zabezpečení tenký. Recenze Vždy pečlivě bezpečnostní kód vygenerovaný agentem and, if possible, have it reviewed by a security expert.
Režim agenta vs GitHub Copilot Agent vs Claude Code
Krajina agentů AI pro vývoj softwaru v letech 2025–2026 je konkurenceschopná. Podívejme se, jak si Cursor's Agent Mode vede v porovnání s předními alternativami.
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)
─────────────────────────────────────────────────────────────────────
Kurzorový agent: Silné stránky
Hlavní výhodou Cursoru jenativní integrace mezi IDE, agentem, a systém Pravidel. Agent má přístup k celé sémanticky indexované kódové základně, umí upravovat soubory přímo v editoru, spouštět příkazy ve vestavěném terminálu, a opakujte chyby v uzavřené smyčce. Schopnost spravovat až 8 paralelních agentů s pracovními stromy git (zavedené v Cursoru 2.0) vám umožňuje prozkoumat implementace alternativy paralelně.
GitHub Copilot Agent: Silné stránky
Copilot Agent, integrovaný přímo do GitHub Workflow, exceluje v rozlišení samostatné problémy GitHubu. Může přímo otevřít PR, pracovat na definovaných úkolech v problémech a nativně se integrují s procesy kontroly kódu GitHub. Pro týmy, které již pracují v ekosystému GitHub, je tento pracovní postup velmi bezproblémový.
Claudeův kód: Silné stránky
Claude Code (nástroj CLI společnosti Anthropic, odlišný od přístupu k Claude přes API) září pro své flexibilita a hluboké uvažování o složitých úkolech. Funguje dobře pro dlouhodobé úkoly, architektonické analýzy a situace, kdy to potřebujete maximální kvalita uvažování spíše než rychlost provedení. Může být integrované do libovolného IDE přes terminál.
Kdy vybrat co
- Kurzorový agent: Každodenní vývoj, implementace funkcí, refaktoring, ladit. Nejlepší volba pro ty, kteří chtějí integrovaný zážitek v IDE.
- Agent druhého pilota: tým zaměřený na GitHub, automatické řešení problémů, PR pracovní postup. Ideální jako doplněk ke Cursoru pro vrstvu GitHub.
- Claudeův kód: Vysoce logické úkoly, architektonické analýzy, automatizace skriptů, prostředí, kde nemůžete změnit IDE.
Nejlepší postupy pro režim agenta
1. Umění efektivní výzvy
Kvalita výstupu režimu agenta je přímo úměrná kvalitě výzvy. Vágní výzva vytváří obecný kód; konkrétní výzva vytvoří kód, který vypadá jako napsal někdo, kdo zná projekt zevnitř.
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. Použijte časté kontrolní body Git
Před každou relací režimu agenta u významných úkolů vytvořte kontrolní bod 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. Před podáním žádosti zkontrolujte
Kurzor vždy zobrazuje rozdíl změn navržených agentem. Vždy si vezměte sebe věnujte čas kontrole těchto změn, zejména pro:
- Konfigurační soubory (angular.json, tsconfig.json, package.json)
- Autentizační a autorizační kód
- Soubory migrace databáze
- Kritická obchodní logika
- Proměnné prostředí a citlivé konfigurace
4. Opakujte a upřesněte úlohu
Neočekávejte, že Agent Mode dokončí složité úkoly s jedinou perfektní výzvou. Nejproduktivnější a nejopakovanější pracovní postup:
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. Nakonfigurujte pravidla specifická pro agenty
Jak jsme viděli v předchozí části, Pravidla jsou multiplikátorem produktivity výkonnější pro režim agenta. Spend time building a good foundation of Rules for your project. Dobré pravidlo: kdykoli opravíte něco, co agent udělal „špatně“, respektujete to do konvencí projektu přidejte tuto opravu jako pravidlo.
Profesionální pracovní postup s režimem agenta
Typický den vývojáře s režimem agenta
Podívejme se, jak se Agent Mode integruje do každodenního pracovního postupu vývojáře 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
Vzor: Režim agenta pro asistovanou kontrolu kódu
Méně zřejmé, ale velmi efektivní použití režimu agenta a asistované kontroly kódu. Před provedením PR požádejte agenta, aby zkontroloval vaši práci:
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
Integrace s režimem plánu
Pro zvláště složité úkoly zkombinujte režim agenta s Režim plánu (které prozkoumáme v dalším článku ze série). Režim plánu to agentovi umožňuje nejprve vytvořte strukturovaný pracovní plán, který můžete nejprve zkontrolovat a schválit nechejte exekuci začít. To je užitečné zejména pro:
- Migrace důležitých frameworků nebo knihoven
- Implementace průřezových funkcí, které se dotýkají mnoha souborů
- Významné architektonické refaktory
- Počáteční nastavení nových projektů nebo modulů
Režim agenta v Cursor 2.0: The New Frontiers
Cursor 2.0, vydaný koncem roku 2025, přinesl významná vylepšení režimu agenta. Tyto funkce představují budoucnost nativního vývoje AI.
Paralelní agenti s pracovními stromy Git
Nejrevolučnější funkcí Cursoru 2.0 je schopnost spustit až 8 agentů paralelně, z nichž každý pracuje na samostatném pracovním stromu git. Každý agent pracuje izolovaně, což umožňuje prozkoumat alternativní implementace současně bez rušení.
Představte si, že byste si museli vybrat mezi třemi různými přístupy k implementaci kritické funkce. S paralelními agenty můžete spustit tři agenty současně, každý s a jiná výzva, která specifikuje jiný přístup. Po 15-20 minutách máte tři kompletní implementace porovnat a vybrat tu nejlepší.
Pozadí agenti
Agenti pozadí Cursor 2.0 vám umožňují delegovat dlouhodobé úkoly které běží na pozadí, zatímco budete pokračovat v práci na jiných věcech. Můžete spustit agenta "aktualizovat všechny testy v projektu pro novou verzi Angular" a mezitím pokračovat ve vývoji funkcí. Zástupce vás upozorní, kdy dokončeno nebo když potřebuje zadání.
Specializované subagenty
Režim agenta nyní podporuje vytváření specializovaných podagentů. Agent „orchestru“. může delegovat konkrétní části úkolu na specializované subagenty: jeden pro psaní testů, jeden pro optimalizaci výkonu, jeden pro dokumentaci. Subagentům lze konfigurovat různé modely, pravidla a přístup k nástrojům hlavním zmocněncem.
Závěry a další kroky
Režim agenta kurzoru představuje jeden z nejvýznamnějších skoků v produktivitě dnes k dispozici vývojářům. Není to o „AI psaní kódu pro vás“, ale z a inteligentního spolupracovníka což urychlí váš pracovní postup, zvládá technickou složitost a ušetří vám čas, na který se můžete soustředit architektura, design a vysoce hodnotná rozhodnutí.
Klíčové body k zapamatování:
- Režim agenta = LLM + Použití nástroje + kontext: Není to magie, je to systém dobře navržený tam, kde AI používá konkrétní nástroje k interakci s kódovou základnou.
- Kvalita výzvy určuje kvalitu výstupu: Výzvy specifické, kontextové a s explicitními omezeními poskytují významné výsledky lepší než vágní výzvy.
- Pravidla kurzoru jsou multiplikátorem produktivity: Dobrý Konfigurace pravidel transformuje agenta z „obecné AI“ na „expertního vývojáře vašeho konkrétního projektu“.
- Před podáním žádosti vždy zkontrolujte: Agent Mode je nástroj mocný, ale ne neomylný. Vaše kritická a zásadní recenze, esp pro bezpečnostní kód a kritickou obchodní logiku.
- Opakujte po malých krocích: Nejúčinnější pracovní postup rozděluje úkoly komplexní v iteračních krocích, s kontrolou a potvrzením v každém kroku.
Pokračovat v sérii: Další článek
V dalším článku ze série se podíváme na to Režim plánu a agenti na pozadí: jak používat strukturované plánování pro složité úkoly a jak delegovat práci na agenty pozadí Cursor 2.0 pro maximalizaci produktivity. Pokud režim agenta a motor, plánovací režim a volant.
Související články v seriálu
- Pravidla kurzoru (článek 2): Zjistěte více o konfiguraci of the Rules system to amplify Agent Mode in your specific project.
- Režim plánu a agenti na pozadí (článek 4): Další krok k automatizaci ještě složitějších úkolů pomocí strukturovaného plánování.
- MCP a kurzor (článek 6): Jak připojit Agent Mode k databázím, externím rozhraním API a vlastním nástrojům prostřednictvím protokolu Model Context Protocol.
- Profesionální úhlový pracovní postup (článek 9): Úhlový projekt kompletně vyvinutý výhradně v režimu kurzorového agenta, od vytvoření až po nasazení.