Il problema: l'assistente riparte da zero a ogni conversazione
Per la terza volta questa settimana hai chiesto a Cursor un componente Angular e per la terza volta ti ha risposto con
i decoratori @Input al posto delle funzioni input() che usi nel progetto. Non è distrazione:
un modello linguistico non conserva memoria da una richiesta all'altra, e le convenzioni che il tuo team ha in testa non
stanno scritte da nessuna parte che lui possa leggere. Le regole di Cursor servono a questo: sono istruzioni
persistenti che Cursor include all'inizio del contesto del modello, e quindi lo stesso suggerimento che daresti a un
collega nuovo il primo giorno, scritto una volta in un file e ripetuto da solo a ogni conversazione.
Questo articolo spiega come sono fatte le regole oggi, secondo la documentazione ufficiale letta il 2026-11-13: i quattro tipi, i tre campi che decidono quando una regola entra nel contesto, un esempio completo con un piccolo programma che applica la tabella di decisione ai tuoi file, e gli errori che fanno sì che una regola sembri non funzionare. Se non hai ancora visto come si lavora con l'Agent, parti dalla guida di apertura della serie.
Quattro tipi di regola, quattro posti dove vivono
La pagina delle regole elenca quattro tipi, che si distinguono per chi li possiede e per dove sono salvati.
- Regole di progetto: file in
.cursor/rules, versionati con il codice e validi per quel repository. - Regole utente: preferenze globali del tuo ambiente Cursor, usate dall'Agent in ogni progetto.
- Regole di team: regole di tutta l'organizzazione, gestite dalla dashboard, disponibili nei piani Team ed Enterprise.
- AGENTS.md: un file markdown semplice nella radice del progetto, alternativa più leggera alle regole di progetto.
La distinzione che conta è chi deve poter cambiare la regola. Una convenzione del repository (come si chiamano i file, quale pattern usare per gli errori) appartiene al progetto e deve viaggiare con il codice, così chi clona il repository la ottiene; una preferenza personale come la lingua delle risposte appartiene a te; una regola aziendale appartiene a chi amministra il team. Quando le fonti si sovrappongono, la documentazione dice che si applicano tutte unite e che in caso di conflitto prevale l'ordine team, progetto, utente. Una cosa che spesso si dà per scontata: secondo la stessa pagina le regole non influenzano né Tab né le altre funzioni di intelligenza artificiale, solo l'Agent.
Anatomia di una regola di progetto
Ogni regola di progetto è un file con estensione .mdc dentro .cursor/rules, in una
cartella a piacere (puoi organizzarle in sottocartelle). Il file comincia con un blocco di intestazione, il
frontmatter, e continua con le istruzioni in markdown. Un dettaglio che ha fatto perdere tempo a molti: un file
.md nella stessa cartella viene ignorato, perché non ha l'intestazione che dice quando applicarlo.
Se preferisci il markdown puro, la documentazione indica AGENTS.md.
L'intestazione ha tre campi: alwaysApply, description e globs. Non sono
indipendenti, e la tabella che la documentazione dà per la loro combinazione è il punto più utile di tutta la pagina.
| alwaysApply | description | globs | Comportamento |
|---|---|---|---|
| true | indifferente | indifferente | Sempre inclusa; globs e description sono ignorati |
| false | indifferente | presente | Allegata quando nel contesto c'è un file che corrisponde |
| false | presente | assente | L'Agent legge la descrizione e la include se serve |
| false | assente | assente | Inclusa solo se la richiami con @nome-regola in chat |
Leggila come una cascata. Se alwaysApply è vero, il resto non conta. Se non lo è, i globs
vincono sulla descrizione, e solo senza globs la descrizione diventa il modo in cui l'Agent sceglie. Una
description scritta per una regola che ha già i globs, secondo la tabella, non cambia il comportamento:
la descrizione serve soltanto alle regole che vuoi lasciare alla decisione dell'Agent. Nell'interfaccia gli stessi
quattro casi compaiono come menu a tendina («Always Apply», «Apply Intelligently», «Apply to Specific Files»,
«Apply Manually»), che imposta questi campi al posto tuo.
Un progetto di prova: quattro regole e un caricatore
Per vedere la tabella in azione ho costruito una cartella di prova, un'applicazione Angular immaginaria con un carrello, e ci ho messo quattro regole: una universale, una per i componenti, una sui servizi HTTP e una sulle migrazioni del database. Sono scritte come le scriveresti tu, brevi e con istruzioni verificabili.
# ===== .cursor/rules/base.mdc
---
alwaysApply: true
---
- Rispondi in italiano e scrivi i commenti del codice in inglese.
- Non modificare mai i file generati in `dist/`.
- Prima di proporre una modifica a un servizio, leggi il file che lo definisce.
# ===== .cursor/rules/componenti.mdc
---
globs: src/app/**/*.component.ts, src/app/**/*.component.html
alwaysApply: false
---
- Usa componenti standalone con `ChangeDetectionStrategy.OnPush`.
- Per input e output usa le funzioni `input()` e `output()`, non i decoratori.
- Nei template usa `@if` e `@for`, non `*ngIf` e `*ngFor`.
# ===== .cursor/rules/servizi/http.mdc
---
description: Convenzioni per i servizi che chiamano il backend con HttpClient
alwaysApply: false
---
- Ogni servizio sta in un file `*.service.ts` e restituisce Observable tipizzati.
- Gli errori HTTP si convertono in un oggetto con `code` e `message`, mai in una stringa.
- Per la struttura di base leggi `@servizio-modello.ts` prima di crearne uno nuovo.
# ===== .cursor/rules/migrazioni.mdc
---
alwaysApply: false
---
- Ogni migrazione ha una parte `up` e una `down`.
- Non cambiare mai il tipo di una colonna sul posto: aggiungi una colonna, copia i dati, poi elimina la vecchia.
La prima ha solo alwaysApply: true: vale per ogni conversazione, quindi contiene solo cose che valgono
davvero ovunque. La seconda ha i globs e viene allegata solo quando lavori su un componente. La terza
ha una description scritta pensando all'Agent, che la legge e decide: la descrizione deve dire
quando la regola serve, non riassumerne il contenuto. La quarta non ha nessun campo e resta fuori finché
non scrivi @migrazioni, il che la rende adatta a procedure delicate che non vuoi vedere applicate per
iniziativa dell'Agent.
Il programma qui sotto è un caricatore minimo che applica la tabella: legge ogni file di
.cursor/rules, scarta quelli senza estensione .mdc o senza intestazione, classifica la
regola nei quattro tipi e dice, dato l'elenco dei file presenti nel contesto, quali regole entrerebbero. Non è il
codice di Cursor: è la tabella della documentazione tradotta in codice, e serve a controllare le tue regole prima di
scoprire un errore in una conversazione. Per confrontare i percorsi con i globs usa
glob.translate, disponibile nelle versioni recenti di Python (qui la 3.14.4).
"""Applica a .cursor/rules la tabella di decisione della documentazione di Cursor (consultata il 2026-11-13)."""
import glob, re, sys
from pathlib import Path
def leggi(percorso):
testo = percorso.read_text(encoding="utf-8")
m = re.match(r"---\n(.*?)\n---\n(.*)", testo, re.S)
if not m:
return None, testo
campi = {}
for riga in m.group(1).splitlines():
chiave, _, valore = riga.partition(":")
campi[chiave.strip()] = valore.strip()
return campi, m.group(2)
def tipo(campi):
if campi.get("alwaysApply") == "true":
return "sempre" # globs e description ignorati
if campi.get("globs"):
return "per-file" # allegata se un file corrispondente e' nel contesto
if campi.get("description"):
return "intelligente" # l'agente legge la descrizione e decide
return "manuale" # solo con @nome-regola
def corrisponde(globs, file):
modelli = [g.strip() for g in globs.split(",")]
return any(re.fullmatch(glob.translate(g, recursive=True, include_hidden=True), file) for g in modelli)
def main(radice, contesto):
regole = []
for p in sorted(Path(radice, ".cursor/rules").rglob("*")):
if p.is_dir():
continue
nome = p.relative_to(Path(radice, ".cursor/rules")).as_posix()
if p.suffix != ".mdc":
print(f"{nome}: IGNORATA, l'estensione non e' .mdc")
continue
campi, corpo = leggi(p)
if campi is None:
print(f"{nome}: IGNORATA, manca l'intestazione")
continue
if campi.get("globs", "").startswith("["):
print(f"{nome}: ATTENZIONE, globs e' un elenco YAML; la documentazione mostra una stringa con pattern separati da virgola")
regole.append((nome, tipo(campi), campi))
print("contesto:", ", ".join(contesto) if contesto else "(nessun file)")
for nome, t, campi in regole:
if t == "sempre":
esito = "inclusa"
elif t == "per-file":
esito = "inclusa" if any(corrisponde(campi["globs"], f) for f in contesto) else "non inclusa"
elif t == "intelligente":
esito = "decide l'agente: " + campi["description"]
else:
esito = "solo con @" + nome.removesuffix(".mdc").split("/")[-1]
print(f" {nome:20} [{t}] {esito}")
if __name__ == "__main__":
main(sys.argv[1], sys.argv[2:])
Le funzioni da guardare sono due. tipo() è la tabella, con gli stessi quattro casi e nello stesso ordine.
corrisponde() divide il campo globs sulla virgola, come fa la documentazione nei suoi esempi
con più pattern, e confronta ogni pezzo con il percorso del file. Se togli la divisione sulla virgola, una regola con
due pattern smette di corrispondere a entrambi. Ho lanciato il programma due volte per ciascun file di contesto, con
uscita identica, su due situazioni: stai modificando un componente, oppure un servizio.
# $ python3 -I carica_regole.py progetto src/app/cart/cart.component.ts
# errata.mdc: ATTENZIONE, globs e' un elenco YAML; la documentazione mostra una stringa con pattern separati da virgola
# note.md: IGNORATA, l'estensione non e' .mdc
# contesto: src/app/cart/cart.component.ts
# base.mdc [sempre] inclusa
# componenti.mdc [per-file] inclusa
# errata.mdc [per-file] non inclusa
# migrazioni.mdc [manuale] solo con @migrazioni
# servizi/http.mdc [intelligente] decide l'agente: Convenzioni per i servizi che chiamano il backend con HttpClient
#
# $ python3 -I carica_regole.py progetto src/app/cart/cart.service.ts
# errata.mdc: ATTENZIONE, globs e' un elenco YAML; la documentazione mostra una stringa con pattern separati da virgola
# note.md: IGNORATA, l'estensione non e' .mdc
# contesto: src/app/cart/cart.service.ts
# base.mdc [sempre] inclusa
# componenti.mdc [per-file] non inclusa
# errata.mdc [per-file] non inclusa
# migrazioni.mdc [manuale] solo con @migrazioni
# servizi/http.mdc [intelligente] decide l'agente: Convenzioni per i servizi che chiamano il backend con HttpClient
Con il componente nel contesto entrano la regola universale e quella dei componenti; con il servizio entra solo la
universale, e la regola sui servizi resta affidata alla decisione dell'Agent, mentre quella sulle migrazioni
aspetta la menzione esplicita. Notane altre due: note.md è ignorato per l'estensione, e
errata.mdc produce un avviso. Quel file, che scrive i globs come elenco YAML, è
riportato qui sotto: la documentazione mostra sempre i globs come una stringa con i pattern separati
da virgola e non descrive la forma ad elenco. Non ho provato come la tratti Cursor, quindi nel dubbio usa la forma
documentata.
---
globs: ["**/*.spec.ts"]
alwaysApply: false
---
- Ogni test descrive un solo comportamento.
Scrivere i globs: la prova sui pattern
I globs sono il punto in cui ci si sbaglia più spesso, perché *.ts e
**/*.ts sembrano equivalenti e non lo sono. La documentazione li definisce così: un asterisco
singolo è un segmento di nome file, il doppio asterisco è un numero qualsiasi di cartelle. Il programma seguente
prova cinque pattern dell'elenco ufficiale su cinque percorsi.
import glob, re
modelli = ["*.ts", "**/*.ts", "src/**", "src/**/*.tsx", "tailwind.config.*"]
percorsi = ["main.ts", "src/main.ts", "src/app/ui/bottone.tsx", "src/README.md", "tailwind.config.js"]
for m in modelli:
rx = re.compile(glob.translate(m, recursive=True, include_hidden=True))
trovati = [p for p in percorsi if rx.fullmatch(p)]
print(f"{m:20} -> {trovati}")
Lo scopo è vedere dove ogni pattern si ferma. L'uscita confronta cosa corrisponde a ciascuno.
# *.ts -> ['main.ts']
# **/*.ts -> ['main.ts', 'src/main.ts']
# src/** -> ['src/main.ts', 'src/app/ui/bottone.tsx', 'src/README.md']
# src/**/*.tsx -> ['src/app/ui/bottone.tsx']
# tailwind.config.* -> ['tailwind.config.js']
*.ts trova solo main.ts nella radice; per prendere anche src/main.ts serve
**/*.ts. Un pattern come src/** prende tutto ciò che sta sotto src,
compresa la documentazione, e per questo di solito conviene restringerlo con un'estensione, come in
src/**/*.tsx. Il risultato coincide con i casi della documentazione, ma è la semantica di Python:
per l'ultima parola sul comportamento di Cursor fidati della sua pagina.
Rimandare a un file invece di copiarlo
Nella regola sui servizi compare @servizio-modello.ts. La documentazione precisa come funziona il
rimando: il contenuto della regola arriva all'Agent così com'è, e la menzione di un file gli dice dove guardare,
ma il file non viene inserito nel prompt; l'Agent lo legge con i suoi strumenti quando gli serve. Due conseguenze.
Primo, un modello di codice di cento righe richiamato così non pesa sul contesto quando la regola è inattiva e non
invecchia in due copie. Secondo, ciò che deve essere sempre presente va scritto nel corpo della regola: un
rimando non è una garanzia che il file sia letto.
Che cosa mettere in una regola e che cosa lasciare fuori
La stessa pagina dà indicazioni di scrittura che conviene tenere insieme, perché dicono quanto una regola debba essere piccola.
- Regole sotto le 500 righe, divise in più regole componibili quando crescono.
- Esempi concreti o file di riferimento, non indicazioni vaghe.
- Niente copie di intere guide di stile: per quelle serve un linter, perché l'Agent conosce già le convenzioni comuni.
- Niente elenco di tutti i comandi: l'Agent conosce npm, git e pytest.
- Niente istruzioni per casi limite che si presentano di rado.
Il filo comune è che una regola costa contesto a ogni conversazione in cui entra, quindi vale solo se corregge un
errore che l'Agent fa davvero e ripetutamente. Il consiglio della documentazione è di partire da poco e aggiungere
una regola quando vedi l'Agent ripetere lo stesso sbaglio; quando lo vedi di nuovo con la regola già scritta, il
difetto è nella regola e va corretto, non moltiplicato. Come prima prova puoi chiedere all'Agent di scrivere la
regola per te con /create-rule, oppure aggiungerla dalla voce Rules di Customize.
AGENTS.md, regole utente e regole di team
AGENTS.md è un file markdown senza intestazione né metadati. Cursor lo legge nella radice e nelle
sottocartelle: un AGENTS.md dentro frontend/ si applica ai file di quella cartella e dei
suoi figli, e le istruzioni più specifiche prevalgono su quelle dei livelli superiori. È la scelta giusta se vuoi
istruzioni leggibili da chiunque senza imparare i quattro tipi di regola; lo useremo nel
workflow su un progetto Angular.
Le regole utente si impostano da Customize e valgono ovunque: la documentazione le descrive adatte a preferenze
come lo stile delle risposte.
Le regole di team si creano dalla dashboard e hanno due interruttori che cambiano molto: «Enable this rule immediately», altrimenti la regola resta una bozza, ed «Enforce this rule», che impedisce ai membri di spegnerla da Customize. Questo non ne fa un controllo di sicurezza: la documentazione avverte che alcuni team usano le regole imposte nei processi di conformità, ma che le indicazioni date a un modello non dovrebbero essere l'unico controllo di sicurezza. Per importare regole da un repository GitHub non basta copiarle: vanno confezionate in un plugin e pubblicate tramite un marketplace.
Domande frequenti
Perché la mia regola non viene applicata?
Controlla prima il tipo: una regola «Apply Intelligently» ha bisogno di una description, una regola per file ha bisogno di un pattern che corrisponda ai file in contesto, e un file senza estensione .mdc viene ignorato. Il caricatore di questo articolo ripete i tre controlli.
Le regole valgono anche per il completamento Tab?
No. La documentazione dice che le regole non influenzano Cursor Tab né le altre funzioni di intelligenza artificiale: contano per l'Agent.
Che fine ha fatto il file .cursorrules?
La pagina delle regole in vigore non lo descrive più: elenca regole di progetto in .cursor/rules, regole utente, regole di team e AGENTS.md. Se hai un vecchio file, spostane il contenuto in una regola .mdc o in AGENTS.md.
Che cosa sai fare adesso
Sai scegliere il tipo di regola per ogni convenzione, scrivere l'intestazione giusta dopo aver letto la cascata dei tre campi, provare i pattern prima di fidarti e tenere ogni regola piccola, versionata e legata a un errore reale. Il passo successivo è dare all'Agent un compito intero e osservare come usa queste regole: lo vediamo nell'articolo sull'Agent Mode.
Nella stessa serie trovi anche Cursor vs Windsurf vs Copilot nel 2026.
Fonti
- Cursor, documentazione: Rules - quattro tipi di regola, estensione .mdc, tabella di alwaysApply, description e globs, rimandi ai file, buone pratiche, AGENTS.md, regole di team, FAQ, consultata il 2026-11-13
- Cursor, documentazione: Agent mode - le regole valgono in tutte le modalità (Agent, Ask, Plan, Debug), consultata il 2026-11-13
- Python: modulo glob - glob.translate con recursive e include_hidden, usata nei due programmi di prova, consultata il 2026-11-13
I due programmi sono stati eseguiti con Python 3.14.4 in una cartella temporanea fuori dal repository, due volte ciascuno con uscita identica. Applicano la tabella della documentazione e non sono il codice di Cursor: dentro l'editor non è stato provato nulla, perché Cursor non era installato. Il formato ad elenco dei globs e il destino del vecchio file .cursorrules sono dichiarati nel testo come non verificati.

Commenti
Caricamento commenti...
Accedi per commentare