Best practice per Claude Code: da 'utilizzabile' a 'davvero utile'

Uso Claude Code da oltre sei mesi, e ho incontrato più insidie di quante righe di codice abbia scritto.

All'inizio pensavo che Claude Code fosse solo un "Copilot più avanzato" — scrivi nel terminale, lui genera codice e si finisce lì. Poi ho capito che il potenziale di questo strumento è molto più alto di quanto immaginassi, ma solo se sai come usarlo.

Questo articolo combina documentazione ufficiale ed esperienza pratica per organizzare quelli che ritengo i consigli d'uso più importanti. Alcuni sono lezioni imparate a mie spese, altri sono funzionalità nascoste scoperte solo leggendo la documentazione.

1. CLAUDE.MD: La Funzionalità Più Sottovalutata

Se ricordi solo una cosa di questo articolo, ricorda questa: Scrivi bene il tuo CLAUDE.md.

CLAUDE.md è il file di istruzioni che Claude Code legge automaticamente all'inizio di ogni conversazione. È come un documento di benvenuto che scrivi per un nuovo collega — tutto ciò che vuoi che sappia, lo scrivi lì.

Molte persone non scrivono un CLAUDE.md o ne scrivono solo un paio di righe. Il risultato è che devono spiegare da capo la struttura del progetto, gli standard di codifica e le scelte tecnologiche in ogni conversazione. È come presentare l'azienda al tuo collega ogni singolo mattino.

Cosa dovrebbe includere un buon CLAUDE.md:

1# Nome del Progetto
2
3## Comandi di Build e Test
4- Installa dipendenze: npm install
5- Esegui test: npm test
6- Test singolo: npm test -- --grep "nome del test"
7- Formattazione: npm run format
8
9## Standard di Codifica
10- Python: Usa ruff per la formattazione, larghezza linea 88
11- Test: Usa pytest, un file di test per servizio
12- Route API: Usa nomi di file al plurale: users.py, orders.py
13- Messaggi di commit: Inglese, formato: tipo(ambito): descrizione
14
15## Decisioni Architetturali
16- Scegli Tailwind rispetto a CSS Modules perché il team lo ha standardizzato
17- I controlli dei permessi utente sono fatti nel middleware; non ripetere in ogni route
18- Prefisso chiave cache Redis: app:v1:
19
20## Insidie Comuni
21- Il limite del pool di connessioni DB è 20; non aprire nuove connessioni nei cicli
22- Non mockare il database; l'ultima volta i mock hanno superato ma la migrazione in produzione è fallita

Principi chiave:

Primo, scrivi cose che Claude non può dedurre dal codice. Il "perché" di un progetto è più importante del "cosa". Non devi spiegare come usare React, ma devi dirgli "abbiamo scelto Tailwind perché il team lo ha standardizzato."

Secondo, mantienilo sotto le 200 righe. La documentazione ufficiale menziona esplicitamente che se CLAUDE.md è troppo lungo, Claude potrebbe ignorare le regole. Usa intestazioni markdown ed elenchi puntati per mantenerlo scansionabile.

Terzo, non inserire contenuti che cambiano frequentemente. Documentazione API dettagliata o descrizioni file per file non appartengono a CLAUDE.md. Fornisci solo link.

I Quattro Livelli di CLAUDE.md

Claude Code supporta quattro livelli di CLAUDE.md, ordinati dal più alto al più basso in termini di priorità:

Nel mio CLAUDE.md globale, di solito scrivo:

1- Sono un ingegnere full-stack; non c'è bisogno di spiegare eccessivamente i concetti di base
2- Mantieni le risposte concise; salta le cortesie inutili
3- Non riassumere cosa hai fatto dopo le modifiche al codice; controllerò il diff
4- Dai priorità a soluzioni semplici; evita l'eccessiva complessità

Queste quattro righe possono farti risparmiare centinaia di correzioni ripetitive.

Avanzato: Organizza le regole con .claude/rules/

