Un workflow è una catena di controlli, non di prompt
Con Cursor puoi generare una feature Angular in pochi minuti, e il rischio è lo stesso di sempre: il codice sembra giusto e non lo è. Un workflow professionale è quello in cui ogni passo ha un controllo che non dipende dall'agente: le regole che dichiarano come si scrive il codice, un compito con un criterio di fine verificabile, test che falliscono se la logica si rompe, una build che dice la verità sulle dimensioni, una CI che ripete tutto a ogni push. Questo articolo percorre la catena su un progetto vero, un elenco di task con aggiornamento ottimistico, e tutto il codice è stato compilato ed eseguito con Angular 22.2.6.
Fa da chiusura alla serie: i singoli strumenti li hai visti uno per uno, dalle regole all'Agent Mode, dal Plan Mode agli hook, da MCP al debugging. Qui li metti in fila. Una precisazione onesta: il codice dell'articolo l'ho scritto io, a mano, e l'ho provato; non è l'uscita di una sessione di Cursor. Serve come riferimento con cui confrontare ciò che il tuo agente produce.
Passo 1: le regole del progetto, in un file che ogni agente legge
Il primo investimento è un file di istruzioni nella radice del progetto. Conviene AGENTS.md,
perché la documentazione delle regole di Cursor
lo accetta come alternativa semplice a .cursor/rules, e perché lo leggono anche altri strumenti (lo
vedi nel confronto fra i tre prodotti). Il comando
ng new può generarne uno per te: con --ai-config=cursor la CLI 22.2.7 ha creato nella
prova un AGENTS.md con le buone pratiche Angular e un .cursor/mcp.json che collega
l'editor al server MCP della CLI. Le scelte accettate dall'opzione sono claude-code, cursor, gemini-cli,
open-ai-codex, vscode e none.
Il file generato è un punto di partenza, e vale la pena leggerlo perché dice che cosa Angular raccomanda oggi:
niente standalone: true nei decoratori, perché è il comportamento predefinito dalla versione 20;
niente ChangeDetectionStrategy.OnPush esplicito, perché da Angular 22 è il predefinito; segnali per lo
stato; inject() al posto dell'iniezione nel costruttore; control flow nativo al posto di
*ngIf e *ngFor; e, per i nuovi servizi singleton, il decoratore @Service() al posto
di @Injectable({ providedIn: 'root' }). Un agente che non conosce le versioni recenti tende a
scrivere la sintassi vecchia, cioè il contrario di ogni riga, ed è per questo che le regole contano.
Sopra quella base si aggiungono le regole del tuo progetto. Il file qui sotto ne mette sette, ognuna con un motivo: le prime quattro fissano come si scrive il codice, le ultime tre il controllo di fine lavoro, che è la parte che nessun generatore scrive per te.
# Regole del progetto task-dashboard
- Angular 22: componenti standalone, stato con signal() e computed(), nessun NgModule.
- Lo stato scrivibile resta privato nel servizio ed esce con asReadonly().
- Gli array non si modificano mai in place: si crea una copia con map, filter o spread.
Cosi' il rollback di un aggiornamento ottimistico e' un semplice set() del valore precedente.
- Nei template: @if, @for e @empty; @for ha sempre track su un id stabile.
- Ogni servizio nuovo ha uno spec con HttpTestingController e httpMock.verify().
- Prima di dichiarare finito un compito, esegui `npx ng test --no-watch` e `npx ng build`
e riporta quanti test sono stati eseguiti. Se uno dei due fallisce, il compito non e' finito.
- Non modificare angular.json, package.json o i test esistenti senza chiederlo.
La regola sulla copia degli array e quella sul controllo finale sono legate. Se lo stato non si modifica
mai sul posto, un aggiornamento ottimistico si annulla rimettendo la vecchia istantanea, come vedrai nel
servizio. E se «finito» significa che ng test e ng build passano, l'agente non può
chiudere un compito che non compila. Per il formato .mdc e per le regole che si attivano per
percorso rimando al secondo articolo della serie.
Passo 2: il progetto, con comandi che non hanno bisogno di un agente
Creare un workspace è un'operazione deterministica: non c'è niente da delegare e una sessione di agente qui è
solo un modo lento di lanciare un comando. L'unica nota è sul runtime: Angular 22 richiede Node
^22.22.3, ^24.15.0 oppure 26 e successivi; con un Node 24.11 la CLI si ferma con un messaggio chiaro.
Il progetto generato ha tre caratteristiche che cambiano il modo di lavorare con l'agente: Vitest come test
runner predefinito, con jsdom (lo dice la guida ai test), zoneless
come comportamento predefinito dalla versione 21 (guida zoneless)
e, nel angular.json della build di produzione, soglie di dimensione a 500 kB (avviso) e 1 MB (errore).
# Node 24.19.0 (Angular 22 richiede ^22.22.3, ^24.15.0 o >=26)
npx @angular/cli@22 new task-dashboard --ai-config=cursor --style=css --ssr=false --skip-git --defaults
cd task-dashboard
npx ng test --no-watch
npx ng build
# Output di "ng test --no-watch" (Angular 22.2.6, Vitest 5.1.0, TypeScript 6.0.3; la durata varia, ~1 s):
# Test Files 3 passed (3)
# Tests 5 passed (5)
#
# Output di "ng build" (stesse dimensioni in due esecuzioni; dopo la prima feature con route lazy):
# Initial total | 221.96 kB | 62.02 kB di trasferimento stimato
# Lazy chunk "task-list" | 1.92 kB | 928 byte di trasferimento stimato
I numeri nei commenti vengono dalle mie esecuzioni, non da una guida. Dopo la feature con route lazy il
pacchetto iniziale pesa 221,96 kB (62,02 kB trasferiti, stima della CLI) e la route task-list, in un
chunk a parte, 1,92 kB. Sono valori di un progetto minimo: servono a mostrarti dove leggere le tue misure, non
a fissare un obiettivo. Quando la build supera una soglia la CLI avvisa o fallisce, e questo è il controllo che
impedisce a una dipendenza aggiunta senza che tu lo sappia di gonfiare il pacchetto in silenzio.
Passo 3: il compito, scritto come un contratto
Un prompt efficace non è lungo, è verificabile. Dice che cosa deve succedere, quali vincoli valgono, che cosa non va toccato e come si controlla il risultato. Quello sotto chiede la funzione più delicata della feature, l'aggiornamento ottimistico di uno stato, e chiude con il comando di verifica: l'agente lo esegue e incolla l'uscita, tu la leggi. È uno schema da adattare, non un'uscita di Cursor.
Leggi AGENTS.md. Nella cartella src/app/features/tasks/ aggiungi la possibilita' di
cambiare lo stato di un task.
Cosa deve fare: updateStatus(id, status) nel TaskService aggiorna subito il signal, poi
chiama PATCH /api/tasks/:id; se il server risponde con un errore ripristina lo stato
precedente e imposta il signal error.
Vincoli: segui AGENTS.md; non toccare gli spec esistenti; aggiungi gli spec per i tre casi
(successo, aggiornamento immediato, rollback su errore).
Controllo finale: esegui npx ng test --no-watch e npx ng build e incolla l'uscita.
Tre scelte meritano una spiegazione. «Non toccare gli spec esistenti» impedisce all'agente di far passare il test modificando il test, un vizio frequente quando un controllo fallisce. Elencare i tre casi da coprire toglie all'agente la libertà di scrivere un solo test felice. E richiedere l'uscita incollata sposta il carico della prova: se il numero di test non c'è, il compito non è dimostrato. Se la funzione è più grande di così, comincia col Plan Mode e rivedi il piano prima di lasciare che scriva.
Il codice di riferimento: modello, servizio, componente
Modello e servizio con segnali
Il modello è un tipo di unione e un'interfaccia con proprietà readonly: lo stato di un task non
si modifica, si sostituisce.
export type TaskStatus = 'todo' | 'in-progress' | 'done';
export interface Task {
readonly id: string;
readonly title: string;
readonly status: TaskStatus;
}
Il servizio tiene i due segnali scrivibili privati e li espone con asReadonly(), come la
guida ai segnali consiglia per non permettere
ai consumatori di modificare lo stato. Il cuore è updateStatus: salva l'istantanea del valore
corrente, sostituisce l'array con una copia in cui cambia un solo elemento, poi invia la richiesta. Se il server
risponde con un errore, set(prima) ripristina tutto.
import { HttpClient } from '@angular/common/http';
import { Service, computed, inject, signal } from '@angular/core';
import { Task, TaskStatus } from './task.model';
const API_URL = '/api/tasks';
@Service()
export class TaskService {
private readonly http = inject(HttpClient);
// Lo stato scrivibile resta privato; fuori dal servizio si legge soltanto
private readonly _tasks = signal<readonly Task[]>([]);
private readonly _error = signal<string | null>(null);
readonly tasks = this._tasks.asReadonly();
readonly error = this._error.asReadonly();
readonly completionRate = computed(() => {
const tutti = this._tasks();
if (tutti.length === 0) return 0;
return Math.round((tutti.filter((t) => t.status === 'done').length / tutti.length) * 100);
});
loadTasks(): void {
this.http.get<Task[]>(API_URL).subscribe({
next: (tasks) => this._tasks.set(tasks),
error: () => this._error.set('Impossibile caricare i task'),
});
}
updateStatus(id: string, status: TaskStatus): void {
const prima = this._tasks(); // istantanea: l'array non viene mai modificato in place
this._tasks.set(prima.map((t) => (t.id === id ? { ...t, status } : t)));
this.http.patch<Task>(`${API_URL}/${id}`, { status }).subscribe({
error: () => {
this._tasks.set(prima); // rollback: basta rimettere l'istantanea
this._error.set('Aggiornamento non riuscito');
},
});
}
}
Il rollback funziona solo perché nessuno ha modificato l'array di partenza. Se avessi usato
push o assegnato task.status = status su un oggetto dell'array, prima e lo
stato nuovo sarebbero lo stesso oggetto e non ci sarebbe niente da ripristinare. È un difetto classico, e si vede con un test sul rollback, non leggendo il codice. @Service() è
l'alternativa a @Injectable({ providedIn: 'root' }) che la CLI 22 raccomanda per i nuovi servizi
singleton; con una versione di Angular precedente la 22 si usa ancora @Injectable.
Il componente
Il componente non dichiara standalone: true né changeDetection: in Angular 22
il primo è implicito e il secondo è OnPush per impostazione predefinita, come riporta la documentazione
dell'API ChangeDetectionStrategy. Il template usa @if per l'errore, @for con
track task.id e @empty per l'elenco vuoto. L'espressione track è ciò che permette ad
Angular di riusare i nodi del DOM invece di ricrearli (guida al control flow): con track $index, se la lista cambia ordine, lo stato locale di una riga (il focus, il testo digitato) resta sulla posizione invece di seguire il task.
import { Component, inject } from '@angular/core';
import { Task } from './task.model';
import { TaskService } from './task.service';
@Component({
selector: 'app-task-list',
template: `
@if (service.error(); as messaggio) {
<p role="alert">{{ messaggio }}</p>
}
<p>Completati: {{ service.completionRate() }}%</p>
<ul>
@for (task of service.tasks(); track task.id) {
<li>
<label>
<input type="checkbox" [checked]="task.status === 'done'" (change)="toggle(task)" />
{{ task.title }}
</label>
</li>
} @empty {
<li>Nessun task</li>
}
</ul>
`,
})
export class TaskList {
protected readonly service = inject(TaskService);
constructor() {
this.service.loadTasks();
}
protected toggle(task: Task): void {
this.service.updateStatus(task.id, task.status === 'done' ? 'todo' : 'done');
}
}
Il servizio è protected perché il template deve leggerlo ma il resto del programma no; la
casella si legge da task.status e non da uno stato locale, quindi la vista segue sempre il
segnale. Che cosa va storto qui: il caricamento nel costruttore va bene per un esempio, ma in un componente
con parametri di route conviene un'inizializzazione che dipenda dall'input.
Passo 4: i test che l'agente non può aggirare
I test usano provideHttpClient() prima di provideHttpClientTesting(), nell'ordine che la
guida ai test HTTP raccomanda perché il
secondo sovrascrive parti del primo, e chiudono con http.verify(), che fa fallire il test se resta
una richiesta non prevista. Il test del servizio copre i tre casi del contratto.
import { provideHttpClient } from '@angular/common/http';
import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
import { TestBed } from '@angular/core/testing';
import { Task } from './task.model';
import { TaskService } from './task.service';
const DATI: Task[] = [
{ id: '1', title: 'Scrivere le regole', status: 'todo' },
{ id: '2', title: 'Configurare la CI', status: 'done' },
];
describe('TaskService', () => {
let service: TaskService;
let http: HttpTestingController;
beforeEach(() => {
TestBed.configureTestingModule({ providers: [provideHttpClient(), provideHttpClientTesting()] });
service = TestBed.inject(TaskService);
http = TestBed.inject(HttpTestingController);
});
afterEach(() => http.verify());
it('carica i task e calcola la percentuale di completamento', () => {
service.loadTasks();
http.expectOne('/api/tasks').flush(DATI);
expect(service.tasks()).toEqual(DATI);
expect(service.completionRate()).toBe(50);
});
it('aggiorna subito lo stato, prima della risposta del server', () => {
service.loadTasks();
http.expectOne('/api/tasks').flush(DATI);
service.updateStatus('1', 'done');
expect(service.completionRate()).toBe(100);
http.expectOne('/api/tasks/1').flush({ ...DATI[0], status: 'done' });
expect(service.completionRate()).toBe(100);
});
it('ripristina lo stato precedente se il server rifiuta', () => {
service.loadTasks();
http.expectOne('/api/tasks').flush(DATI);
service.updateStatus('1', 'done');
http.expectOne('/api/tasks/1').flush('errore', { status: 500, statusText: 'Server Error' });
expect(service.tasks()).toEqual(DATI);
expect(service.error()).toBe('Aggiornamento non riuscito');
});
});
Il secondo test è il più importante: controlla che la percentuale salga a 100 prima di rispondere alla richiesta, cioè che l'aggiornamento sia davvero ottimistico. Il terzo controlla il ripristino. Per sapere se un test vale qualcosa conviene romperlo apposta: ho tolto la riga del rollback e due test su cinque sono falliti, uno del servizio e uno del componente. Se tutti fossero rimasti verdi, avrei avuto la prova che non controllavano niente.
import { provideHttpClient } from '@angular/common/http';
import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
import { TestBed } from '@angular/core/testing';
import { TaskList } from './task-list';
describe('TaskList', () => {
it('mostra i task, aggiorna subito la casella e torna indietro su errore', async () => {
TestBed.configureTestingModule({ providers: [provideHttpClient(), provideHttpClientTesting()] });
const http = TestBed.inject(HttpTestingController);
const fixture = TestBed.createComponent(TaskList);
const el = fixture.nativeElement as HTMLElement;
http.expectOne('/api/tasks').flush([{ id: '1', title: 'Scrivere le regole', status: 'todo' }]);
await fixture.whenStable();
const casella = el.querySelector('input') as HTMLInputElement;
expect(el.textContent).toContain('Scrivere le regole');
expect(casella.checked).toBe(false);
casella.click(); // l'utente spunta il task
await fixture.whenStable();
expect(casella.checked).toBe(true);
expect(el.textContent).toContain('Completati: 100%');
http.expectOne('/api/tasks/1').flush('errore', { status: 500, statusText: 'Server Error' });
await fixture.whenStable();
expect(casella.checked).toBe(false);
expect(el.querySelector('[role="alert"]')?.textContent).toContain('Aggiornamento non riuscito');
http.verify();
});
});
Il test del componente simula l'utente: casella.click() cambia la casella, whenStable()
lascia completare l'aggiornamento della vista, e poi si verifica il DOM, non il segnale. È il livello giusto per
catturare un errore tipico, cioè un servizio corretto collegato male al template. I test
Playwright end-to-end servono a un altro scopo e non fanno parte di questo esempio.
Passo 5: route lazy e configurazione
La route usa loadComponent con un import dinamico: Angular mette il componente in un chunk separato,
e infatti la build ne ha mostrato uno da 1,92 kB. La configurazione aggiunge provideHttpClient(withFetch()),
che usa l'API fetch del runtime ed è la forma che serve se un giorno attivi il rendering lato server.
import { Routes } from '@angular/router';
export const routes: Routes = [
{ path: '', pathMatch: 'full', redirectTo: 'tasks' },
{
path: 'tasks',
// Il componente finisce in un chunk separato, scaricato solo quando serve
loadComponent: () => import('./features/tasks/task-list').then((m) => m.TaskList),
title: 'Task',
},
];
import { provideHttpClient, withFetch } from '@angular/common/http';
import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
import { provideRouter } from '@angular/router';
import { routes } from './app.routes';
export const appConfig: ApplicationConfig = {
providers: [
provideBrowserGlobalErrorListeners(),
provideHttpClient(withFetch()),
provideRouter(routes),
],
};
Il rapporto fra i due file è questo: app.routes.ts decide quale codice viene scaricato e quando,
app.config.ts decide quali servizi esistono. Se l'agente aggiunge un servizio HTTP e dimentica il
provider, il test del servizio passa (ha i suoi provider) e l'app in esecuzione fallisce: per questo conviene
almeno un test che avvii il componente radice con la configurazione reale.
Passo 6: la CI ripete i controlli a ogni push
I controlli locali valgono finché qualcuno li esegue. Il workflow qui sotto li ripete a ogni push su
main e a ogni pull request: installa le dipendenze con npm ci, esegue i test e la
build, e annulla le esecuzioni superate dello stesso ramo. Le versioni delle azioni sono quelle correnti
al 2026-11-13 secondo le pagine delle release (checkout 7.0.1, setup-node 7.1.0, tag principale v7). È uno schema da
adattare: non l'ho eseguito su GitHub, ho solo validato la sintassi YAML.
# .github/workflows/ci.yml
name: CI
on:
push:
branches: [main]
pull_request:
concurrency:
group: ci-${{ github.ref }}
cancel-in-progress: true
jobs:
verifica:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: actions/setup-node@v7
with:
node-version: 24
cache: npm
- run: npm ci
- run: npx ng test --no-watch
- run: npx ng build
Il Node della CI deve soddisfare lo stesso requisito della tua macchina, per questo
node-version: 24 e non una versione fissa che invecchia. Sul resto, il deploy dipende dal tuo
hosting e non lo propongo in astratto: questo progetto è solo browser e produce la cartella
dist/task-dashboard; con il rendering lato server (--ssr) cambiano il server e il modo di
pubblicare, non il metodo. La pubblicazione vera e propria la lasci a un passo separato, che lanci tu dopo i controlli.
Dove l'agente sbaglia, e come lo vedi in revisione
Le correzioni da cercare in revisione, su un progetto come questo, sono in pratica queste cinque. Leggile come la scaletta della tua revisione.
- Stato modificato sul posto (
push, assegnazione a un campo): il rollback e i segnali smettono di funzionare. - Sintassi di una versione vecchia:
*ngIf,standalone: trueridondante,@Injectabledove la regola dice@Service(). - Test che non verificano nulla, o che l'agente ha modificato per farli passare.
- Dipendenze o file di configurazione toccati senza che tu l'abbia chiesto.
- Una build che passa perché una soglia di dimensione è stata alzata.
Ognuna di queste righe ha un antidoto nel workflow: le regole, il contratto del prompt, il test su rollback, il divieto di toccare i test e la configurazione. Quando l'agente sbaglia in modo nuovo, non rimproverare il prompt: aggiungi una regola, così la volta dopo l'errore non passa. Per il caso in cui sei tu a dover trovare la causa di un guasto, il metodo è nel settimo articolo.
Collegare Cursor alla CLI di Angular con MCP
L'ultima mossa riguarda il controllo di fine lavoro. La CLI di Angular include un server MCP, descritto come
sperimentale nella documentazione, che dà all'agente
strumenti come get_best_practices (le regole allineate alla versione), list_projects e
run_target, con cui eseguire test o build direttamente. L'argomento
--read-only registra solo gli strumenti che non modificano il progetto. È lo stesso file che
ng new --ai-config=cursor ha creato (npx -y @angular/cli mcp); come si configura e come si
mette in sicurezza un server MCP lo spiega il sesto articolo.
L'avvertenza non cambia: npx -y esegue l'ultima versione pubblicata, quindi lo strumento va
trattato come codice di terzi.
Che cosa sai fare adesso
Sai impostare un progetto Angular per lavorarci con un agente: regole in AGENTS.md, un compito
scritto come contratto con un controllo di fine lavoro, test che hai verificato rompendoli di proposito, una build
con soglie di dimensione e una CI che ripete tutto. Sai anche che cosa guardare in revisione. Non troverai in
queste pagine una percentuale di tempo risparmiato: dipende dal progetto e dal compito, e l'unico numero che vale
è quello che misuri tu, con lo stesso compito svolto con e senza agente, come descrive il
confronto fra gli strumenti. Per ripartire dall'inizio della serie c'è la
guida completa a Cursor.
Domande frequenti
Come si fa a far seguire a Cursor le convenzioni Angular del progetto?
Con un file di istruzioni letto dall'agente. ng new --ai-config=cursor genera un AGENTS.md con le pratiche raccomandate da Angular; ci aggiungi le regole del tuo progetto e il controllo di fine lavoro, cioè eseguire test e build prima di dichiarare finito.
Serve scrivere standalone: true e OnPush nei componenti di Angular 22?
No. Standalone è il comportamento predefinito dalla versione 20 e OnPush lo è da Angular 22, quindi dichiararli è ridondante. In un progetto più vecchio vanno invece indicati, e la regola nel file di istruzioni deve dire quale versione usi.
Come si verifica che un test generato da un agente valga qualcosa?
Rompendo il codice di proposito. Se togli la riga che il test dovrebbe proteggere e il test resta verde, non controlla niente. Nel servizio dell'articolo, togliere il rollback ha fatto fallire due test su cinque.
Fonti
- Angular: Angular CLI MCP Server setup - strumenti del server (
run_target,get_best_practices), opzione--read-only, natura sperimentale, consultata il 2026-11-13 - Angular: Develop with AI - configurazioni per gli assistenti AI, fra cui Cursor, consultata il 2026-11-13
- Angular: Testing - Vitest e jsdom come impostazione predefinita dei nuovi progetti, consultata il 2026-11-13
- Angular: Zoneless - zoneless predefinito dalla versione 21, consultata il 2026-11-13
- Angular, API: ChangeDetectionStrategy - OnPush abilitato per impostazione predefinita, consultata il 2026-11-13
- Angular: Control flow -
@for,tracke@empty, consultata il 2026-11-13 - Angular: Signals -
asReadonly()per esporre un segnale senza permettere di modificarlo, consultata il 2026-11-13 - Angular: Testing HTTP requests - ordine di
provideHttpClienteprovideHttpClientTesting, consultata il 2026-11-13 - Cursor, documentazione: Rules -
AGENTS.mdcome alternativa a.cursor/rules, consultata il 2026-11-13 - actions/checkout: Releases - ultima versione 7.0.1 (2026-07-20), consultata il 2026-11-13
- actions/setup-node: Releases - ultima versione 7.1.0 (2026-10-08), consultata il 2026-11-13
Il progetto è stato creato con @angular/cli 22.2.7 (Angular 22.2.6, TypeScript 6.0.3, Vitest 5.1.0) in una cartella temporanea, con Node 24.19.0. I cinque test sono stati eseguiti due volte e la build due volte, con le stesse dimensioni. Il workflow YAML è stato validato come sintassi ma non eseguito su GitHub; l'AGENTS.md e il prompt sono schemi da adattare e non sono stati dati a Cursor, che non è installato nella macchina di prova.

Commenti
Caricamento commenti...
Accedi per commentare