Salta al contenuto principale

01 - Cursor IDE: Guida Completa per Developer

Quale strumento di Cursor usare per quale compito: Tab, Agent, modalità, contesto, .cursorignore, worktree, privacy e piani, dalla documentazione ufficiale.

Cosa ne pensi di questo articolo?

01 - Cursor IDE: Guida Completa per Developer
Cursor IDEFoto:Marek PrášilPexels

In Breve

Quale strumento di Cursor usare per quale compito: Tab, Agent, modalità, contesto, .cursorignore, worktree, privacy e piani, dalla documentazione ufficiale.

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.

settings.json: barra delle attività verticale
{
  "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 usarlaModifica i file?
AgentFunzioni nuove, refactoring, correzione di bugSì
AskCapire il codice, esplorare l'architetturaNo, sola lettura
PlanFunzioni complesse di cui vuoi rivedere l'approccio primaSì, dopo che approvi il piano
DebugBug difficili che richiedono prove a runtimeSì

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.

  • @nomefile o @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.
  • @Commit e @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.

verifica.sh
#!/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.

.cursorignore, prima versione
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.

.cursorignore, versione corretta
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.

.cursor/worktrees.json
{
  "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.

PianoPrezzoModelli di terze parti
Free0 $Non disponibili
Plus8 $ al meseNon disponibili
Premium30 $ al meseAl prezzo di listino delle API, da credito prepagato
Super100 $ al meseCome Premium
Ultra200 $ al meseCome 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

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.

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