03 - Tryb agenta: Modyfikuj bazę kodu za pomocą polecenia
Wyobraź sobie, że możesz powiedzieć swojemu IDE: „Dodaj uwierzytelnianie JWT do tej aplikacji Angular” i obserwuj podczas gdy edytor tworzy pliki, zapisuje usługi, aktualizuje komponenty, uruchamia testy i naprawia błędy samodzielnie, bez konieczności dotykania ani jednej linii kodu. To nie jest science fiction: np Tryb agenta Kursora, jedna z najbardziej rewolucyjnych funkcji w ekosystemie IDE natywnym dla sztucznej inteligencji w roku 2025.
W przeciwieństwie do prostego autouzupełniania lub czatu tekstowego z AI, tryb agenta oferuje sztuczna inteligencja na zupełnie nowy poziom: agent ma dostęp do systemu plików, może uruchamiaj polecenia w terminalu, czytaj dane wyjściowe błędu i wykonaj iterację samodzielnie, aż do zadanie nie zostało wykonane poprawnie. Podobnie jak starszy programista pracujący równolegle z Tobą, potrafi zarządzać złożonymi zadaniami obejmującymi wiele plików przy głębokim zrozumieniu kontekstu projektu.
W tym artykule omówimy tryb agenta pod każdym względem: od architektury wewnętrznej po możliwości praktyczne, od rzeczywistych przypadków użycia po zaawansowane strategie maksymalizujące produktywność. Zobaczymy jak to zintegrować z systemem Cursor Rules, jak zarządzać jego ograniczeniami i jak wypada na tle konkurencji Agent drugiego pilota GitHub i kod Claude.
Czego dowiesz się w tym artykule
- Architektura trybu agenta: jak LLM + użycie narzędzi + dostęp do systemu plików współdziałają
- Różnica między trybem Zapytaj, Trybem Edycji i Trybem Agenta oraz kiedy używać każdego z nich
- Jak aktywować i skonfigurować tryb agenta za pomocą odpowiednich szablonów
- Pełne możliwości agenta: tworzenie plików, edycja wielu plików, terminal, wyszukiwanie w Internecie
- Praktyczne przypadki użycia z pełnymi przykładami kodu Angular
- Jak reguły kursora zwiększają skuteczność agenta
- Ograniczenia, obejścia i zaawansowane tryby, takie jak tryb YOLO i tryb Max
- Porównanie z agentem GitHub Copilot i kodem Claude
- Najlepsze praktyki dotyczące skutecznych podpowiedzi i profesjonalnych przepływów pracy
Przegląd serii Cursor IDE i AI-Native Development
| # | Przedmiot | Centrum |
|---|---|---|
| 1 | Kompletny przewodnik po IDE kursora | Pełny przegląd |
| 2 | Reguły kursora | Niestandardowa konfiguracja AI |
| 3 | Jesteś tutaj - Tryb Agenta | Zaawansowana automatyzacja wielu plików |
| 4 | Tryb planu i agenci działający w tle | Planowanie i równoległość |
| 5 | Haki kursora | Automatyzacja przepływu pracy |
| 6 | MCP i kursor | Integracja baz danych i API |
| 7 | Debugowanie za pomocą Cursor AI | 3x szybsze debugowanie |
| 8 | Kursor kontra windsurfing kontra drugi pilot | Porównanie instrumentów 2026 |
| 9 | Profesjonalny przepływ pracy Angular | Ukończ projekt za pomocą kursora |
Architektura trybu agenta: jak to naprawdę działa
Aby efektywnie korzystać z trybu agenta, niezwykle ważne jest zrozumienie, co dzieje się pod maską. Tryb agenta to nie jest po prostu „sztuczna inteligencja, która pisze więcej kodu”: to wieloskładnikowy system, w którym występuje duży język Model jest wyposażony w narzędzia do betonu do interakcji ze środowiskiem programistycznym.
Model użycia narzędzia
Serce trybu agenta i koncepcja użycie narzędzia (lub wywołanie funkcji). Model LLM u podstaw Cursora — czy to Claude Sonnet, GPT-4o, czy Gemini — nie tylko generuje tekst: jest on szkolony rozpoznawać, kiedy do wykonania zadania konieczne jest użycie narzędzia zewnętrznego. Zamiast „wymyślać” zawartość pliku, agent może faktycznie odczytać ten plik. Zamiast wyobrażać sobie wynik polecenia, może je wykonać i odczytać wynik.
Narzędzia dostępne dla agenta Cursor obejmują:
- plik_czytania: Odczytuje zawartość określonego pliku
- zapis_pliku: Tworzy lub nadpisuje plik nową zawartością
- edycja_pliku: Zastosuj określone zmiany do części pliku
- katalog_listy: Wyświetla listę plików w katalogu
- pliki_wyszukiwania: Wyszukaj wzorce tekstowe lub semantyczne w bazie kodu
- polecenie_run_terminal_command: Wykonuje polecenia w wbudowanym terminalu
- odczyt_terminal_wyjście: Odczytuje dane wyjściowe terminala (w tym błędy)
- web_search: Wyszukaj aktualne informacje w Internecie
- utwórz_subagent: Twórz wyspecjalizowanych agentów do określonych zadań (Cursor 2.0+)
Pętla agentyczna
Tryb agenta działa poprzez: iteracyjny cykl rozumowania:
- Przestrzegać: Odczytuje kontekst (plik, strukturę projektu, istniejące błędy)
- Plan: Określ kroki potrzebne do wykonania zadania
- To działa: Skorzystaj z dostępnych narzędzi (twórz pliki, wykonuj polecenia itp.)
- Waluta: Odczytuje dane wyjściowe, sprawdza błędy, sprawdza wynik
- Brzmieć: Jeśli występują błędy, wróć do kroku 1 z nowymi informacjami
Ta pętla trwa autonomicznie aż do zakończenia zadania i zakończenia działania agenta określa, które wymagają wkładu użytkownika.
Gromadzenie kontekstu: jak agent rozumie projekt
Przed napisaniem choćby jednej linii kodu tryb agenta przeprowadza dokładną analizę kontekstu. Kursor indeksuje bazę kodu przy użyciu osadzania semantycznego, umożliwiając agentowi znalezienie plików i odpowiednie wzorce, nawet jeśli nie są one wyraźnie wymienione w podpowiedzi. To jest zasadniczo różni się od prostego grepa: agent rozumie relacje konceptualistyczny pomiędzy różnymi częściami kodu.
Na przykład, jeśli poprosisz agenta o „dodanie potwierdzenia do formularza logowania”, automatycznie się o tym dowie konieczności patrzenia na komponent logowania, formularz reaktywny, istniejące walidatory, szablony TypeScript i potencjalnie powiązane testy jednostkowe — wszystko bez konieczności określania.
Tryb zapytania, tryb edycji i tryb agenta: podstawowe różnice
Cursor oferuje trzy główne sposoby interakcji ze sztuczną inteligencją, każdy zoptymalizowany pod kątem różnych scenariuszy. Zrozumienie, kiedy używać każdego z nich, ma kluczowe znaczenie dla maksymalizacji produktywności.
Tryb Zapytaj: Rozmowa
Tryb Zapytania (dostępny za pomocą Ctrl+L / Cmd+L) i tryb konwersacyjny
Kursora. W tym trybie AI odpowiada na Twoje pytania, udzielając wyjaśnień i sugestii
i fragmenty kodu, ale nie modyfikuje bezpośrednio plików. I idealny tryb dla:
- Zrozumienie złożonych lub starszych fragmentów kodu
- Przed wdrożeniem zapoznaj się z alternatywnymi rozwiązaniami architektonicznymi
- Zadawaj pytania dotyczące konkretnych bibliotek, interfejsów API lub wzorców
- Wykonuj recenzje kodu i otrzymuj opinie na temat istniejącego kodu
- Burza mózgów na temat projektu i struktury projektu
Tryb edycji: Edycja kontekstowa
Tryb edycji (dostępny za pomocą Ctrl+K / Cmd+K) pozwala na modyfikacje
kontekstowe i ukierunkowane. Sztuczna inteligencja działa na bieżącym pliku lub konkretnym zaznaczeniu, stosując
zlokalizowane przekształcenia. Jest idealny dla:
- Refaktoryzacja pojedynczej funkcji lub klasy
- Transformacje kodu (np. konwersja funkcji na async/await)
- Dodaj dokumentację JSDoc do istniejących metod
- Napraw konkretny błąd w bieżącym pliku
- Szybkie poprawki sugerowane przez IDE
Tryb agenta: pełna automatyzacja
Tryb agenta (dostępny za pomocą Ctrl+I / Cmd+I, wybierając opcję „Agent” z pliku
menu rozwijane) i najpotężniejszy tryb. Agent może działać wiele plików,
wykonuj polecenia, iteruj po błędach i samodzielnie wykonuj złożone zadania. E
odpowiedni tryb dla:
- Implementuj kompletne funkcje obejmujące wiele plików
- Refaktoryzacja w skali kodu (np. migracja z modułów CommonJS do ES)
- Wstępna konfiguracja w pełni rusztowanych projektów
- Naprawianie błędów wymagających analizy między plikami
- Dodaj testy do istniejących komponentów
- Migracje technologii (np. z RxJS 6 do 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)
Aktywuj i skonfiguruj tryb agenta
Otwórz czat i wybierz tryb agenta
Tryb agenta jest aktywowany poprzez okno Cursor Composer. Oto kroki:
- Naciskać
Ctrl+I(Windows/Linux) lubCmd+I(macOS), aby otworzyć Composer - Z menu rozwijanego w lewym górnym rogu czatu wybierz "Agent"
- Alternatywnie, w istniejącym czacie kliknij bieżący tryb i wybierz „Agent”
Możesz także ustawić tryb agenta jako domyślny w ustawieniach kursora:
Settings > Features > Chat > Default Mode.
Wybór odpowiedniego modelu
Tryb agenta obsługuje kilka modeli LLM, każdy z różnymi funkcjami. Wybór modelu znacząco wpływa na jakość wyników:
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
Tryb YOLO: Automatyczne wykonywanie poleceń
Domyślnie tryb agenta prosi o potwierdzenie przed uruchomieniem jakichkolwiek poleceń w terminalu. Tryb YOLO usuwa ten monit o potwierdzenie, umożliwiając agentowi samodzielnie wykonywać polecenia. Aby go aktywować:
Settings > Features > Chat & Composer > Allow agent to run commands automatically
Bądź ostrożny z trybem YOLO
Tryb YOLO jest potężny, ale wymaga ostrożności. Zawsze konfiguruj tj dozwolone polecenia
określenie listy dozwolonych (np. npm test, ng build) i listę odrzuconych
(np. rm -rf, git push). Nie włączaj trybu YOLO w pomieszczeniach zamkniętych
produkcji lub na repozytoriach z wrażliwymi danymi bez prawidłowego skonfigurowania limitów.
Tryb maksymalny: rozszerzony kontekst
Wprowadzony wraz z najnowszymi aktualizacjami, Tryb maksymalny usuwa ograniczenia agresywne czyszczenie kontekstu kursora. W trybie standardowym agent ogranicza kontekst Aby poprawić responsywność, tryb Max wykorzystuje pełny kontekst dostępny w modelu. Przekłada się to na znacznie lepsze wyniki dla:
- Duże bazy kodu z wieloma zależnościami między plikami
- Złożone błędy wymagające zrozumienia wielu warstw aplikacji
- Refaktoryzacja, która musi uwzględniać wzorce architektoniczne rozproszone w projekcie
Pełne możliwości Agenta
Tworzenie i edytowanie plików
Agent może tworzyć nowe pliki i modyfikować istniejące, mając pełną świadomość struktury projektu. Nie tylko generuje izolowany kod: czyta istniejące pliki, rozumie je wzorce i generuje nowy kod zgodny ze stylem i konwencjami 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.)"
Za pomocą tego pojedynczego monitu tryb agenta zazwyczaj tworzy lub modyfikuje:
src/app/core/models/notification.model.ts(nowy)src/app/core/services/notification.service.ts(nowy)src/app/shared/components/notification/notification.component.ts(nowy)src/app/shared/components/notification/notification.component.html(nowy)src/app/shared/components/notification/notification.component.css(nowy)src/app/app.component.ts(zmodyfikowany tak, aby zawierał komponent)src/app/app.component.html(edytowano, aby dodać znacznik komponentu)src/app/core/services/notification.service.spec.ts(nowy)
Wykonywanie poleceń terminala
Tryb agenta może wykonywać polecenia we wbudowanym terminalu Cursora i odczytywać jego dane wyjściowe. To on pozwala na:
- Zainstaluj zależności za pomocą
npm install - Uruchom kompilację i przeczytaj błędy TypeScript
- Uruchom testy i iteruj, aż zaliczą
- Uruchom automatycznie linter i formatter
- Użyj Angular CLI, aby wygenerować rusztowanie
- Uruchom niestandardowe skrypty swojego projektu
Wyszukiwanie internetowe w czasie rzeczywistym
Często niedocenianą umiejętnością jest umiejętność wyszukiwania informacji w sieci wykonanie zadania. Agent może zapoznać się z oficjalną dokumentacją, wyszukać rozwiązania konkretnych błędów lub sprawdzić poprawność składni zaktualizowanych interfejsów API. Jest to szczególnie przydatne podczas pracy z bibliotekami, które często się aktualizują własne API, takie jak biblioteki Angular, RxJS czy Material Design.
Analiza błędów i samokorekta
Jedną z najpotężniejszych funkcji trybu agenta jest możliwość samokorekta. Po wygenerowaniu kodu agent uruchamia kompilację (jeśli tryb YOLO jest aktywny lub jeśli użytkownik wyrazi zgodę), odczytuje błędy TypeScriptu lub lintera i wykonuje iterację, modyfikując kod, aż ich nie będzie więcej błędów. Ta pętla sprzężenia zwrotnego radykalnie skraca czas potrzebny na przeniesienie zero błędów konstrukcyjnych.
Praktyczne przypadki użycia Angulara
Przypadek 1: Dodaj kompletną funkcję (komponent + usługa + test)
Najczęstszym przypadkiem użycia trybu agenta jest wdrożenie nowych funkcji. Zobaczmy przykład beton: dodaj system stronicowania do listy 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)
Oto kod, który agent zazwyczaj generuje dla usługi 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);
}
}
Przypadek 2: Refaktoryzacja między plikami
Jedną z najbardziej oczywistych zalet trybu agenta jest refaktoryzacja obejmująca wiele plików.
Rozważ ten scenariusz: musisz przeprowadzić migrację wszystkich komponentów projektu Angular z
ngModel do formularzy reaktywnych.
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.
Przypadek 3: Naprawianie błędów przy użyciu świadomości kontekstu
Tryb agenta doskonale radzi sobie z naprawianiem błędów, ponieważ nie ogranicza się do pliku, w którym pojawia się błąd: rozumie relacje między komponentami i usługami, aby znaleźć prawdziwą pierwotną przyczynę.
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.
W tym scenariuszu tryb agenta zazwyczaj:
- Prawo
user-settings.component.tsi określ, którego z nich używangOnInitzamiastngOnChangesotakeUntilDestroyed - Prawo
user.service.tsi stwierdza, że Obserwowalny zostaje ukończony i nie jest ponownie wydawany po subskrypcji - Prawo
app.routes.tslub moduł routingu, aby sprawdzić, czy komponent został odtworzony lub ponownie użyty - Proponuje poprawkę: użyj
ActivatedRoute.paramMapz obserwowalnym zamiastsnapshot - Wdróż poprawkę we wszystkich plikach, których dotyczy problem
- Uruchamia linter w celu sprawdzenia poprawności zmodyfikowanego kodu
Tryb agenta i zasady kursora: potężna synergia
Tryb agenta staje się wykładniczo potężniejszy w połączeniu z systemem Reguły kursora. Reguły działają jak „instrukcje systemowe”, które Cię poprowadzą agenta o tym, jak powinien działać w ramach Twojego konkretnego projektu. Bez zasad, agent generuje ogólny kod, który może nie być zgodny z konwencjami zespołu. Przy dobrze skonfigurowanych regułach wygenerowany kod jest nie do odróżnienia od zapisanego przez specjalistę-dewelopera w projekcie.
Jak reguły wpływają na tryb agenta
Zasady typu Always są wstrzykiwane na początku każdej sesji
agenta, zapewniając stały kontekst. Zasady Agent Requested przychodzą
ładowane dynamicznie, gdy agent ustali, że są one istotne dla bieżącego zadania.
Dzięki temu możesz mieć wyspecjalizowane zasady dla różnych aspektów projektu bez
niepotrzebnie zawyżają okno kontekstowe.
Zobaczmy pełny przykład konfiguracji reguł dla projektu Angular z trybem agenta.
W nowej strukturze Cursor (po wersji 0.45) reguły znajdują się w katalogu
.cursor/rules/ jako plik .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
W przypadku tej konfiguracji reguł, gdy agent otrzyma monit typu „Utwórz komponent listy zamówień” automatycznie wygeneruje:
- Samodzielny komponent z funkcją wykrywania zmian OnPush
- Sygnały dla państwa lokalnego
- input()/output() zamiast dekoratorów
- inject() do wstrzykiwania zależności
- takeUntilDestroyed() dla subskrypcji
- Odpowiedni plik testowy
- Aktualizacja pliku beczki
Wszystko to automatycznie, bez konieczności podawania tego w monicie.
Ograniczenia trybu agenta i sposoby ich przezwyciężenia
Okno kontekstowe i duże pliki
Najczęstszym ograniczeniem trybu agenta jest okno kontekstowe. Kiedy baza kodu i bardzo duży, agent może nie mieć wystarczającej ilości miejsca, aby załadować wszystkie pliki istotne jednocześnie. Może to prowadzić do niespójnych zmian lub strat kontekstu pomiędzy różnymi częściami zadania.
Strategie zarządzania oknem kontekstowym
- Podziel duże zadania: Zamiast pojedynczego monitu o megazadanie, podziel go pracuj w logicznych krokach. Zakończ i sprawdź każdy krok przed przejściem do następnego.
-
Użyj @file dla wyraźnego kontekstu: Wyraźnie wskaż odpowiednie pliki
z
@nomefilew monicie, aby pomóc agentowi w ustaleniu priorytetu kontekstu. - Aktywuj tryb maksymalny: W przypadku złożonych zadań wymagających dużego kontekstu, Tryb Max ogranicza agresywne przycinanie i poprawia jakość wyników.
-
Utwórz dokumenty kontekstowe: W przypadku bardzo dużych projektów utwórz pliki
ARCHITECTURE.mdoCONTEXT.mdktóre podsumowują strukturę projektu. Agent może je odczytać na początku zadania.
Potencjalnie destrukcyjne działania
Tryb agenta może modyfikować lub usuwać krytyczne pliki, jeśli nie zostanie odpowiednio poprowadzony. Niektóre kluczowe środki zapobiegawcze:
-
Zatwierdź przed delegowaniem do agenta: Zawsze dokonuj zatwierdzenia lub ukrycia
zmian przed uruchomieniem trybu agenta w przypadku ważnych zadań. To pozwala
aby powrócić do poprzedniego stanu za pomocą prostego
git checkout. - Użyj reguł, aby zdefiniować chronione pliki: Dodaj regułę wskazującą agentowi pliki, których nie wolno mu nigdy modyfikować (np. krytyczne pliki konfiguracyjne, plik migracji bazy danych).
- Sprawdź przed złożeniem wniosku: Kursor zawsze pokazuje różnicę proponowanych zmian przed ich zastosowaniem. Poświęć trochę czasu na recenzję, szczególnie dla plików krytycznych, takich jak konfiguracje lub schemat bazy danych.
Błędy w rozumowaniu i halucynacje
Jak każdy system sztucznej inteligencji, tryb agenta może popełniać błędy. Może „halucynować” nieistniejące interfejsy API, używać przestarzałych wersji bibliotek lub błędnie interpretować niejednoznaczne wymagania. Środki zaradcze:
- Konkretne podpowiedzi: Im bardziej szczegółowy będzie Twój monit, tym mniej i margines na błędną interpretację. Dołącz wersje bibliotek, wzorce ulubione i wyraźne ograniczenia.
- Włącz wyszukiwanie w Internecie: Pozwól agentowi zapoznać się z dokumentacją aktualizacja znacznie zmniejsza ryzyko korzystania z przestarzałych API.
- Sprawdź dane wyjściowe: Nigdy nie wprowadzaj zmian bez ich przejrzenia. Jest to szczególnie ważne w przypadku krytycznej logiki biznesowej lub kodu bezpieczeństwa.
Nie deleguj kodu bezpieczeństwa agentowi bez sprawdzenia
Uwierzytelnianie, autoryzacja, szyfrowanie i zarządzanie sekretami to obszary gdzie sztuczna inteligencja może wygenerować kod, który jest funkcjonalnie poprawny, ale ma luki w zabezpieczeniach cienki. Recenzja Zawsze uważnie kod bezpieczeństwa wygenerowany przez agenta i, jeśli to możliwe, zlecić jego sprawdzenie ekspertowi ds. bezpieczeństwa.
Tryb agenta kontra agent GitHub Copilot kontra Claude Code
Krajobraz agentów AI do tworzenia oprogramowania w latach 2025–2026 jest konkurencyjny. Zobaczmy, jak tryb agenta kursora wypada w porównaniu z wiodącymi alternatywami.
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 kursora: mocne strony
Główną zaletą Cursora jestnatywna integracja pomiędzy IDE, agentem, i system Zasad. Agent ma dostęp do całej bazy kodu indeksowanej semantycznie, możesz edytować pliki bezpośrednio w edytorze, wykonywać polecenia w wbudowanym terminalu, i iteruj po błędach w zamkniętej pętli. Możliwość zarządzania maksymalnie 8 równoległymi agentami z drzewami roboczymi git (wprowadzonymi w Cursorze 2.0) pozwala na eksplorację implementacji alternatywy równolegle.
Agent drugiego pilota GitHub: mocne strony
Copilot Agent, zintegrowany bezpośrednio z GitHub Workflow, wyróżnia się rozdzielczością samodzielne problemy z GitHubem. Potrafi bezpośrednio otworzyć PR, pracować nad zdefiniowanymi zadaniami w problemach i natywnie integrować się z procesami przeglądu kodu GitHub. W przypadku zespołów już pracujących w ekosystemie GitHub ten przepływ pracy jest bardzo płynny.
Claude Code: Mocne strony
Claude Code (narzędzie CLI firmy Anthropic, różniące się od dostępu do Claude przez API) świeci za to elastyczność i głębokie rozumowanie w przypadku złożonych zadań. Działa dobrze w przypadku długotrwałych zadań, analiz architektury i sytuacji, w których jest to potrzebne maksymalną jakość rozumowania, a nie szybkość wykonania. To może być zintegrowany z dowolnym IDE poprzez terminal.
Kiedy wybrać co
- Agent kursora: Codzienny rozwój, wdrażanie funkcjonalności, refaktoryzacja, debugować. Najlepszy wybór dla tych, którzy chcą zintegrowanego środowiska IDE.
- Agent drugiego pilota: Zespół zorientowany na GitHub, automatyczne rozwiązywanie problemów, Proces PR. Idealny jako uzupełnienie Cursora dla warstwy GitHub.
- Kod Claude'a: Zadania wymagające dużego rozumowania, analizy architektoniczne, automatyzacja skryptów, środowiska, w których nie można zmienić IDE.
Najlepsze praktyki dotyczące trybu agenta
1. Sztuka skutecznej podpowiedzi
Jakość danych wyjściowych w trybie agenta jest wprost proporcjonalna do jakości podpowiedzi. Niejasny monit generuje ogólny kod; określony monit generuje kod, który wygląda jak napisany przez kogoś, kto zna projekt od podszewki.
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. Używaj częstych punktów kontrolnych Git
Przed każdą sesją trybu agenta dotyczącą ważnych zadań utwórz punkt kontrolny 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. Przejrzyj przed złożeniem wniosku
Kursor zawsze pokazuje różnicę zmian zaproponowanych przez agenta. Zawsze bierz siebie poświęć trochę czasu na zapoznanie się z tymi zmianami, szczególnie w przypadku:
- Pliki konfiguracyjne (angular.json, tsconfig.json, package.json)
- Kod uwierzytelniający i autoryzacyjny
- Pliki migracji bazy danych
- Krytyczna logika biznesowa
- Zmienne środowiskowe i wrażliwe konfiguracje
4. Powtórz i udoskonal zadanie
Nie oczekuj, że tryb agenta wykona złożone zadania za pomocą jednego doskonałego monitu. Najbardziej produktywny i iteracyjny przepływ pracy:
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. Skonfiguruj reguły specyficzne dla agenta
Jak widzieliśmy w poprzedniej sekcji, Reguły są mnożnikiem produktywności potężniejszy w trybie agenta. Poświęć czas na budowanie dobrych podstaw reguł dla swojego projektu. Dobra zasada: zawsze, gdy poprawisz coś, co agent zrobił „źle”, szanujesz do konwencji projektu, dodaj tę poprawkę jako Rule.
Profesjonalny przepływ pracy w trybie agenta
Typowy dzień programisty w trybie agenta
Zobaczmy, jak tryb agenta integruje się z codzienną pracą programisty 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
Wzorzec: Tryb agenta do wspomaganego przeglądu kodu
Mniej oczywiste, ale bardzo skuteczne wykorzystanie trybu agenta i wspomaganego przeglądu kodu. Przed wykonaniem PR poproś agenta o sprawdzenie Twojej pracy:
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
Integracja z trybem planu
W przypadku szczególnie skomplikowanych zadań połącz Tryb Agenta z Tryb planu (co omówimy w następnym artykule z tej serii). Tryb planowania pozwala agentowi najpierw utwórz ustrukturyzowany plan pracy, który możesz najpierw przejrzeć i zatwierdzić niech rozpocznie się egzekucja. Jest to szczególnie przydatne w przypadku:
- Migracje ważnych frameworków lub bibliotek
- Przekrojowe implementacje funkcji, które dotyczą wielu plików
- Znaczące refaktoryzacje architektoniczne
- Wstępna konfiguracja nowych projektów lub modułów
Tryb agenta w Cursor 2.0: Nowe granice
Cursor 2.0, wydany pod koniec 2025 roku, wprowadził znaczące ulepszenia w trybie agenta. Funkcje te reprezentują przyszłość rozwoju opartego na sztucznej inteligencji.
Agenci równoległi z drzewami roboczymi Git
Najbardziej rewolucyjną cechą Cursora 2.0 jest możliwość wykonania do 8 agentów równolegle, każdy działający na oddzielnym drzewie roboczym Git. Każdy agent działa w izolacji, co pozwala na badanie alternatywnych implementacji jednocześnie bez zakłóceń.
Wyobraź sobie, że musisz wybierać pomiędzy trzema różnymi podejściami do wdrożenia krytycznej funkcji. W przypadku agentów równoległych można jednocześnie uruchomić trzech agentów, każdy z rozszerzeniem inny monit określający inne podejście. Po 15-20 minutach masz trzy kompletne wdrożenia, aby porównać i wybrać najlepszą.
Agenci w tle
Agenci działający w tle Cursor 2.0 umożliwiają delegowanie zadań długoterminowych które działają w tle, podczas gdy Ty pracujesz nad innymi rzeczami. Możesz uruchomić agenta aby „zaktualizować wszystkie testy w projekcie dla nowej wersji Angulara” i w międzyczasie kontynuuj rozwój funkcji. Agent powiadomi Cię, kiedy zostało ukończone lub kiedy wymaga wprowadzenia danych.
Wyspecjalizowani subagenci
Tryb agenta obsługuje teraz tworzenie wyspecjalizowanych subagentów. Agent „organizator”. potrafi delegować określone części zadania wyspecjalizowanym subagentom: jednego do pisania testów, jeden do optymalizacji wydajności, drugi do dokumentacji. Subagentów można skonfigurować z różnymi modelami, regułami i dostępem do narzędzi przez głównego agenta.
Wnioski i dalsze kroki
Tryb agenta kursora stanowi jeden z najbardziej znaczących skoków w produktywności dostępne już dziś dla programistów. Tu nie chodzi o to, że „AI napisze za ciebie kod”, ale z inteligentny współpracownik co przyspiesza Twoją pracę, zarządza złożonością techniczną i uwalnia Twój czas, który możesz poświęcić na skupienie się architektura, projektowanie i decyzje o wysokiej wartości.
Kluczowe punkty do zapamiętania:
- Tryb agenta = LLM + użycie narzędzia + kontekst: To nie magia, to system dobrze zaprojektowany, w którym sztuczna inteligencja wykorzystuje konkretne narzędzia do interakcji z bazą kodu.
- Jakość podpowiedzi określa jakość wyniku: Podpowiedzi specyficzne, kontekstowe i posiadające wyraźne ograniczenia, przynoszą znaczące rezultaty lepsze niż niejasne podpowiedzi.
- Reguły kursora to mnożnik produktywności: Dobry Konfiguracja reguł przekształca agenta z „ogólnej sztucznej inteligencji” w „eksperta programisty”. Twojego konkretnego projektu”.
- Zawsze sprawdź przed zastosowaniem: Tryb agenta jest narzędziem potężny, ale nie nieomylny. Twoja krytyczna i fundamentalna recenzja, zwł dla kodu bezpieczeństwa i krytycznej logiki biznesowej.
- Iteruj małymi krokami: Najbardziej efektywny przepływ pracy polega na podziale zadań złożone w iteracyjnych krokach, z przeglądem i zatwierdzaniem na każdym kroku.
Kontynuuj serię: Następny artykuł
W następnym artykule z serii będziemy się nad tym zastanawiać Tryb planu i agenci działający w tle: jak wykorzystać planowanie strukturalne w przypadku złożonych zadań i jak delegować pracę do agentów działających w tle Cursor 2.0, aby zmaksymalizować produktywność. Jeśli tryb agenta i silnik, tryb Plan i kierownica.
Powiązane artykuły z serii
- Reguły kursora (artykuł 2): Dowiedz się więcej o konfiguracji systemu reguł, aby wzmocnić tryb agenta w konkretnym projekcie.
- Tryb planu i agenci działający w tle (artykuł 4): Następny krok automatyzować nawet bardziej złożone zadania dzięki ustrukturyzowanemu planowaniu.
- MCP i kursor (art. 6): Jak podłączyć tryb agenta do baz danych, zewnętrznych interfejsów API i narzędzi niestandardowych za pośrednictwem protokołu Model Context Protocol.
- Profesjonalny przepływ pracy Angular (artykuł 9): Projekt Angularowy kompletny opracowany w całości w trybie Cursor Agent, od stworzenia do wdrożenia.