Claude Code CLI: Comandi Essenziali e Configurazione
Claude Code non è solo un assistente AI: è un terminale potenziato che si integra nel workflow quotidiano dello sviluppatore. Dalla riga di comando, puoi gestire file, eseguire build, lanciare test, analizzare codice e orchestrare task complessi, tutto attraverso un'interfaccia conversazionale che comprende il contesto del tuo progetto.
In questo dodicesimo articolo della serie, esploreremo in profondità la Command Line Interface di Claude Code: i metodi di installazione su ogni piattaforma, le scorciatoie da tastiera che accelerano il lavoro, i comandi slash per il controllo dell'agente, la gerarchia di configurazione a quattro livelli, i template di permessi per la sicurezza e la modalità headless per l'automazione CI/CD.
Cosa Imparerai
- Installare Claude Code su macOS, Linux, Windows e WSL
- Padroneggiare le scorciatoie da tastiera per velocizzare il workflow
- Usare tutti gli slash commands disponibili
- Comprendere la gerarchia di configurazione a 4 livelli
- Configurare template di permessi per diversi scenari di sicurezza
- Eseguire Claude Code in modalità headless per pipeline CI/CD
- Risolvere problemi comuni di installazione e configurazione
- Ottimizzare l'esperienza CLI per il lavoro quotidiano
Panoramica della Serie Completa
| # | Articolo | Focus |
|---|---|---|
| 1 | Claude come Partner Tecnico | Setup e primi passi |
| 2 | Contesto e Setup del Progetto | CLAUDE.md e configurazione |
| 3 | Ideazione e Requisiti | MVP e user personas |
| 4 | Architettura Backend e Frontend | Spring Boot e Angular |
| 5 | Struttura del Codice | Organizzazione e convenzioni |
| 6 | Prompt Engineering Avanzato | Tecniche avanzate |
| 7 | Testing e qualità | Strategie e generazione test |
| 8 | Documentazione Professionale | README, API, ADR |
| 9 | Deploy e DevOps | Docker, CI/CD, monitoring |
| 10 | Evoluzione e Manutenzione | Refactoring e scalabilità |
| 11 | Integrazione Progetto Reale | Claude Code in produzione |
| 12 | Claude Code CLI (sei qui) | Comandi e configurazione |
| 13 | Agent Skills | capacità modulari |
| 14 | Subagenti Specializzati | Agenti con ruoli specifici |
| 15 | Hooks e Automazione | Event-driven workflows |
| 16 | Ralph Wiggum Method | Sviluppo guidato da test |
| 17 | BMAD Method | Gestione progetti strutturata |
| 18 | Orchestrazione Multi-Agente | Pipeline di agenti |
| 19 | Collaborative Work | Team e pair programming AI |
| 20 | Sicurezza e Best Practice | Hardening e compliance |
| 21 | Monitoring e Observability | Metriche e debugging |
1. Installazione di Claude Code
Claude Code supporta molteplici piattaforme e metodi di installazione. La scelta del metodo
dipende dal sistema operativo e dalle preferenze personali. Tutti i metodi installano lo stesso
binario claude che viene aggiunto al PATH di sistema.
Prerequisiti
Prima di procedere con l'installazione, assicurati di avere i seguenti requisiti soddisfatti sul tuo sistema:
Requisiti di Sistema
| Requisito | Versione Minima | Note |
|---|---|---|
| Node.js | 18.0+ | Necessario per il runtime JavaScript |
| npm | 9.0+ | Incluso con Node.js |
| Git | 2.30+ | Per operazioni su repository |
| Sistema Operativo | macOS 12+, Ubuntu 20.04+, Windows 10+ (WSL2) | Supporto nativo Linux e macOS, WSL per Windows |
| Account Anthropic | Piano Pro, Max o Team | Necessario per l'autenticazione API |
Metodo 1: Installazione tramite npm (Consigliato)
Il metodo più universale è l'installazione globale tramite npm. Funziona su tutte le piattaforme dove Node.js è disponibile e garantisce aggiornamenti semplici.
# Installazione globale
npm install -g @anthropic-ai/claude-code
# Verifica installazione
claude --version
# Primo avvio e autenticazione
claude
# Aggiornamento alla versione più recente
npm update -g @anthropic-ai/claude-codeMetodo 2: Installazione tramite curl (macOS e Linux)
Per chi preferisce evitare npm, è disponibile uno script di installazione diretto che scarica il binario precompilato. Questo metodo è particolarmente utile in ambienti senza Node.js preinstallato.
# macOS e Linux
curl -fsSL https://cli.anthropic.com/install.sh | sh
# Verifica che il binario sia nel PATH
which claude
# Output atteso: /usr/local/bin/claude
# Prima esecuzione
claudeMetodo 3: Installazione tramite Homebrew (macOS)
Gli utenti macOS che utilizzano Homebrew come package manager possono installare Claude Code attraverso il tap ufficiale. Questo metodo integra Claude Code nella gestione centralizzata dei pacchetti di Homebrew.
# Aggiungere il tap ufficiale Anthropic
brew tap anthropics/claude-code
# Installazione
brew install claude-code
# Aggiornamento
brew upgrade claude-code
# Verifica versione
claude --versionMetodo 4: Installazione su Windows (PowerShell + WSL)
Su Windows, Claude Code richiede WSL2 (Windows Subsystem for Linux) per funzionare correttamente. L'installazione può essere eseguita direttamente dalla PowerShell di Windows o dall'interno del terminale WSL.
# Passo 1: Installare WSL2 (se non già installato)
wsl --install
# Passo 2: Aprire il terminale WSL (Ubuntu)
wsl
# Passo 3: Installare Node.js nel WSL
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
# Passo 4: Installare Claude Code
npm install -g @anthropic-ai/claude-code
# Passo 5: Verificare
claude --version
# Alternativa: Installazione diretta da PowerShell
# (Richiede Node.js installato su Windows)
npm install -g @anthropic-ai/claude-codeNota sulla Compatibilità Windows
Claude Code su Windows funziona meglio con WSL2 perchè molti tool di sviluppo (Git, compilatori, tool di build) sono nativamente supportati su Linux. Se lavori con progetti che richiedono strumenti Unix-like, WSL2 è fortemente raccomandato. L'esperienza con PowerShell nativa è supportata ma può avere limitazioni con alcuni comandi di sistema.
Autenticazione
Dopo l'installazione, il primo avvio di claude avvia il flusso di autenticazione.
Claude Code supporta due metodi di autenticazione principali.
Metodi di Autenticazione
| Metodo | Uso | Configurazione |
|---|---|---|
| Anthropic Console | Account individuali Pro/Max | Login via browser automatico al primo avvio |
| API Key | Account Team, Enterprise, CI/CD | Variabile d'ambiente ANTHROPIC_API_KEY |
| AWS Bedrock | Enterprise su infrastruttura AWS | Configurazione credenziali AWS |
| Google Vertex AI | Enterprise su infrastruttura GCP | Configurazione credenziali Google Cloud |
# Metodo 1: Variabile d'ambiente (sessione corrente)
export ANTHROPIC_API_KEY="sk-ant-api03-xxxxx"
# Metodo 2: File .env nella root del progetto
echo 'ANTHROPIC_API_KEY=sk-ant-api03-xxxxx' >> .env
# Metodo 3: Configurazione permanente in .bashrc o .zshrc
echo 'export ANTHROPIC_API_KEY="sk-ant-api03-xxxxx"' >> ~/.zshrc
source ~/.zshrc
# Verifica autenticazione
claude --print-auth-status2. Scorciatoie da Tastiera
Le scorciatoie da tastiera sono fondamentali per un uso efficiente di Claude Code. Conoscerle permette di passare rapidamente tra modalità operative, gestire il contesto e controllare il flusso di esecuzione senza interrompere il ritmo di lavoro.
Tabella Completa delle Scorciatoie
| Scorciatoia | Azione | Descrizione Dettagliata |
|---|---|---|
! |
Bash Mode | Attiva la modalità Bash diretta. Digita ! seguito dal comando
per eseguirlo nel terminale senza che Claude lo interpreti come prompt.
Esempio: !npm test esegue direttamente i test. |
@ |
Mention File/Folder | Menziona un file o una cartella per aggiungerli al contesto corrente.
Supporta autocompletamento con Tab. Esempio: @src/app/services/
carica l'intera cartella nel contesto. |
Esc |
Interrupt | Interrompe l'operazione corrente di Claude. Utile quando una generazione sta prendendo una direzione sbagliata o impiega troppo tempo. |
Esc + Esc |
Rewind Menu | Doppia pressione di Escape apre il menu di rewind che permette di tornare a uno stato precedente della conversazione, annullando le ultime azioni di Claude. |
Ctrl+R |
Full Output | Mostra l'output completo dell'ultimo comando eseguito, incluse le parti che potrebbero essere state troncate per brevita. |
Shift+Tab |
Auto-Accept (YOLO Mode) | Attiva la modalità di accettazione automatica per le operazioni successive. Claude eseguira le azioni senza chiedere conferma. Usare con cautela in ambienti di produzione. |
Shift+Tab+Tab |
Plan Mode | Attiva la modalità pianificazione. Claude analizza il task, crea un piano strutturato e lo presenta per approvazione prima di eseguire qualsiasi azione. |
Ctrl+C |
Cancel Input | Cancella il testo digitato nell'input corrente senza interrompere la sessione di Claude Code. |
Ctrl+D |
Exit | Chiude la sessione corrente di Claude Code salvando la cronologia della conversazione. |
Tab |
Autocompletamento | Autocompleta nomi di file, cartelle e comandi slash nel prompt di input. |
YOLO Mode: Uso e Precauzioni
La modalità YOLO (You Only Live Once) attivata con Shift+Tab è uno strumento
potente ma pericoloso. Quando attiva, Claude esegue tutte le operazioni - incluse
modifiche ai file, esecuzione di comandi e installazione di pacchetti - senza
chiedere conferma all'utente.
Quando Usare YOLO Mode
- Prototyping rapido: Quando stai esplorando idee in un branch dedicato
- Refactoring automatico: Quando hai già validato il piano e vuoi esecuzione rapida
- Generazione boilerplate: Quando Claude deve creare molti file simili
- Ambienti sandbox: Quando lavori in container Docker o VM usa-e-getta
Quando NON Usare YOLO Mode
- Produzione: Mai su branch main/master o ambienti di produzione
- Operazioni distruttive: Quando il task potrebbe comportare eliminazione di file
- Comandi di sistema: Quando Claude potrebbe eseguire comandi con sudo
- Dati sensibili: Quando il contesto contiene credenziali o dati riservati
Plan Mode: Pianificazione Strutturata
La modalità Plan (Shift+Tab+Tab) è l'opposto della YOLO mode. Costringe Claude
a creare un piano dettagliato prima di eseguire qualsiasi azione. Il piano include:
- Analisi del task richiesto e identificazione dei file coinvolti
- Sequenza ordinata di operazioni da eseguire
- Potenziali rischi e dipendenze tra le operazioni
- Stima del numero di file da modificare
- Richiesta esplicita di approvazione prima dell'esecuzione
# Attivare Plan Mode con Shift+Tab+Tab, poi scrivere il prompt:
> Aggiungi validazione email al form di registrazione
# Claude risponde con un piano:
# Piano di Esecuzione:
# 1. Leggere src/app/auth/register.component.ts
# 2. Leggere src/app/auth/register.component.html
# 3. Aggiungere validatore email al FormGroup
# 4. Aggiungere messaggio di errore nel template
# 5. Aggiungere test per la validazione email
# 6. Aggiornare il service di validazione
#
# File coinvolti: 4
# Operazioni: 6
#
# Procedere? [y/n]3. Slash Commands
Gli slash commands sono comandi speciali che controllano il comportamento di Claude Code.
Si digitano direttamente nel prompt preceduti dal carattere /. Ogni comando
ha una funzione specifica per gestire la sessione, il contesto e la configurazione.
Tabella Completa degli Slash Commands
| Comando | Descrizione | Esempio d'Uso |
|---|---|---|
/add-dir |
Aggiunge una directory al contesto di lavoro corrente | /add-dir ../shared-libs per includere librerie condivise |
/agents |
Mostra e gestisce i subagenti disponibili nella directory .claude/agents/ |
/agents per elencare tutti i subagenti configurati |
/clear |
Pulisce la cronologia della conversazione corrente, liberando contesto | /clear dopo aver completato un task per iniziare pulito |
/config |
Apre e modifica i file di configurazione di Claude Code | /config per visualizzare e modificare le impostazioni |
/help |
Mostra la guida completa dei comandi disponibili | /help per il riferimento rapido |
/mcp |
Gestisce i server MCP (Model Context Protocol) configurati | /mcp per vedere lo stato dei server connessi |
/model |
Cambia il modello AI utilizzato nella sessione corrente | /model claude-sonnet-4-20250514 per passare a Sonnet |
/permissions |
Visualizza e modifica i permessi concessi a Claude Code | /permissions per rivedere cosa Claude può fare |
/rewind |
Torna a uno stato precedente della conversazione | /rewind per annullare le ultime azioni |
/status |
Mostra lo stato corrente della sessione, contesto e utilizzo token | /status per verificare quanti token sono stati utilizzati |
Uso Avanzato degli Slash Commands
Gli slash commands possono essere combinati in sequenze logiche per gestire sessioni di lavoro complesse. Ecco alcuni pattern d'uso avanzati.
# Pattern 1: Reset del contesto per un nuovo task
/clear
/add-dir ./src/features/new-feature
Implementa il componente UserProfile seguendo i pattern esistenti
# Pattern 2: Verifica stato prima di operazioni critiche
/status
/permissions
Esegui il refactoring del modulo di pagamento
# Pattern 3: Cambio modello per task specifici
/model claude-sonnet-4-20250514 # Per task rapidi e frequenti
Genera i test boilerplate per tutti i service
/model claude-opus-4-20250514 # Per task complessi
Analizza l'architettura e proponi miglioramenti
# Pattern 4: Debug di connessioni MCP
/mcp
# Verifica che i server necessari siano connessi
# prima di eseguire task che li richiedonoComandi Personalizzati (Custom Slash Commands)
Oltre ai comandi built-in, Claude Code supporta la creazione di comandi personalizzati
tramite file Markdown nella directory .claude/commands/. Ogni file .md
diventa un comando slash invocabile nella sessione.
# Code Review Completa
Esegui una code review approfondita dei file modificati.
## Checklist
1. Verifica la correttezza logica del codice
2. Controlla naming conventions e coerenza
3. Identifica potenziali bug o edge case
4. Verifica la gestione degli errori
5. Controlla la copertura dei test
6. Valuta la performance e la scalabilità
## Output
Produci un report strutturato con:
- **Severita**: Critical / Major / Minor / Suggestion
- **File e riga**: Riferimento preciso
- **Problema**: Descrizione chiara
- **Soluzione**: Fix proposto con codice# Verifica Pre-Deploy
Prima di procedere con il deploy, controlla:
1. Esegui `npm run build` e verifica che non ci siano errori
2. Esegui `npm test` e verifica che tutti i test passino
3. Controlla che non ci siano console.log rimasti nel codice
4. Verifica che le variabili d'ambiente siano configurate
5. Controlla che il file .env.production sia aggiornato
6. Verifica la versione nel package.json
Riporta lo stato di ogni punto con un checkmark.
Una volta creati, i comandi personalizzati si invocano con /review o
/deploy-check direttamente nel prompt di Claude Code.
4. Gerarchia di Configurazione
Claude Code utilizza un sistema di configurazione a quattro livelli gerarchici, dove ogni livello può sovrascrivere le impostazioni del livello inferiore. Questa architettura permette di avere configurazioni granulari che vanno dalle policy aziendali fino alle preferenze personali del singolo sviluppatore.
Gerarchia di Configurazione (dal più alto al più basso)
| Livello | Percorso File | Scope | Priorità |
|---|---|---|---|
| Enterprise | /etc/claude-code/managed-settings.json |
Tutta l'organizzazione | Massima (non sovrascrivibile) |
| Progetto Locale | .claude/settings.local.json |
Singolo sviluppatore nel progetto | Alta |
| Progetto Condiviso | .claude/settings.json |
Tutti gli sviluppatori del progetto | Media |
| Utente Globale | ~/.claude/settings.json |
Tutti i progetti dell'utente | Base |
Livello 1: Enterprise (Massima Priorità)
La configurazione Enterprise è gestita dall'amministratore di sistema e si trova
in /etc/claude-code/managed-settings.json. Le impostazioni definite
a questo livello non possono essere sovrascritte da nessun altro livello.
È il meccanismo ideale per imporre policy di sicurezza aziendali.
{
"permissions": {
"deny": [
"Bash(rm -rf /*)",
"Bash(sudo *)",
"Bash(chmod 777 *)",
"Write(~/.ssh/*)",
"Write(~/.aws/*)"
]
},
"security": {
"max_file_size_bytes": 10485760,
"blocked_domains": ["*.internal.company.com"],
"require_approval_for_network": true
},
"model": {
"default": "claude-sonnet-4-20250514",
"allowed": ["claude-sonnet-4-20250514", "claude-opus-4-20250514"]
}
}Livello 2: Progetto Locale (settings.local.json)
Il file .claude/settings.local.json è specifico per il singolo sviluppatore
nel contesto di un progetto. Questo file non deve essere committato
nel repository (va aggiunto a .gitignore) perchè contiene preferenze personali.
{
"permissions": {
"allow": [
"Bash(npm run test:watch)",
"Bash(npm run dev)",
"Bash(docker compose up -d)"
]
},
"preferences": {
"model": "claude-opus-4-20250514",
"theme": "dark",
"auto_approve_reads": true
}
}Livello 3: Progetto Condiviso (settings.json)
Il file .claude/settings.json viene committato nel repository e condivide
le configurazioni del progetto con tutto il team. Qui vanno le regole e i permessi
che tutti gli sviluppatori devono seguire.
{
"permissions": {
"allow": [
"Bash(npm run *)",
"Bash(mvn *)",
"Bash(gradle *)",
"Bash(git status)",
"Bash(git diff *)",
"Bash(git log *)",
"Read(*)",
"Write(src/**/*)"
],
"deny": [
"Bash(git push --force *)",
"Bash(git reset --hard *)",
"Bash(rm -rf *)",
"Write(.env*)",
"Write(**/credentials*)",
"Write(**/secrets*)"
]
},
"context": {
"include_patterns": ["src/**/*.ts", "src/**/*.html", "src/**/*.css"],
"exclude_patterns": ["node_modules/**", "dist/**", ".angular/**"]
}
}Livello 4: Utente Globale
Il file ~/.claude/settings.json nella home directory dell'utente contiene
le preferenze globali che si applicano a tutti i progetti. È il livello con
la priorità più bassa e viene sovrascritto da qualsiasi configurazione di progetto.
{
"permissions": {
"allow": [
"Bash(ls *)",
"Bash(cat *)",
"Bash(which *)",
"Bash(node --version)",
"Read(*)"
]
},
"preferences": {
"model": "claude-sonnet-4-20250514",
"auto_approve_reads": true,
"verbose_output": false,
"language": "it"
}
}Risoluzione dei Conflitti
Quando la stessa impostazione è definita a più livelli, il livello con priorità
maggiore prevale. In caso di liste (come allow e deny),
le voci deny di livelli superiori prevalgono sempre sulle voci
allow di livelli inferiori. Questo garantisce che le policy
di sicurezza aziendali non possano essere aggirate.
5. Template di Permessi per la Sicurezza
I permessi controllano quali azioni Claude Code può eseguire senza chiedere conferma. La configurazione corretta dei permessi bilancia produttività e sicurezza. Ecco due template pronti all'uso per scenari comuni.
Template 1: Basic Security (Sviluppo Standard)
Questo template è ideale per lo sviluppo quotidiano su progetti dove vuoi che Claude abbia autonomia sui comandi di sviluppo comuni, ma con protezione sui file sensibili e le operazioni distruttive.
{
"permissions": {
"allow": [
"Bash(npm run *)",
"Bash(npm test *)",
"Bash(npm install *)",
"Bash(npx *)",
"Bash(git status)",
"Bash(git diff *)",
"Bash(git log *)",
"Bash(git branch *)",
"Bash(git checkout *)",
"Bash(git add *)",
"Bash(git commit *)",
"Bash(tsc *)",
"Bash(ng *)",
"Bash(mvn *)",
"Bash(gradle *)",
"Bash(python -m pytest *)",
"Bash(docker compose *)",
"Bash(curl *)",
"Read(*)",
"Write(src/**/*)",
"Write(tests/**/*)",
"Write(docs/**/*)"
],
"deny": [
"Write(.env*)",
"Write(**/*.pem)",
"Write(**/*.key)",
"Write(**/credentials*)",
"Write(**/secrets*)",
"Write(~/.ssh/*)",
"Write(~/.aws/*)",
"Bash(rm -rf *)",
"Bash(sudo *)",
"Bash(chmod 777 *)",
"Bash(git push --force *)",
"Bash(git reset --hard *)"
]
}
}Template 2: Strict Security (Ambienti Critici)
Questo template richiede approvazione esplicita per tutte le operazioni di scrittura e nega qualsiasi accesso alla rete. È ideale per ambienti con dati sensibili, compliance rigorosa o progetti in produzione.
{
"permissions": {
"allow": [
"Read(src/**/*)",
"Read(tests/**/*)",
"Read(docs/**/*)",
"Bash(git status)",
"Bash(git diff *)",
"Bash(git log *)"
],
"deny": [
"Write(*)",
"Bash(npm install *)",
"Bash(npx *)",
"Bash(curl *)",
"Bash(wget *)",
"Bash(ssh *)",
"Bash(scp *)",
"Bash(nc *)",
"Bash(git push *)",
"Bash(git commit *)",
"Bash(docker *)",
"Bash(sudo *)",
"Bash(rm *)",
"Bash(mv *)",
"Bash(cp *)"
]
},
"security": {
"require_approval_for_all_writes": true,
"require_approval_for_network": true,
"audit_log": true,
"max_file_modifications_per_session": 10
}
}Confronto tra i Template
| Aspetto | Basic Security | Strict Security |
|---|---|---|
| Lettura file | Automatica su tutti i file | Automatica solo su src/tests/docs |
| Scrittura file | Automatica su src, test, docs | Richiede approvazione per ogni file |
| Comandi build | Automatici (npm, mvn, gradle) | Negati - solo lettura |
| Comandi git | Lettura + commit/checkout | Solo lettura (status, diff, log) |
| Accesso rete | curl permesso, no ssh/scp | Completamente negato |
| File sensibili | Bloccati (.env, .pem, .key) | Bloccati (tutti i file in scrittura) |
| Uso ideale | Sviluppo quotidiano | Audit, compliance, produzione |
6. Modalità Headless
La modalità headless permette di eseguire Claude Code in modo non interattivo, ideale per l'integrazione in pipeline CI/CD, script di automazione e processi batch. In questa modalità, Claude riceve un prompt, lo esegue e restituisce il risultato in formato JSON strutturato.
Sintassi Base
# Sintassi base
claude --print "Analizza il codice in src/ e riporta i problemi" --output-format json
# Con limite di iterazioni
claude --print "Esegui i test e correggi i fallimenti" \
--output-format json \
--max-iterations 10
# Con modello specifico
claude --print "Genera la documentazione API" \
--output-format json \
--model claude-sonnet-4-20250514
# Con permessi espliciti
claude --print "Formatta tutti i file TypeScript" \
--output-format json \
--allowedTools "Bash(npx prettier --write src/**/*.ts)" \
--allowedTools "Read(*)"Flag Principali della Modalità Headless
Flag della Modalità Headless
| Flag | Descrizione | Valore Default |
|---|---|---|
--print |
Il prompt da eseguire in modalità non interattiva | Obbligatorio |
--output-format |
Formato dell'output (json, text, stream-json) |
text |
--max-iterations |
Numero massimo di iterazioni (tool use cycles) | Illimitato |
--model |
Modello AI da utilizzare | Da configurazione |
--allowedTools |
Tool permessi per l'esecuzione (ripetibile) | Da configurazione |
--verbose |
Output dettagliato con log di debug | false |
Integrazione con GitHub Actions
Un caso d'uso potente della modalità headless e l'integrazione con pipeline CI/CD. Ecco un esempio completo di workflow GitHub Actions che usa Claude Code per code review automatica su ogni Pull Request.
name: Claude Code Review
on:
pull_request:
types: [opened, synchronize]
jobs:
review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install Claude Code
run: npm install -g @anthropic-ai/claude-code
- name: Run Code Review
env:
ANTHROPIC_API_KEY: