Il problema: cinque modi di chiedere aiuto, e nessuno che dica quale usare
Hai installato Cursor, hai aperto il tuo progetto e davanti a te ci sono un completamento che compare mentre scrivi, un pannello dove dialogare con l'assistente, una selezione di codice che puoi mandargli, un menu di modalità e un elenco di modelli. La domanda pratica non è che cosa sappia fare Cursor, ma quale di questi strumenti scegliere per il compito che hai davanti, e che cosa lasciargli toccare. Questa guida risponde in quest'ordine: che cosa è Cursor rispetto a VS Code, come si passa dall'uno all'altro, come si usano Tab, Agent e le modalità nel lavoro quotidiano e dove stanno i limiti di sicurezza che conviene conoscere prima di dare un comando a un agente.
Una premessa sul perché il testo cita sempre la documentazione e una data. Cursor è un prodotto di terzi che cambia in fretta: la sua interfaccia, i nomi dei menu e i piani a pagamento sono cambiati più volte nel giro di un anno, e le guide scritte prima di quei cambi descrivono cose che non esistono più. Ogni funzione qui sotto è stata riletta il 2026-11-13 sulla documentazione ufficiale e sul changelog; quello che non ho trovato lì non c'è. Cursor non era installato sulla macchina con cui ho scritto, quindi i passaggi dentro l'editor non sono stati provati qui: li riporto come li descrive la documentazione, e dove conta lo dico.
Che cosa è Cursor, e che cosa porta di VS Code
La pagina di migrazione dice che Cursor è basato sul codice di VS Code, e che per questo il passaggio è indolore: impostazioni, tasti rapidi e aspetto sono quelli che conosci. Una conseguenza che il testo ufficiale dichiara con franchezza è il ritardo di versione: Cursor viene riallineato regolarmente all'ultima versione di VS Code, ma per stabilità usa spesso una versione un po' più vecchia. Se una funzione appena uscita in VS Code non c'è, è questo il motivo più probabile.
Importare il profilo di VS Code
L'importazione è un solo clic in Cursor Settings, alla voce General, poi Account, poi «VS Code Import», e porta estensioni, temi, impostazioni e scorciatoie. Se cambi macchina o vuoi più controllo, il percorso manuale usa i profili di VS Code: dal Command Palette si esporta il profilo (su file o su un Gist di GitHub) e lo si importa dall'altra parte. Che ogni singola estensione funzioni identica non lo promette nessuno: la documentazione parla di trasferimento, non di compatibilità garantita, quindi dopo l'importazione apri le due o tre estensioni da cui dipendi davvero e provale prima di toglierle a VS Code.
Un dettaglio di interfaccia sorprende chi arriva da VS Code: la barra delle attività è orizzontale, per lasciare
spazio alla chat. Se la preferisci verticale, la documentazione indica una sola impostazione, da inserire nel
settings.json oppure da cercare nella schermata delle impostazioni, seguita da un riavvio.
{
"workbench.activityBar.orientation": "vertical"
}
La chiave workbench.activityBar.orientation è quella indicata dalla documentazione di Cursor e il valore
da usare è vertical; gli altri valori possibili non li ho verificati. Senza questa riga resta l'orientamento
orizzontale di partenza. Il file è stato validato come JSON, ma l'effetto sull'editor non è stato provato qui.
Tab, Agent e modalità: lo strumento giusto per ogni compito
Il modo più semplice per non perdersi è associare a ogni strumento la grandezza del compito. Il completamento Tab lavora sulla riga che stai scrivendo, l'Agent su un compito intero, e in mezzo ci sono la selezione inviata all'Agent e le modalità che cambiano quanto l'Agent può fare da solo. Procediamo dal più piccolo al più grande.
Tab: il completamento che prevede la prossima modifica
Tab è il completamento automatico di Cursor e, secondo la documentazione, si basa sulle tue modifiche recenti, sul codice intorno e sugli errori del linter. I suggerimenti compaiono in grigio davanti al cursore: Tab li accetta per intero, Esc o continuare a scrivere li rifiuta, e Cmd/Ctrl con la freccia destra li accetta una parola per volta, utile quando il suggerimento è giusto a metà. Può modificare più righe, aggiungere gli import mancanti e proporre modifiche coordinate; dopo averne accettata una, un secondo Tab salta al punto successivo in cui prevede che dovrai intervenire, anche in un altro file.
Se i suggerimenti ti disturbano, per esempio mentre scrivi un documento, l'indicatore Tab in basso a destra permette di sospenderlo per un tempo scelto, spegnerlo ovunque o disattivarlo per certi tipi di file come markdown e JSON. Il tasto di accettazione si rimappa cercando «Accept Cursor Tab Suggestions» nelle scorciatoie.
Agent: un compito dall'inizio alla fine
L'Agent si apre con Cmd/Ctrl+I. Gli descrivi un risultato in linguaggio naturale e lui decide quali file leggere, quali modifiche fare e come verificarle. Gli strumenti a sua disposizione, nella documentazione, comprendono la ricerca in file e cartelle, la lettura dei file (anche immagini), la modifica, l'esecuzione di comandi nel terminale, la ricerca sul web, un browser per fare screenshot e provare un'applicazione, e la possibilità di farti domande mentre lavora. La documentazione precisa anche che non c'è un limite al numero di chiamate agli strumenti in un singolo compito: un compito mal definito può quindi girare a lungo e consumare molto del tuo piano.
Per mandare all'Agent un pezzo di codice preciso, selezionalo e premi Cmd/Ctrl+L oppure Cmd/Ctrl+K: l'Agent si apre con quelle righe già citate nel messaggio. Se hai letto guide più vecchie, nota che Cmd+K una volta apriva la modifica inline e la documentazione dice che quel flusso è stato sostituito da questo. Allo stesso modo, il «Composer» delle guide precedenti oggi non è un pannello: Composer 2.5 compare nella documentazione come nome di un modello di Cursor.
Le modalità: quanto può fare l'Agent da solo
Con Shift+Tab o con il menu nel pannello si cambia modalità. La tabella riporta le quattro che la documentazione elenca, con ciò che ciascuna può fare sui tuoi file.
| Modalità | Quando usarla | Modifica i file? |
|---|---|---|
| Agent | Funzioni nuove, refactoring, correzione di bug | Sì |
| Ask | Capire il codice, esplorare l'architettura | No, sola lettura |
| Plan | Funzioni complesse di cui vuoi rivedere l'approccio prima | Sì, dopo che approvi il piano |
| Debug | Bug difficili che richiedono prove a runtime | Sì |
Due fatti della documentazione cambiano il modo di lavorare. Ogni modalità usa un proprio contesto, quindi cambiare modalità apre una finestra di contesto nuova: conviene aprire una chat nuova quando cambi compito, invece di trascinarti dietro la conversazione precedente. Le regole di progetto, utente e team invece valgono in tutte e quattro le modalità. La regola pratica è partire da Ask quando non conosci un codice, passare a Plan per le modifiche che toccano molti file e riservare Agent ai compiti che sai descrivere in una frase; il Plan Mode e gli agenti in background sono approfonditi nel quarto articolo della serie.
Che cosa vede l'Agent: il contesto
Nel pannello, digitando @ scegli che cosa allegare al messaggio. Le voci attuali della documentazione
sono poche e dicono molto di come è cambiato il prodotto.
@nomefileo@cartella/: un file o una cartella; dopo una cartella, la barra obliqua permette di scendere nel contenuto.@Terminals: l'uscita dei terminali, utile per far leggere un errore senza copiarlo.@Chats: il contesto di una conversazione precedente.@Commite@Branch: la differenza dello stato di lavoro non committato, oppure quella dell'intero ramo rispetto a main.@Browser: il contenuto del browser integrato.
La stessa pagina avverte di usare le menzioni quando sai quali file contano, e di saltarle quando non lo sai,
perché l'Agent trova da solo i file rilevanti con la propria ricerca. Le voci @codebase,
@docs, @web e @definitions che vedi in molti tutorial non sono nell'elenco
di oggi: il changelog della versione 2.0 dice che molte voci esplicite sono state rimosse dal menu perché l'Agent
può raccogliere il contesto da sé. Il contesto non è infinito: l'anello accanto al campo di testo mostra quanto
della finestra è pieno, e quando sta per finire Cursor riassume le parti più vecchie della conversazione.
Sulla ricerca nel codice la documentazione descrive un motore chiamato Instant Grep, che costruisce e interroga il proprio indice sulla tua macchina; Cursor dichiara di non caricare percorsi o codice per costruire un indice di ricerca e di non conservare embedding della tua codebase a questo scopo. Resta vero un punto che la stessa pagina precisa: quando l'Agent apre un file trovato, il contenuto di quel file può comunque entrare nella richiesta al modello. Chi cerca la spiegazione dell'indicizzazione semantica in vecchi articoli deve quindi considerarla superata.
Che cosa lasciare fuori: .cursorignore
Il file .cursorignore alla radice del progetto usa la sintassi di .gitignore e blocca
l'accesso a ciò che elenca per l'Agent, per Tab e per le menzioni con la chiocciola. Ci sono tre cose da
sapere prima di fidarsene. Primo: la documentazione scrive che la protezione non è garantita al cento per cento,
per l'imprevedibilità dei modelli. Secondo: gli strumenti di terminale e i server MCP usati dall'Agent non sono
governati da questo file, quindi un comando di terminale che legge quel file, se lo approvi, non viene fermato dall'esclusione.
Terzo: esiste già un elenco di esclusioni predefinite, che comprende i file .env*, i lock file, le
cartelle come node_modules/, e anche estensioni come *.csv e *.pdf: se un
CSV non compare mai nelle risposte dell'Agent, il motivo è questo.
Siccome la sintassi è quella di Git, i pattern si provano con Git stesso, come suggerisce la documentazione.
Lo script qui sotto scorre un elenco fisso di percorsi e, per ciascuno, chiede a git check-ignore -v
quale riga del file lo colpisce; l'opzione --no-index serve perché i file di prova non sono
tracciati. Va eseguito in una cartella con un repository inizializzato, nella quale il contenuto di
.cursorignore è stato copiato in .gitignore.
#!/bin/bash
# Usa il contenuto di .cursorignore come .gitignore: git check-ignore -v dice quale riga colpisce ogni percorso
cd "$1" || exit 1
for p in node_modules/x/i.js src/app.ts src/app.log .env chiave.pem public/index.html public/assets/style.css public/assets/logo.js; do
r=$(git -c core.excludesFile=/dev/null check-ignore -v --no-index "$p" | cut -f1 | sed -E 's/^\.gitignore:([0-9]+):/riga \1: /')
if [ -z "$r" ]; then echo "$p -> non ignorato"; else echo "$p -> $r"; fi
done
Nella prima prova la cartella public è ignorata per intero con public/* e si vuole
lasciare passare solo l'indice e un foglio di stile. Leggi l'uscita riga per riga: una riga che comincia con
! indica che il file è stato lasciato passare da quella regola, mentre il numero dice quale riga
del file lo ha deciso.
node_modules/
*.log
.env
*.pem
public/*
!public/index.html
!public/assets/style.css
# Uscita di verifica.sh (git 2.53.0, due esecuzioni identiche):
# node_modules/x/i.js -> riga 1: node_modules/
# src/app.ts -> non ignorato
# src/app.log -> riga 2: *.log
# .env -> riga 3: .env
# chiave.pem -> riga 4: *.pem
# public/index.html -> riga 6: !public/index.html
# public/assets/style.css -> riga 5: public/*
# public/assets/logo.js -> riga 5: public/*
public/index.html passa, ma public/assets/style.css no: la riga 5 ha escluso la
cartella assets e Git non scende più dentro una cartella esclusa, quindi la regola di eccezione
della riga 7 non viene nemmeno consultata. È la limitazione che la documentazione di Cursor descrive e che Git
documenta per .gitignore: non si può riammettere un file se una cartella che lo contiene è esclusa.
Un caso reale in cui ci si imbatte è quello di un file di configurazione da lasciare visibile dentro una cartella
altrimenti ignorata.
La correzione consiste nel riammettere la cartella e nell'escluderne poi il contenuto file per file, e solo dopo
nell'eccezione per il singolo file. Con la seconda versione style.css passa e logo.js
resta escluso, come volevi.
node_modules/
*.log
.env
*.pem
public/*
!public/index.html
!public/assets/
public/assets/*
!public/assets/style.css
# Uscita di verifica.sh (git 2.53.0, due esecuzioni identiche):
# node_modules/x/i.js -> riga 1: node_modules/
# src/app.ts -> non ignorato
# src/app.log -> riga 2: *.log
# .env -> riga 3: .env
# chiave.pem -> riga 4: *.pem
# public/index.html -> riga 6: !public/index.html
# public/assets/style.css -> riga 9: !public/assets/style.css
# public/assets/logo.js -> riga 8: public/assets/*
La prova usa il motore di Git, non quello di Cursor: dimostra che i due pattern si comportano come descrive la documentazione, non che Cursor li applichi identici in ogni caso. Se un file che ti serve non compare nelle risposte, questo è il primo controllo da fare. Dopo aver cambiato il file, conferma sempre con una domanda all'Agent che dipenda da quel file.
Che cosa può fare da solo l'Agent, e che cosa no
I limiti predefiniti sono documentati nella pagina sulla sicurezza dell'Agent, e vale la pena conoscerli prima del primo compito reale. Leggere i file e cercare nel codice non richiede approvazione. Modificare i file del progetto neppure: le modifiche vengono salvate subito su disco, con l'eccezione dei file di configurazione, che chiedono il tuo consenso. Eseguire comandi nel terminale richiede approvazione per impostazione predefinita, e la configurazione dei Run Modes permette di lasciar passare quelli di cui ti fidi, da una semplice lista di comandi consentiti fino a un classificatore di revisione automatica; la documentazione stessa li definisce protezioni «best effort», non un confine di sicurezza rigido. Ogni connessione a un server MCP richiede approvazione, e dopo averla data ogni singola chiamata di strumento chiede la sua.
Le conseguenze pratiche sono due. Poiché le modifiche ai file sono immediate, il controllo di versione è la tua rete di sicurezza: parti da un albero di lavoro pulito, così la differenza che vedi è solo quella dell'Agent. Poi ci sono i checkpoint, istantanee della codebase che l'Agent crea prima delle modifiche importanti: con «Restore Checkpoint» riporti i file allo stato di quel punto, ma la documentazione avverte che sono salvati in locale, separati da Git, che il ripristino non toglie i messaggi dalla conversazione e che servono solo ad annullare le modifiche dell'Agent, non a sostituire un commit. Il caso tipico è un refactoring esplorativo andato storto a metà: il checkpoint ti riporta indietro in pochi secondi, il commit ti protegge il giorno dopo.
Più agenti insieme: worktree e Agents Window
Con Cursor 2.0, uscito il 2025-10-29 secondo il changelog, si possono eseguire fino a otto agenti in parallelo su un unico prompt, usando i worktree di Git o macchine remote perché ognuno lavori su una copia isolata del codice. Un worktree di Git è una seconda cartella di lavoro dello stesso repository, su un ramo diverso: due agenti che toccano lo stesso file non si pestano i piedi perché non stanno nella stessa cartella. La versione 3, del 2026-04-02, ha aggiunto l'Agents Window, un'interfaccia centrata sugli agenti dove ne esegui molti in parallelo in locale, nei worktree, nel cloud o su SSH remoto; l'editor classico resta disponibile e si passa dall'uno all'altra dal Command Palette con «Open Agents Window» e «Open IDE».
I worktree creati dall'interfaccia sono una funzione della sola Agents Window; nell'editor si usano i comandi delle
Worktree Skills. Un worktree nuovo non ha le tue dipendenze installate né il file .env, e questo è
il difetto più comune: l'agente parte e fallisce al primo test. Per questo la documentazione prevede il file
.cursor/worktrees.json, con una lista di comandi eseguiti in sequenza nel worktree appena creato.
{
"setup-worktree": [
"npm ci",
"cp $ROOT_WORKTREE_PATH/.env .env"
]
}
Le chiavi accettate sono tre: setup-worktree-unix, setup-worktree-windows e la
generica setup-worktree, che fa da ripiego. Ciascuna è una lista di comandi o il percorso di uno
script; ROOT_WORKTREE_PATH è la variabile con cui il comando raggiunge la cartella originale per
copiarne il .env. Il file è stato validato come JSON ma non provato in Cursor. La documentazione
sconsiglia di collegare le dipendenze con link simbolici, perché possono dare problemi al worktree principale, e
indica un gestore di pacchetti veloce come pnpm o bun. Dalla versione 3.5, un limite di 25 worktree per macchina
(cursor.worktreeMaxCount) pulisce automaticamente i più vecchi.
Privacy e costi: ciò che conviene sapere prima
Quando usi le funzioni di intelligenza artificiale, Cursor invia ai fornitori dei modelli prompt e contesto del codice. La documentazione sulla gestione dei dati dice che con la Privacy Mode attiva il tuo codice non viene mai usato per l'addestramento né da Cursor né dai fornitori dei modelli, e che la modalità è attiva per impostazione predefinita per i team Enterprise: nei piani individuali sta a te verificarla nelle impostazioni. I Cloud Agent sono l'unica funzione che richiede a Cursor di conservare il codice: copie cifrate dei repository, tenute temporaneamente e cancellate a compito concluso. Se il tuo cliente vieta il codice fuori dalla sua rete, non attivarli.
I prezzi cambiano e sono legati a un abbonamento più ampio, quindi li riporto solo come fotografia della pagina dei modelli e dei prezzi del 2026-11-13, da ricontrollare prima di decidere. Il pagamento è mensile salvo diversa indicazione, i prezzi sono al netto delle imposte.
| Piano | Prezzo | Modelli di terze parti |
|---|---|---|
| Free | 0 $ | Non disponibili |
| Plus | 8 $ al mese | Non disponibili |
| Premium | 30 $ al mese | Al prezzo di listino delle API, da credito prepagato |
| Super | 100 $ al mese | Come Premium |
| Ultra | 200 $ al mese | Come Premium |
Il dato che pesa nella scelta non è il prezzo, è la riga dei modelli: sul piano Plus l'Agent usa soltanto i modelli di Cursor, a impostazioni fisse, e non include i modelli di terze parti come Claude, GPT o Gemini, che dal Premium in su si pagano a parte, a consumo, dal credito prepagato. I piani Hobby, Start, Pro e Pro+ precedenti sono ora «legacy» e continuano per i clienti esistenti, con due serbatoi di utilizzo mensili. Il tetto settimanale si rinnova ogni settimana e, quando finisce, puoi aspettare, usare il credito oppure passare a un piano superiore. Non esiste una cifra di risparmio di tempo che possa darti: dipende dal compito e dalla tua revisione.
Domande frequenti
Come porto le impostazioni di VS Code in Cursor?
In Cursor Settings, General, Account, premi Import alla voce «VS Code Import»: vengono trasferiti estensioni, temi, impostazioni e scorciatoie. In alternativa esporti un profilo da VS Code e lo importi dal Command Palette.
Dov'è finita la modifica inline con Cmd+K?
Cmd/Ctrl+K e Cmd/Ctrl+L, con del codice selezionato, aprono oggi l'Agent con quelle righe già citate. Secondo la documentazione il vecchio flusso di modifica inline è stato sostituito da questo.
Posso impedire a Cursor di leggere certi file?
Sì, con un file .cursorignore alla radice, che usa la sintassi di .gitignore. Non governa però i comandi di terminale né i server MCP, e la documentazione non ne garantisce la protezione completa.
Che cosa sai fare adesso
Sai scegliere lo strumento in base alla grandezza del compito: Tab per la riga, Agent per il compito, Ask quando vuoi capire senza rischiare modifiche e Plan quando il lavoro tocca molti file. Sai portare il tuo profilo da VS Code, tenere fuori dall'Agent i file sensibili e verificare con Git che le tue esclusioni funzionino, e sai perché senza controllo di versione un agente che salva subito su disco è un rischio. Il passo successivo naturale è insegnare all'Agent le convenzioni del tuo progetto con le regole, nel secondo articolo, e poi affidargli compiti interi nel terzo. Per vedere il tutto su un progetto intero c'è il workflow su un'applicazione Angular, e per scegliere fra Cursor e altri strumenti il confronto della serie.
Fonti
- Cursor, documentazione: Quickstart - apertura dell'Agent con Cmd/Ctrl+I, Plan Mode con Shift+Tab, consultata il 2026-11-13
- Cursor, documentazione: Agent - strumenti dell'Agent, assenza di limite alle chiamate, checkpoint locali e separati da Git, consultata il 2026-11-13
- Cursor, documentazione: Agent mode - Cmd/Ctrl+K e Cmd/Ctrl+L con selezione, modalità Agent, Ask, Plan, Debug e contesto per modalità, consultata il 2026-11-13
- Cursor, documentazione: Tab completion - accettazione, rifiuto, salto al punto successivo, spegnimento, consultata il 2026-11-13
- Cursor, documentazione: Prompting agents - elenco delle menzioni @ e anello del contesto, consultata il 2026-11-13
- Cursor, documentazione: Ignore file - sintassi di .cursorignore, elenco predefinito, limiti di terminale e MCP, limite sulla negazione, consultata il 2026-11-13
- Cursor, documentazione: Search - Instant Grep e privacy della ricerca, consultata il 2026-11-13
- Cursor, documentazione: VS Code Migration - importazione del profilo, orientamento della barra delle attività, versione di VS Code, consultata il 2026-11-13
- Cursor, documentazione: Agent Security - approvazioni predefinite per file, terminale e MCP, Run Modes, consultata il 2026-11-13
- Cursor, documentazione: Worktrees - worktrees.json, chiavi di setup, limite di 25 worktree, consultata il 2026-11-13
- Cursor, documentazione: Privacy and Data Governance - flussi di dati, Privacy Mode, Cloud Agent, consultata il 2026-11-13
- Cursor, documentazione: Models & Pricing - piani e prezzi, modelli di terze parti, piani legacy, consultata il 2026-11-13
- Cursor, changelog 2.0 (2025-10-29) - fino a otto agenti in parallelo, voci @ rimosse, consultata il 2026-11-13
- Cursor, changelog 3.0 (2026-04-02) - Agents Window, consultata il 2026-11-13
- Git: gitignore - regola sulla riammissione di un file in una cartella esclusa, consultata il 2026-11-13
Gli esempi sul .cursorignore sono stati eseguiti con Git 2.53.0 in una cartella temporanea fuori dal repository, due volte con uscita identica: provano il comportamento delle regole in Git, non in Cursor. I due file JSON sono stati validati con Python. Cursor non era installato: ciò che riguarda l'editor, l'Agent e i piani deriva dalla documentazione ufficiale e dal changelog letti il 2026-11-13.

Commenti
Caricamento commenti...
Accedi per commentare