# Claude Code ha più di cento comandi. Te ne bastano 27

> I 27 comandi di Claude Code che contano, divisi per momento della giornata e con un pro-tip ciascuno, più come scriverne di tuoi senza i buchi di sicurezza più comuni.

- URL: https://stocasticparrot.ai/tutorial/comandi-claude-code/
- Autore: Danilo Giudice
- Uscita: 2026-11-07

Esistono [oltre 100 comandi](https://code.claude.com/docs/en/commands) su Claude Code, alcuni erano sconosciuti anche a me, ma sono il vademecum di chi opera da terminale. I 27 che contano li ho raccolti dividendoli per categoria e funzione, con il pro-tip 💡 che uso più spesso. **Lo spoiler:** se arrivi in fondo, ogni momento della giornata ha il suo comando, e sai scriverne di tuoi senza aprire i buchi di sicurezza più comuni.

Se i comandi li conosci già, salta da una 💡 all’altra.

Nel prompt di Claude Code contano tre prefissi, spiegati nella [pagina sulla modalità interattiva](https://code.claude.com/docs/en/interactive-mode): `/` lancia un comando, `!` manda la riga dritta alla shell (l’output entra nella sessione e Claude lo commenta), `@` cita un file. Sapevi che ogni comando vale solo all’inizio del messaggio? Quello che scrivi dopo è il suo argomento. Ed alcuni comandi sono *skill*, cioè non eseguono una logica fissa ma danno al modello un testo di istruzioni. Al passo 7 ne scrivi una tua.

## 1. Prima sessione in un progetto

### /init

Lancialo la prima volta che apri Claude Code in un progetto. Legge il codice e scrive un `CLAUDE.md` di partenza, il file di istruzioni che Claude Code carica in ogni sessione. Consideralo una bozza: il comando si lancia una volta, poi il file lo curi tu.

Dentro Claude Code:
```
/init
```

> 💡 Pro-tip: **Con `CLAUDE_CODE_NEW_INIT=1` il giro diventa interattivo.** Lancia `CLAUDE_CODE_NEW_INIT=1 claude` e `/init` ti accompagna anche su skill, hook (comandi che partono da soli a certi eventi) e file di memoria personali. Se trova la configurazione di Codex o di Gemini CLI, propone di importarla.

### /memory

Apre i tuoi `CLAUDE.md` per modificarli e gestisce l’auto-memory, cioè le note che Claude Code scrive da solo. Ti serve quando un’istruzione va cambiata e non ricordi in quale file sta.

Dentro Claude Code:
```
/memory
```

> 💡 Pro-tip: **Se Claude «ricorda» una cosa sbagliata, guarda qui.** Da `/memory` leggi le voci dell’auto-memory e la accendi o la spegni. Il `CLAUDE.md` invece si rilegge a ogni richiesta: se è diventato un romanzo, nell’[igiene di Claude Code](https://stocasticparrot.ai/spiegoni/igiene-claude-code/) ti spiego come metterlo a dieta.

### /permissions

Alias: `/allowed-tools`.

Apre le regole dei permessi, spiegate nella [pagina sui permessi](https://code.claude.com/docs/en/permissions): allow (lo strumento parte senza chiedere), ask (chiede ogni volta), deny (vietato). Ci trovi anche le cartelle di lavoro e i blocchi recenti dell’auto mode, in cui a lasciar passare gli strumenti è un classificatore, non tu. Aprilo quando una conferma torna sempre uguale: una regola allow la toglie.

Dentro Claude Code:
```
/permissions
```

> 💡 Pro-tip: **Puoi vietare a Claude una skill sola.** Aggiungi una regola deny `Skill(deploy)`: Claude non può più lanciare da solo la skill `deploy`. Una regola `Skill` senza nome le vieta tutte.

### /mcp

Gestisce i server MCP, i programmi che collegano Claude Code a servizi esterni come GitHub o Jira, e i loro login OAuth, come spiega la [pagina sugli MCP](https://code.claude.com/docs/en/mcp). Senza argomenti mostra i server e il loro stato: se un servizio esterno smette di rispondere, guarda qui per primo.

Dentro Claude Code:
```
/mcp
```

> 💡 Pro-tip: **Ricollega un server senza uscire dalla sessione.** Se GitHub si è staccato, `/mcp reconnect github`; se si sono staccati tutti, `/mcp reconnect all`. Con `enable` e `disable` li accendi e li spegni.

## 2. Durante il lavoro

Mentre Claude lavora, un comando va in coda e parte a fine turno. Alcuni partono subito: fra questi `/btw`, `/model`, `/effort` e `/usage`.

### /plan

Prima di toccare un file, Claude esplora il progetto e ti consegna un piano di lavoro: in plan mode di norma non modifica i sorgenti, e il piano resta in un file in `~/.claude/plans/`. Se dopo il comando scrivi il compito, parte subito. Serve prima di un cambiamento che tocca molti file, e per farti spiegare un progetto che non conosci senza rischiare modifiche. Con il modello `opusplan`, dice la [pagina sulla configurazione dei modelli](https://code.claude.com/docs/en/model-config), pianifica Opus ed esegue Sonnet. Quando il piano è pronto, `Ctrl+G` lo apre nel tuo editor per riscriverlo; poi scegli: Claude parte in auto mode, parte ma ogni modifica la confermi tu, oppure resta in plan mode e gli chiedi correzioni.

Dentro Claude Code:
```
/plan sposta la validazione dei form in un modulo condiviso
```

> 💡 Pro-tip: **Plan mode non vuol dire sola lettura.** Per esplorare, Claude può lanciare comandi nella shell. E se hai avviato Claude Code con `--dangerously-skip-permissions`, il blocco sulle modifiche diventa solo un’istruzione: lo dice la [pagina sui permission mode](https://code.claude.com/docs/en/permission-modes).

### /context

Mostra in una griglia colorata cosa occupa il contesto, cioè tutto quello che il modello ha davanti a ogni richiesta. Aggiunge suggerimenti quando qualcosa pesa troppo. Lancialo quando devi scegliere se andare avanti, compattare o ripartire da zero. Con `all`, in schermo intero, apre il dettaglio voce per voce.

Dentro Claude Code:
```
/context all
```

> 💡 Pro-tip: **Guarda la riga «Skills».** Le descrizioni delle skill che Claude può lanciare da solo stanno nel contesto a ogni richiesta. Il contesto lo controlli tu, e spesso: nell’[igiene di Claude Code](https://stocasticparrot.ai/spiegoni/igiene-claude-code/) trovi come pesarlo e come alleggerirlo.

### /compact

Riassume la conversazione fin qui e libera contesto. Dopo il comando puoi scrivere cosa deve restare nel riassunto: così decidi tu cosa sopravvive. Lancialo quando chiudi una parte del lavoro e vuoi continuare nella stessa sessione.

Dentro Claude Code:
```
/compact tieni il piano e i comandi di test
```

> 💡 Pro-tip: **Compatta tu, prima che lo faccia l’auto-compaction.** È il riassunto che Claude Code fa da solo a finestra quasi piena, senza chiederti cosa tenere. Il contesto lo controlli tu: io l’auto-compaction la tengo spenta, [ecco perché](https://stocasticparrot.ai/spiegoni/auto-compaction/) e [come si fa](https://stocasticparrot.ai/tutorial/spegnere-auto-compaction/).

### /btw

Una domanda al volo (*by the way*, «a proposito») sulla sessione, anche mentre Claude lavora, senza fermarlo. La risposta compare in un riquadro che si chiude e non entra nella conversazione: il contesto resta com’era. Ti serve per chiedere a che punto è, o per farti rispiegare un passaggio.

Dentro Claude Code:
```
/btw quale file stavi modificando?
```

> 💡 Pro-tip: **Non ha strumenti.** Non legge file e non lancia comandi: risponde solo con quello che c’è già nella conversazione. Se ti serve di più, premi `f` e la domanda diventa un subagente, cioè un’altra istanza di Claude che lavora in parallelo, con tutti gli strumenti.

### /model

Cambia il modello e lo salva come predefinito per le sessioni nuove. Senza argomento apre un selettore; con il nome del modello ci va dritto. Serve quando il compito chiede un modello più potente, o quando ne basta uno più leggero.

Dentro Claude Code:
```
/model
```

> 💡 Pro-tip: **Nel selettore, `s` lo cambia solo per questa sessione.** Comodo per un compito difficile, senza toccare il predefinito. Se lo cambi mentre Claude risponde, vale dalla richiesta dopo.

### /effort

Regola l’*effort* del modello, cioè quanto lavora prima di risponderti: da `low` a `xhigh`, poi `max` e `auto`. Alzalo per un bug difficile, abbassalo per le domande veloci. Se lo cambi a metà turno, vale dal messaggio dopo.

Dentro Claude Code:
```
/effort high
```

> 💡 Pro-tip: **`max` vale solo per questa sessione.** Alla sessione dopo non lo ritrovi. E se non ricordi a che livello sei, `/effort status` te lo stampa.

### /usage

Alias: `/cost`, `/stats`.

Mostra in una schermata sola i costi della sessione, i limiti del tuo piano e le statistiche d’uso. Parte subito, anche mentre Claude lavora: guardalo quando ti avvicini ai limiti, o prima di lanciare un lavoro lungo.

Dentro Claude Code:
```
/usage
```

> 💡 Pro-tip: **Ti dice dove finiscono i consumi.** Con un piano Claude li divide per skill, subagente, plugin e server MCP, e propone modifiche per contesti lunghi e cache mancate (contesto riletto da capo) se pesano almeno il 10 %, come spiega la [pagina sui costi](https://code.claude.com/docs/en/costs).

### /goal

Gli dici quando il lavoro è finito, e Claude va avanti da solo finché non lo è. Dopo ogni turno un secondo modello legge la conversazione e controlla la condizione: se non è ancora vera, Claude riparte. La [pagina sui goal](https://code.claude.com/docs/en/goal) lo consiglia per i lavori lunghi con una fine verificabile, come portare un modulo su una nuova API finché ogni chiamata compila e i test passano.

Gira anche da script, senza interfaccia, con `claude -p "/goal …"`, e sopravvive alla ripresa della sessione. `/goal clear` lo toglie. Il secondo modello non lancia comandi e non apre file: scrivi una condizione che l’output di Claude possa dimostrare. Il goal non cambia i permessi: serve l’auto mode, il modo di partenza nel terminale (da script aggiungi `--permission-mode auto`).

Dentro Claude Code:
```
/goal npm test passa senza errori e nessun test esistente è stato modificato; oppure fermati dopo 20 turni
```

> 💡 Pro-tip: **«Fermati dopo 20 turni» lo valuta il secondo modello.** Lo legge nella conversazione, dove Claude scrive a ogni turno a che punto è. Un tetto tecnico ai turni o alla spesa, da script, lo danno `--max-turns` e `--max-budget-usd`, nel [riferimento della CLI](https://code.claude.com/docs/en/cli-reference).

## 3. In parallelo

### /background

Alias: `/bg`.

Stacca la sessione e la lascia lavorare da sola: il terminale torna libero, e puoi anche chiuderlo. Il testo dopo il comando è l’ultima istruzione prima di staccare; se Claude stava rispondendo, la risposta va avanti. Con la sessione si spostano i comandi e i subagenti in background, e i `/loop`.

Dalla shell, `claude agents` ti mostra in una schermata tutte le sessioni in background: chi lavora e chi aspetta una tua risposta. Lo spiega la [pagina sulla vista agenti](https://code.claude.com/docs/en/agent-view): è una funzione ancora in anteprima (*research preview*). Due avvertenze. Ogni sessione pesa sui limiti del piano come una normale. E quella che stacchi con `/background` non va in una copia separata: continua a modificare i file dove stava, e se intanto li tocchi anche tu rischi conflitti.

Dentro Claude Code:
```
/background lancia tutti i test e correggi quelli che falliscono
```

> 💡 Pro-tip: **C’è anche il gesto: freccia a sinistra, a riga vuota.** Le sessioni in background compaiono in `/resume` con la sigla «bg».

### /tasks

Alias: `/bashes`.

Mostra e gestisce il lavoro in background di questa sessione: comandi lunghi e subagenti, anche quelli già finiti. Parte subito, anche mentre Claude risponde. Aprilo quando vuoi sapere cosa gira ancora, o fermare qualcosa che non serve più.

Dentro Claude Code:
```
/tasks
```

> 💡 Pro-tip: **Non è la lista delle cose da fare di Claude.** Quella si apre con `Ctrl+T`. Qui trovi solo il lavoro che gira dietro le quinte.

### /subtask

Manda in parallelo un subagente che parte con tutta la conversazione di adesso: non devi rispiegargli niente. Lavora in background mentre tu vai avanti, e i suoi passaggi restano fuori dal tuo contesto: quando ha finito, nella conversazione torna solo il risultato. L’esempio della [pagina sui subagenti](https://code.claude.com/docs/en/sub-agents) è quello qui sotto: il subagente scrive i test delle modifiche fatte finora, e tu intanto continui a implementare. Mentre lavora lo vedi in un pannello sotto il prompt: con `Enter` apri la sua trascrizione e gli scrivi, con `x` lo fermi. Occhio ai file che tocca: di solito `/rewind` non annulla le sue modifiche, e la documentazione non dice che lavori in una copia separata.

Dentro Claude Code:
```
/subtask scrivi i test unitari per le modifiche al parser fatte finora
```

> 💡 Pro-tip: **Fino a luglio 2026 questo lo faceva `/fork`.** Lo dice il [changelog](https://code.claude.com/docs/en/changelog) della 2.1.212. Se una guida vecchia ti dice di usare `/fork` per mandare un subagente, intende `/subtask`. Oggi `/fork` fa un’altra cosa: la trovi al passo 5.

### /batch

Prende una modifica grande che attraversa tutto il progetto e la divide fra tanti subagenti che lavorano in parallelo, come dice la [pagina dei comandi](https://code.claude.com/docs/en/commands). Prima esplora il codice e spezza il lavoro in 5–30 unità indipendenti. Poi lancia un subagente per unità, ognuno nel suo worktree, cioè una copia di lavoro separata del repository: così non si pestano i piedi. Ogni subagente fa la sua parte, lancia i test e apre una PR (la proposta di modifica), oppure ti dice com’è andata. Se le parti dipendono l’una dall’altra, non è lo strumento giusto.

Dentro Claude Code:
```
/batch porta src/ da JavaScript a TypeScript
```

> 💡 Pro-tip: **Prima di lanciare i subagenti ti mostra il piano e aspetta il tuo sì.** Leggilo con calma: ogni unità diventa un subagente che consuma token, e le PR le rivedi tu. Serve un repository git, o un hook `WorktreeCreate` che crei le copie di lavoro.

### /loop

Alias: `/proactive`.

Ti fa da sentinella: ripete un prompt a intervalli e tiene d’occhio una cosa che cambia da sola, come un deploy o una PR.

- Con l’intervallo (`10m`, `2h`, `1d`) il ritmo è fisso.
- Senza intervallo lo regola Claude, fra un minuto e un’ora: breve se una build sta finendo, lungo se tutto tace.
- Senza prompt cura la PR del branch: commenti di revisione, controlli automatici falliti, conflitti.
- Al posto del prompt puoi passargli una tua skill: `/loop 20m /review-pr 1234`.

Gira solo con la sessione aperta, o in background con `/bg`. Se la riprendi, i loop a intervallo fisso tornano. In ogni caso un loop scade dopo 7 giorni, dice la [pagina sulle attività pianificate](https://code.claude.com/docs/en/scheduled-tasks). Ogni giro è un turno, e consuma token.

Dentro Claude Code:
```
/loop 5m controlla se il deploy è finito e dimmi com’è andata
```

> 💡 Pro-tip: **`Esc` non ferma un loop a intervallo fisso.** E nemmeno `Ctrl+C`: chiedi a Claude di cancellarlo, per esempio «cancella il loop del deploy». Con `Esc` si ferma solo il loop senza intervallo, mentre aspetta il giro dopo.

## 4. Prima di consegnare

### /diff

Mostra le modifiche che non hai ancora messo in un commit, comprese quelle di Claude, e te le divide anche turno per turno. Guardalo prima di ogni commit, per vedere cosa è cambiato davvero.

Dentro Claude Code:
```
/diff
```

> 💡 Pro-tip: **La vista per turno non viene da git.** Viene dalle modifiche che Claude fa con i suoi strumenti: un file cambiato da un comando shell compare solo in «Current».

### /code-review

Alias: `/review`.

Ti dà un revisore che non ha visto nascere il codice: gira in background, in un subagente che non vede la conversazione, come spiegano la [pagina sulla revisione in locale](https://code.claude.com/docs/en/code-review-local) e la [pagina delle skill](https://code.claude.com/docs/en/skills). Cerca bug e ti porta i risultati quando ha finito.

- Senza argomenti guarda le modifiche del tuo branch, anche quelle senza commit; se no gli dai una PR, come nell’esempio qui sotto (livello `high`, PR 1234), un intervallo di commit o una cartella.
- Il livello va da `low` (pochi risultati, con meno falsi positivi) a `max`, che allarga la ricerca.
- Con `--fix` applica le correzioni, che passano dai tuoi permessi; con `--comment` pubblica i risultati come commenti sulla PR.

Le modifiche di un `--fix` in background non si annullano con `/rewind`: per quelle serve git.

Dentro Claude Code:
```
/code-review high 1234
```

> 💡 Pro-tip: **`ultra` porta la revisione nel cloud, e costa.** Ogni bug viene riprodotto e verificato. A novembre 2026, dice la [pagina di ultrareview](https://code.claude.com/docs/en/ultrareview): tre giri gratis una tantum sui piani Pro, Max e Ultra, poi di solito 5–25 dollari a revisione. Serve il login a claude.ai.

### /security-review

Cerca vulnerabilità nelle modifiche del tuo branch: iniezioni (input esterno che finisce dentro un comando o una query), problemi di autenticazione, dati esposti. `/code-review` cerca errori di correttezza, questo cerca falle di sicurezza. Lancialo prima di aprire una PR, soprattutto se hai toccato il login o i dati degli utenti.

Dentro Claude Code:
```
/security-review
```

> 💡 Pro-tip: **Gli serve un remote che si chiami `origin`.** Il remote è il collegamento al repository online: `/security-review` confronta il tuo branch con il branch principale di `origin`, e senza quel remote non parte.

## 5. Tra una sessione e l’altra

### /clear

Alias: `/new`, `/reset`.

Apre una conversazione nuova, con il contesto vuoto: niente di quello che vi siete detti arriva alla richiesta dopo. La memoria del progetto resta, e la conversazione di prima resta sul disco: la riprendi con `/resume`. Finché non chiudi Claude Code, ci torni anche dal menu di `/rewind`.

Dentro Claude Code:
```
/clear
```

> 💡 Pro-tip: **Dai un nome alla conversazione che lasci.** Con `/clear login-sistemato` la ritrovi in `/resume` con quel nome. Occhio: toglie anche un `/goal` attivo. Io faccio così: un compito, una sessione. Il contesto lo controlli tu, e l’[igiene](https://stocasticparrot.ai/spiegoni/igiene-claude-code/) comincia da qui.

### /resume

Alias: `/continue`.

Riprende una conversazione di prima, con tutto il suo contesto. Senza argomento apre l’elenco delle sessioni; con un nome o un ID ci va dritto. Ti serve per i lavori di più giorni: la sessione di ieri riparte da dove l’avevi lasciata. Dalla shell fai lo stesso con `claude --resume` e il nome.

Dentro Claude Code:
```
/resume login-sistemato
```

> 💡 Pro-tip: **Funziona anche con le sessioni in background.** Se quella che cerchi gira ancora, `/resume` ti ci attacca e manda in background quella in cui sei.

### /branch

Crea un ramo della conversazione (non di git) da questo punto e ti ci sposta. Serve per provare una strada senza perdere l’altra: per esempio, a metà lavoro vuoi vedere dove porta un approccio con Redis.

Dentro Claude Code:
```
/branch prova-con-redis
```

> 💡 Pro-tip: **L’originale resta dov’è.** Ci torni con `/resume`, dal punto in cui hai creato il ramo. Se la strada nuova non porta da nessuna parte, hai perso solo il ramo.

### /fork

Copia la conversazione in una nuova sessione in background, e tu resti qui. Se aggiungi un prompt, la copia parte subito con quello. È una sessione a sé, con una sua riga in `claude agents` e, di norma, un suo worktree. Serve quando un compito deve andare avanti da solo, con tutto il contesto di adesso.

Dentro Claude Code:
```
/fork scrivi i test del modulo dei pagamenti
```

> 💡 Pro-tip: **Prima di seguire una guida su `/fork`, guarda la data.** Nel 2026 ha cambiato significato due volte: fino a marzo era il nome di `/branch`, fino a luglio lanciava il subagente che oggi si chiama `/subtask`.

## 6. Quando qualcosa va storto

### /rewind

Alias: `/undo`, `/checkpoint`.

Ti lascia provare la strada più audace, perché se va male torni indietro. Claude Code salva un checkpoint a ogni tuo messaggio, come spiega la [pagina sui checkpoint](https://code.claude.com/docs/en/checkpointing). Scegli il messaggio, poi cosa fare:

- riporti al punto di allora il codice, la conversazione o tutti e due; con il solo codice i file tornano com’erano, e nella conversazione resta perché la strada era sbagliata;
- con «Summarize from here» riassumi da quel messaggio in poi, per esempio una lunga sessione di debug, e le istruzioni iniziali restano intatte; con «Summarize up to here» riassumi la parte prima.

Se riporti indietro la conversazione, il tuo prompt di allora ricompare nel campo: lo correggi e lo rimandi. Ci arrivi anche con `Esc` `Esc`, ma solo a riga vuota.

Dentro Claude Code:
```
/rewind
```

> 💡 Pro-tip: **Non riporta indietro i file toccati solo da un comando Bash.** I checkpoint coprono i file che Claude modifica con i suoi strumenti per i file, e di solito non quelli dei subagenti. Per il resto il paracadute è git.

### /doctor

Alias: `/checkup`.

Quando qualcosa non va e non sai da dove cominciare, parti da qui. Controlla installazione, impostazioni, estensioni e `CLAUDE.md`, e propone correzioni che applica dopo il tuo sì. Se `claude` non parte proprio, la [guida ai problemi](https://code.claude.com/docs/en/troubleshooting) dice di lanciare `claude doctor` dalla shell, che fa solo la diagnosi.

Dentro Claude Code:
```
/doctor
```

> 💡 Pro-tip: **`/doctor prompt-audit` controlla le tue istruzioni.** Segnala quelle scritte per modelli vecchi, quelle che rimandano a file o comandi che non esistono e i file che si contraddicono, come spiega la [pagina sulla memoria](https://code.claude.com/docs/en/memory). Puoi anche indicargli un file: `/doctor prompt-audit CLAUDE.md`.

### /bug

Alias: `/share`.

Segnala un bug ad Anthropic, anche mentre Claude lavora. Prima dell’invio una schermata ti fa scegliere quanta conversazione allegare, e non parte niente senza il tuo sì. Per i suggerimenti sul prodotto c’è `/feedback`, che dalla 2.1.212 è un comando a parte.

Dentro Claude Code:
```
/bug la barra di stato sparisce dopo /clear
```

> 💡 Pro-tip: **Con un provider diverso da Anthropic, il report non parte.** Lo stesso senza credenziali Anthropic: Claude Code lo salva in `~/.claude/feedback-bundles/`, e mandarlo tocca a te.

## 7. Crea il tuo comando

Un comando tuo è una skill: un file di istruzioni con un nome. Lo metti in `.claude/skills/<nome>/SKILL.md` se vale per il progetto, in `~/.claude/skills/<nome>/SKILL.md` se vale per te in tutti i progetti. I vecchi file in `.claude/commands/` funzionano ancora; se c’è lo stesso nome nei due posti, vince la skill. Tutti i campi sono nella [pagina delle skill](https://code.claude.com/docs/en/skills).

Io, a fine compito, aggiorno il mio HANDOFF.md. Questa skill ne prepara la bozza:

`.claude/skills/passaggio/SKILL.md`:
```
---
description: Prepara una nota di passaggio sul lavoro della sessione, da copiare in HANDOFF.md
argument-hint: "[argomento]"
disable-model-invocation: true
allowed-tools: Bash(git status *)
---

Prepara una nota di passaggio sul lavoro di oggi su $0.

I file cambiati, secondo git:

!`git status --short`

Scrivi cosa è fatto, cosa resta da fare e il comando per ripartire.
Non modificare nessun file: mostrami solo il testo.
```

Il nome del comando è quello della cartella, quindi la lanci così:

Dentro Claude Code:
```
/passaggio "refactor del login"
```

`$0` è il primo argomento, `$1` il secondo, e `$ARGUMENTS` li prende tutti insieme. Le virgolette tengono insieme più parole: senza, `$0` sarebbe solo «refactor». La riga che comincia con `!` gira prima che il testo arrivi a Claude, e al suo posto Claude trova l’output di git. Se il comando fallisce, per esempio fuori da un repository, si ferma tutta la skill.

> 💡 Pro-tip: **`allowed-tools` concede in anticipo, non limita.** Gli strumenti elencati partono senza chiedere, gli altri restano disponibili. Il controllo di fiducia della cartella non lo ferma: prima di aprire Claude Code in un repository clonato, leggi gli `allowed-tools` e i blocchi `!` delle sue skill.

> 💡 Pro-tip: **Gli argomenti entrano nei blocchi `!` senza virgolette.** L’unica difesa è il controllo dei permessi sul comando finale: `allowed-tools` stretti, mai `Bash(*)`. Per questo nel mio esempio il blocco `!` non usa argomenti. Non lo dice la documentazione: viene dal codice di Claude Code 2.1.319.

> 💡 Pro-tip: **Decidi chi può lanciarla.** Con `disable-model-invocation: true` la lanci solo tu (pensa a un `deploy`). Con `user-invocable: false` la lancia solo Claude. Se la chiami come un comando integrato lo sostituisce, ma gli alias no: con una tua skill `usage`, `/cost` apre ancora l’originale.

Ultima cosa, il costo. La descrizione di ogni skill che Claude può lanciare da solo sta nel contesto: tutte insieme hanno l’1 % della finestra, e ognuna si taglia a 1.536 caratteri. Oltre il budget perdono la descrizione per prime quelle che usi meno. `/skill-doctor` ti dice quali non usi e quanto ti costano. Con `disable-model-invocation: true`, come nell’esempio, la descrizione resta fuori. Il resto della dieta è nell’[igiene di Claude Code](https://stocasticparrot.ai/spiegoni/igiene-claude-code/).

Più di cento comandi, 27 che contano. Da domani, almeno uno per ogni momento della giornata. Fine.

## Fonti

Verificato il 6 e il 7 novembre 2026 sulla documentazione ufficiale e sul codice di Claude Code 2.1.319. I comandi cambiano spesso: la data conta.

- Anthropic, documentazione di Claude Code, [Commands](https://code.claude.com/docs/en/commands): l’elenco dei comandi, i sei momenti della giornata e a cosa serve `/batch`.
- Anthropic, documentazione di Claude Code, [Interactive mode](https://code.claude.com/docs/en/interactive-mode): i prefissi, la coda dei comandi, le scorciatoie.
- Anthropic, documentazione di Claude Code, [Configure permissions](https://code.claude.com/docs/en/permissions): le regole allow, ask e deny.
- Anthropic, documentazione di Claude Code, [Choose a permission mode](https://code.claude.com/docs/en/permission-modes): cosa fa Claude in plan mode, come si approva il piano e il modo in cui parte una sessione.
- Anthropic, documentazione di Claude Code, [Model configuration](https://code.claude.com/docs/en/model-config): `opusplan`, che pianifica con Opus ed esegue con Sonnet.
- Anthropic, documentazione di Claude Code, [Manage costs effectively](https://code.claude.com/docs/en/costs): come `/usage` divide i consumi e i suggerimenti che dà.
- Anthropic, documentazione di Claude Code, [Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp): i server MCP.
- Anthropic, documentazione di Claude Code, [Keep Claude working toward a goal](https://code.claude.com/docs/en/goal): `/goal`, come scrivere la condizione e l’auto mode.
- Anthropic, documentazione di Claude Code, [CLI reference](https://code.claude.com/docs/en/cli-reference): i tetti `--max-turns` e `--max-budget-usd`.
- Anthropic, documentazione di Claude Code, [Manage multiple agents with agent view](https://code.claude.com/docs/en/agent-view): `/background`, `claude agents` e cosa passa in background.
- Anthropic, documentazione di Claude Code, [Create custom subagents](https://code.claude.com/docs/en/sub-agents): `/subtask` e i subagenti che ereditano la conversazione.
- Anthropic, documentazione di Claude Code, [Run prompts on a schedule](https://code.claude.com/docs/en/scheduled-tasks): `/loop`, i suoi ritmi, la scadenza e come si ferma.
- Anthropic, documentazione di Claude Code, [Review locally with `/code-review`](https://code.claude.com/docs/en/code-review-local): bersagli, livelli, `--fix` e `--comment` di `/code-review`.
- Anthropic, documentazione di Claude Code, [Find bugs with ultrareview](https://code.claude.com/docs/en/ultrareview): `/code-review ultra` e i suoi prezzi.
- Anthropic, documentazione di Claude Code, [Checkpointing](https://code.claude.com/docs/en/checkpointing): cosa ripristina `/rewind` e cosa no, e i due riassunti.
- Anthropic, documentazione di Claude Code, [Troubleshooting](https://code.claude.com/docs/en/troubleshooting): `/doctor` e `claude doctor`.
- Anthropic, documentazione di Claude Code, [How Claude remembers your project](https://code.claude.com/docs/en/memory): `/doctor prompt-audit`.
- Anthropic, documentazione di Claude Code, [Extend Claude with skills](https://code.claude.com/docs/en/skills): skill, argomenti, blocchi `!`, `allowed-tools`, precedenze e le skill che girano in un subagente.
- Anthropic, [changelog di Claude Code](https://code.claude.com/docs/en/changelog), fino alla 2.1.318 del 4 novembre 2026: le date dei cambi di nome e il worktree delle copie di `/fork`.