Man mano che un progetto cresce, un singolo file CLAUDE.md non basta. La soluzione ufficiale è più elegante: Dividi le regole nella directory .claude/rules/.

1.claude/rules/
2├── testing.md        # Standard di test
3├── api-style.md      # Stile di scrittura API
4└── frontend.md       # Convenzioni frontend

Ancora più potente, puoi usare il frontmatter YAML per limitare le regole a file specifici:

1---
2paths: ["src/api/**/*.ts", "src/routes/**/*.ts"]
3---
4
5Le route API devono includere validazione degli input e gestione degli errori.
6Tutti i nuovi endpoint richiedono test di integrazione in tests/api/.

In questo modo, la regola si carica solo quando Claude accede a file corrispondenti, risparmiando spazio nel contesto.

2. La Qualità del Prompt Determina la Qualità dell'Output

Sembra un cliché, ma ho visto troppe persone usare Claude Code in questo modo:

"Aiutami a scrivere una funzione di login"

Poi si preoccupano per un'enorme quantità di codice generato — questo non è quello che volevo.

Una buona istruzione dovrebbe contenere tre elementi: Obiettivo, Vincoli e Contesto.

Istruzione Scadente vs Istruzione Buona

Scadente: "Aggiungi una funzione di ricerca all'elenco utenti"

Buona: "Aggiungi una casella di ricerca sopra la tabella in @src/pages/UserList.tsx. La ricerca deve usare l'API backend /api/users?search=xxx, nessun filtro frontend. Usa un debounce di 300ms e mantieni lo stile coerente con il componente Filter esistente."

La differenza? Le buone istruzioni riducono l'ambiguità. Claude Code non deve indovinare se vuoi una ricerca frontend o backend, il tempo di debounce o gli standard di stile.

Suggerimenti Ufficiali per i Prompt

1. Usa @ per fare riferimento a file specifici

Claude Code supporta l'uso di @percorsofile per inserire direttamente il contenuto del file nel contesto. Invece di dire "quel codice relativo all'autenticazione", scrivere @src/auth/login.ts è molto più preciso. Puoi anche specificare intervalli di righe: @src/auth/login.ts#5-30.

2. Incolla screenshot e immagini

Usa Ctrl+V per incollare direttamente le immagini. Quando esegui il debug di problemi UI, uno screenshot di "come appare ora" rispetto a "come lo voglio io" è dieci volte più efficace di una descrizione testuale.

3. Fornisci criteri di validazione

Non dire solo "aiutami a risolvere questo bug", ma:

"Risolvi il problema per cui la ri-autenticazione fallisce dopo un timeout di login. Dopo la correzione, cliccando su qualsiasi pulsante dopo la scadenza del token si dovrebbe essere reindirizzati automaticamente alla pagina di login. I casi di test sono in @tests/auth.test.ts; eseguili per confermare che funzionino dopo la correzione."

Dai a Claude uno standard auto-verificabile — casi di test, screenshot, output atteso — così può controllare la qualità del proprio lavoro e ridurre i continui scambi.

4. Sii chiaro su cosa NON fare

Claude Code a volte può essere troppo zelante — chiedi di risolvere un bug e lui rifattorizza anche il codice circostante. Dire esplicitamente "cambia solo questa funzione, non toccare altro codice" fa risparmiare un sacco di problemi.

Quando le istruzioni vaghe sono utili

Non tutte le situazioni richiedono precisione. Le istruzioni vaghe sono in realtà migliori per attività esplorative:

• "Cosa si può migliorare in questo file?"
• "Aiutami a capire l'architettura di questo modulo"
• "Ci sono potenziali problemi con questo codice?"

Ma una volta arrivato alla fase di implementazione, torna alla modalità precisione.

3. MODALITÀ PIANIFICAZIONE: Pensa Chiaramente Prima di Agire

Claude Code ha una Modalità Pianificazione, che considero il flusso di lavoro più sottovalutato.

Come entrare in Modalità Pianificazione

Tre modi:

1# Avvia direttamente in modalità pianificazione
2claude --permission-mode plan
3
4# Cambia durante la conversazione (premi Shift+Tab due volte)
5Shift+Tab Shift+Tab
6
7# Dillo nel prompt
8"Non modificare ancora il codice, aiutami a fare un piano"

In Modalità Pianificazione, Claude Code può solo leggere file e cercare codice; non può apportare alcuna modifica. Esplora il codebase, analizza i tuoi requisiti e fornisce un piano di implementazione dettagliato.

Modo corretto di usare la Modalità Pianificazione

Operazione chiave: Premi Ctrl+G per aprire e modificare il piano nel tuo editor.

Questo significa che puoi:

1. Lasciare che Claude generi un piano iniziale
2. Ctrl+G per aprire il piano, cancellare le parti con cui non sei d'accordo e aggiungere le tue idee
3. Tornare alla modalità normale (Shift+Tab) e lasciare che Claude esegua secondo il piano modificato

Cambiare un piano richiede una frase; cambiare codice già scritto richiede dieci volte tanto.

Flusso di lavoro consigliato per attività complesse

Il processo standard ufficiale è di quattro passaggi: Esplora → Pianifica → Implementa → Verifica.

11. Entra in Modalità Pianificazione
22. Fai leggere a Claude il codice rilevante: "Leggi il codice in src/auth/ per capire la logica delle sessioni"
33. Richiedi un piano: "Sviluppa un piano di migrazione OAuth2"
44. Ctrl+G per rivedere e modificare il piano
55. Torna alla modalità normale
66. "Implementa secondo il piano, esegui i test dopo la scrittura"
77. Fai verificare a Claude rispetto ai requisiti

Quando non ti serve la Modalità Pianificazione

• Cambiare il nome di una variabile
• Correggere un ovvio errore di battitura
• Aggiungere una singola riga di log

Il criterio è semplice: Se c'è un solo modo per implementare l'attività, fallo direttamente. Se ci sono più scelte, pianifica prima.

4. SUB-AGENTI: Il Multitasking di Claude Code

I Sub-agenti sono un meccanismo potente: Claude Code può avviare processi AI indipendenti per gestire attività in parallelo. Ogni sub-agente ha la propria finestra di contesto e non ingombra la tua conversazione principale.

Tipi di Sub-agente Integrati

Il maggior valore dei Sub-agenti: Isolamento del Contesto

Quando chiedi a Claude di eseguire test, analizzare log o cercare molti file, queste operazioni generano output massicci che riempiono la tua finestra di contesto. Usa i sub-agenti per queste attività; l'output rimane nel contesto del sub-agente e solo un riepilogo ti viene restituito.

Ad esempio:

"Usa un sub-agente per eseguire tutti i test ed elencare i casi falliti"

"Usa un sub-agente per cercare tutti i file che usano API deprecate"

Esecuzione in background: Ctrl+B

Premi Ctrl+B per mettere un sub-agente in background. Puoi continuare a chattare con Claude su altre cose e riceverai una notifica quando l'attività in background sarà completata.

Adatto per:

• Esecuzione di suite di test (di solito richiede minuti)
• Ricerche di codice su larga scala
• Revisioni di codice non urgenti

Sub-agenti Personalizzati

Puoi creare agenti personalizzati nella directory .claude/agents/:

1---
2name: code-reviewer
3description: Esperto di revisione del codice. Attivato automaticamente dopo le modifiche al codice.
4tools: Read, Grep, Glob, Bash
5model: sonnet
6---
7
8Sei un revisore di codice senior. Controlla le seguenti dimensioni:
9- Chiarezza e leggibilità del codice
10- Completezza della gestione degli errori
11- Esposizione di informazioni sensibili
12- Validazione degli input
13- Insidie di performance

Poi chiamalo in conversazione usando @"code-reviewer (agent)".

5. Gestione del Contesto: La Chiave Più Trascurata

Sebbene la finestra di contesto di Claude Code sia grande (fino a 1 milione di token), non è infinita e la gestione del contesto determina direttamente la qualità dell'output.

Cosa c'è nel contesto?

• La cronologia della tua conversazione
• Tutti i contenuti dei file letti da Claude
• Output dell'esecuzione dei comandi
• File CLAUDE.md (caricato ogni volta)
• File Memory (prime 200 righe)
• Definizioni degli strumenti Skill e MCP caricate

Cinque Strategie Pratiche

1. /clear: Pulisci quando un'attività è completata

Non correggere bug, aggiungere funzionalità e rifattorizzare tutto nella stessa conversazione. /clear svuota il contesto ma mantiene CLAUDE.md, agendo come un riavvio gratuito.

2. /compact: Comprimi manualmente il contesto

Quando la conversazione diventa lunga, usa /compact per far sì che Claude riassuma e comprima automaticamente il dialogo precedente. Un modo migliore è aggiungere un focus alla compressione:

/compact focus on API changes and test results

In questo modo, Claude dà priorità al mantenimento del contenuto che ti interessa durante la compressione.

3. /context: Vedi cosa sta consumando il tuo contesto

Digita /context per vedere l'utilizzo corrente — quali file occupano quanti token e quanto spazio occupano le definizioni degli strumenti MCP. Trovo spesso server MCP inutili che occupano spazio enorme.

4. Usa i Sub-agenti per isolare il rumore

Eseguire test e analizzare log produce molto output. Lascia che siano i sub-agenti a farlo per mantenere pulito il contesto della conversazione principale.

5. Scrivi istruzioni di conservazione della compressione in CLAUDE.md

Puoi dire a Claude cosa deve essere mantenuto durante la compressione:

1# Istruzioni di Compressione
2Quando comprimi il contesto, mantieni sempre:
3- Elenco completo dei file modificati
4- Comandi di test e risultati
5- Decisioni architetturali chiave

Memory vs CLAUDE.md

A cosa serve Memory: Le tue preferenze ("a questa persona piacciono le risposte concise"), le convenzioni del progetto ("la distribuzione ha un passaggio speciale"), le decisioni storiche ("l'ultima volta abbiamo scelto l'opzione A a causa di X").

Cosa Memory NON è: Dettagli del codice, cronologia Git, stati temporanei — queste cose sono recuperate più accuratamente dal codice e da Git.

Usa il comando /memory per visualizzare e gestire tutti i Memory caricati.

6. Gestione dei Permessi: Bilanciare Sicurezza ed Efficienza

Claude Code fornisce cinque modalità di permesso, ciclabili con Shift+Tab durante la conversazione:

Configurazione delle Regole di Permesso

In .claude/settings.json, puoi controllare finemente i permessi per ogni strumento:

1{
2  "permissions": {
3    "allow": [
4      "Bash(npm run *)",
5      "Bash(git commit *)",
6      "Edit(src/**/*.ts)",
7      "Read(*.md)"
8    ],
9    "deny": [
10      "Bash(rm -rf *)",
11      "Edit(.env)"
12    ]
13  }
14}

Priorità delle regole: deny → ask → allow (deny ha la priorità più alta).

Questo significa che puoi permettere audacemente comandi comuni mentre usi deny per proteggere file sensibili. Ad esempio, i file .env non dovrebbero mai essere modificati.

Gerarchia dei File di Impostazione

Simile a CLAUDE.md, le impostazioni hanno più livelli:

1Policy dell'Organizzazione (Priorità Più Alta)
2  ↓
3Argomenti CLI
4  ↓
5.claude/settings.local.json (Locale, non committato in Git)
6  ↓
7.claude/settings.json (Livello progetto, condiviso con il team)
8  ↓
9~/.claude/settings.json (Globale, personale)
10  ↓
11Valori Predefiniti (Priorità Più Bassa)

Il mio consiglio: Metti le regole condivise dal team in .claude/settings.json, le preferenze personali in ~/.claude/settings.json e le configurazioni sensibili in .claude/settings.local.json (ricordati di aggiungerlo a .gitignore).

7. HOOKS: Trasformare le Regole in Leggi Ferree

Le istruzioni in CLAUDE.md sono "suggerimenti" — Claude le segue la maggior parte delle volte ma occasionalmente le dimentica. Gli hooks sono "leggi ferree" — vengono eseguiti a prescindere da tutto.

Gli hooks sono comandi shell attivati automaticamente da eventi specifici del ciclo di vita, configurati in settings.json.

Tipi di Evento Chiave

Esempi Pratici

Formattazione automatica — Esegui Prettier dopo ogni modifica:

1{
2  "hooks": {
3    "PostToolUse": [{
4      "matcher": "Edit|Write",
5      "hooks": [{
6        "type": "command",
7        "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
8      }]
9    }]
10  }
11}

Protezione dei file critici — Impedisci la modifica delle configurazioni di produzione:

1{
2  "hooks": {
3    "PreToolUse": [{
4      "matcher": "Edit|Write",
5      "hooks": [{
6        "type": "command",
7        "command": ".claude/hooks/protect-files.sh"
8      }]
9    }]
10  }
11}

Un comando hook che restituisce codice di uscita 0 significa permesso; codice di uscita 2 significa bloccato. Questo significa che puoi scrivere qualsiasi logica complessa.

Re-iniezione di informazioni chiave dopo la compressione del contesto:

1{
2  "hooks": {
3    "SessionStart": [{
4      "matcher": "compact",
5      "hooks": [{
6        "type": "command",
7        "command": "echo 'Usa Bun, non npm. Esegui bun test prima di fare commit.'"
8      }]
9    }]
10  }
11}

Questo risolve un problema comune: quando una lunga conversazione viene compressa, importanti istruzioni menzionate in precedenza potrebbero andare perse. Gli hooks possono re-iniettarle automaticamente dopo ogni compressione.

Quattro Tipi di Hooks

8. FLUSSO DI LAVORO GIT: Usare Bene WORKTREE

Claude Code può eseguire comandi Git, il che è un'arma a doppio taglio. Ma lo strumento ufficiale fornisce un'ottima rete di sicurezza: Worktree.

Git Worktree: Aree di Lavoro Isolate

1# Avvia Claude in un worktree isolato
2claude --worktree feature-auth
3claude --worktree bugfix-123
4
5# Genera automaticamente un nome
6claude --worktree

Worktree crea una copia indipendente del ramo Git in .claude/worktrees/. Qualunque cosa faccia Claude all'interno, non influenzerà il ramo principale. All'uscita:

• Se nessuna modifica → Pulizia automatica
• Se ci sono modifiche → Ti chiede se mantenerle o eliminarle

Questo è particolarmente utile per attività esplorative. Non sei sicuro che un piano di refactoring funzioni? Provalo in un worktree; se fallisce, buttalo via senza alcun rischio.

Alcune Leggi Ferree su Git

1. Non permettere mai a Claude Code di eseguire push automatico

Può fare commit, ma l'azione di push deve essere confermata da te. Una volta mandato in remoto, il costo del rollback aumenta significativamente.

2. Fai commit frequentemente

Fai commit dopo aver completato una piccola funzionalità. Usa /rewind per tornare a qualsiasi checkpoint, purché tu abbia registrazioni di commit.

3. Fai attenzione alle operazioni distruttive

Se Claude Code vuole eseguire git reset --hard, git push --force o rm -rf, pensa alle conseguenze prima di approvare. Queste operazioni non hanno annullamento. Puoi anche negare questi comandi nelle regole di permesso.

4. Ripristina il contesto da una PR

Questo carica automaticamente le modifiche e le discussioni della PR come contesto, perfetto per revisioni del codice o per continuare il lavoro di qualcun altro.

1claude --from-pr 123

9. Scorciatoie e Riferimento ai Comandi

Uso queste scorciatoie ogni giorno; consiglio vivamente di memorizzarle:

Scorciatoie Più Comuni

Comandi slash Più Comuni

1/compact [focus]     # Comprimi il contesto, puoi specificare un focus
2/clear              # Pulisci la conversazione, ricomincia
3/context            # Visualizza l'utilizzo del contesto
4/memory             # Visualizza e gestisci Memory
5/rewind             # Torna indietro a un checkpoint
6/resume [nome]       # Riprendi una conversazione precedente
7/model              # Cambia modello
8/effort [livello]    # Imposta la profondità di ragionamento: low/medium/high/max
9/init               # Genera automaticamente CLAUDE.md
10/mcp                # Gestisci i server MCP
11/permissions        # Visualizza le regole di permesso
12/cost               # Visualizza il consumo di token

/init è particolarmente utile per nuovi progetti — analizza automaticamente il tuo codebase e aiuta a generare una bozza di CLAUDE.md. Sebbene di solito richieda aggiustamenti manuali, è molto più veloce che partire da zero.

10. PENSIERO ESTESO: Fai Riflettere Claude Più a Fondo

Per problemi complessi, puoi abilitare la modalità Pensiero Esteso, consentendo a Claude di dedicare più tempo al ragionamento prima di rispondere.

Come usarlo

1# Scorciatoia
2Option+T (Mac) / Alt+T (Windows/Linux)
3
4# O tramite comando
5/effort high    # Ragionamento più profondo
6/effort max     # Massima profondità di ragionamento
7/effort low     # Attività semplici, risparmia token

Quando usarlo

• Decisioni architetturali complesse
• Debug complicato (molteplici cause possibili da eliminare)
• Progettazione di refactoring multi-passaggio
• Valutazione di pro e contro di più soluzioni

Quando non ti serve

• Semplici modifiche al codice
• Formattazione, ridenominazione
• Bug fix già chiari

Consiglio professionale: Scrivere "ultrathink" nel prompt può forzare la più alta profondità di ragionamento senza dover regolare manualmente le impostazioni di effort.

11. SERVER MCP: Connettere Claude al Mondo Esterno

MCP (Model Context Protocol) consente a Claude Code di comunicare con strumenti esterni — GitHub, database, Slack, Notion, ecc.

Aggiunta Rapida

1claude mcp add github -- npx @anthropic-ai/mcp-server-github
2claude mcp add postgres -- npx @anthropic-ai/mcp-server-postgres postgresql://localhost:5432/mydb

File di Configurazione

MCP è configurato in .mcp.json:

1{
2  "mcpServers": {
3    "github": {
4      "type": "stdio",
5      "command": "npx",
6      "args": ["@modelcontextprotocol/server-github"],
7      "env": {
8        "GITHUB_TOKEN": "$GITHUB_TOKEN"
9      }
10    }
11  }
12}

Nota il Sovraccarico del Contesto

Ogni server MCP consuma ulteriori 100-500+ token per le definizioni degli strumenti. Usa il comando /mcp per controllare il sovraccarico di ogni server e disabilitare quelli inutilizzati.

La mia esperienza: Non essere avido. 2-3 server MCP comunemente usati sono sufficienti. Installarne troppi consuma spazio del contesto con definizioni di strumenti, il che può effettivamente degradare la qualità dell'analisi del codice.

12. INTEGRAZIONE IDE: Più di un Semplice Terminale

VS Code

Dopo aver installato l'estensione Claude Code, puoi usare Claude direttamente in VS Code senza passare al terminale.

Funzionalità utili:

• Vista diff affiancata: Le modifiche di Claude sono mostrate come diff, chiare a colpo d'occhio
• Option+K / Alt+K: Inserisci rapidamente riferimenti @ al file corrente
• Conversazioni multi-scheda: Apri più conversazioni indipendenti in schede diverse
• Cmd+Shift+Esc: Apri rapidamente una nuova scheda di conversazione

JetBrains

Anche gli IDE JetBrains come IntelliJ, PyCharm, WebStorm hanno un plugin Claude Code. Basta cercare "Claude Code" nel marketplace dei plugin per installarlo.

13. Revisione del Codice: Fidati ma Verifica

La qualità del codice di Claude Code è generalmente buona, ma non dovresti fidarti ciecamente.

Problemi Comuni

1. Eccessiva complessità

Chiedi una semplice funzione di utilità e lui ti dà un intero strato di astrazione con generics, interfacce e pattern factory. Usare un martello pneumatico per rompere una noce.

Soluzione: Scrivi "dai priorità a soluzioni semplici" in CLAUDE.md, oppure dì esplicitamente "nessuna astrazione necessaria" nell'istruzione.

2. API allucinate

A volte usa API inesistenti o sintassi obsoleta, specialmente per nuove versioni di librerie di nicchia.

Soluzione: Esegui i test. Ecco perché le istruzioni dovrebbero includere standard di validazione.

3. Deriva dell'ambito

Gli chiedi di cambiare una funzione e lui rifattorizza l'intero file.

Soluzione: Dì esplicitamente "cambia solo X, non toccare altro codice." Oppure usa il comando /freeze per limitare l'ambito di modifica a directory specifiche.

Modalità Scrittore/Revisore

Una modalità avanzata raccomandata ufficialmente: Usa due sessioni indipendenti per interpretare i ruoli di "Scrittore" e "Revisore."

Due sessioni hanno contesti indipendenti; il Revisore non è influenzato dalla logica dello Scrittore e può trovare punti ciechi.

1Sessione A (Scrittore): "Implementa middleware di rate-limiting per API"
2Sessione B (Revisore): "Revisiona l'implementazione del rate-limiting in @src/middleware/rateLimiter.ts, 
3                     concentrandoti su casi limite, race condition e coerenza"
4Sessione A: "Correggi il feedback della revisione: [Incolla l'output di B]"

14. Cosa NON Fare con Claude Code

Dopo aver detto tanto su "cosa fare", parliamo di "cosa non fare".

1. Non fargli fare cose che non capisci affatto

Se non sai nulla di Kubernetes, non lasciare che Claude Code scriva configurazioni di deployment da usare direttamente. Non puoi revisionare ciò che non capisci.

2. Non usarlo in ambienti senza controllo di versione

Niente Git significa nessuna possibilità di rollback. Le modifiche di Claude Code potrebbero sovrascrivere i tuoi file; usarlo senza controllo di versione è come camminare su una corda tesa senza rete di sicurezza.

3. Non lanciargli un'attività enorme tutta in una volta

"Migra l'intero progetto da JavaScript a TypeScript"

Questa istruzione dà carta bianca a Claude Code, rendendo il risultato incontrollabile. Suddividilo in piccoli passaggi e conferma ogni passaggio prima di passare al successivo.

4. Non aspettarti la perfezione al primo tentativo

L'iterazione è normale. Usa /rewind per tornare indietro e usa feedback precisi per descrivere "cosa c'è che non va."

Riepilogo

La filosofia centrale dell'uso di Claude Code è semplice:

È un collaboratore estremamente capace, ma non un pilota automatico. Il volante è sempre nelle tue mani.

In ordine di importanza, i miei consigli sono:

1. Scrivi bene CLAUDE.md — Investi una volta, beneficia in ogni conversazione
2. Dai istruzioni precise — Obiettivo + Vincoli + Standard di validazione
3. Usa Plan Mode — Prima pianifica, poi agisci per compiti complessi
4. Gestisci il contesto — /clear, /compact, Sub-agents
5. Controlla i permessi — Nega operazioni pericolose, consenti comandi comuni
6. Fai commit frequenti — Mantieni la capacità di tornare indietro

Segui questi consigli e Claude Code può moltiplicare la tua efficienza diverse volte. Se non lo fai, ti aiuterà solo a creare caos più rapidamente.

Il valore di uno strumento dipende sempre da chi lo usa.

Quanto sopra è una combinazione della documentazione ufficiale di Claude Code e dell'esperienza pratica. Se hai pratiche migliori, condividile liberamente.