Salta al contenuto principale

02 - Cursor Rules: Configurare AI per il tuo Progetto

Come scrivere le regole di Cursor: i quattro tipi, i campi di .mdc, i globs provati con un programma, AGENTS.md e regole di team, secondo la documentazione.

Cosa ne pensi di questo articolo?

02 - Cursor Rules: Configurare AI per il tuo Progetto
Cursor IDEFoto:Bibek ghoshPexels

In Breve

Come scrivere le regole di Cursor: i quattro tipi, i campi di .mdc, i globs provati con un programma, AGENTS.md e regole di team, secondo la documentazione.

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.

alwaysApplydescriptionglobsComportamento
trueindifferenteindifferenteSempre inclusa; globs e description sono ignorati
falseindifferentepresenteAllegata quando nel contesto c'è un file che corrisponde
falsepresenteassenteL'Agent legge la descrizione e la include se serve
falseassenteassenteInclusa 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.

Le quattro regole del progetto di prova
# ===== .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).

carica_regole.py
"""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.

Uscita di carica_regole.py (Python 3.14.4, due esecuzioni identiche)
# $ 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.

errata.mdc: forma dei globs non 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.

prova_glob.py
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.

Uscita di prova_glob.py (Python 3.14.4, due esecuzioni identiche)
# *.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.

Prova Questi Strumenti

Strumenti gratuiti correlati a questo argomento.

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti