02 - Claude Code: Sviluppo Agentico da Terminale
Nel panorama degli strumenti di sviluppo assistito da AI, Claude Code occupa una posizione unica: e una CLI agentica che vive nel terminale, legge il tuo codebase, esegue comandi, modifica file e gestisce workflow complessi senza mai aprire un IDE. Non e un chatbot con accesso al codice: e un agente autonomo che opera nel tuo ambiente di sviluppo con la stessa naturalezza con cui un collega senior lavorerebbe al tuo fianco.
Questo articolo e un deep dive completo su Claude Code: dall'installazione alla configurazione avanzata, dall'architettura interna ai workflow pratici, dal sistema di permessi alla creazione di agenti personalizzati. Che tu sia uno sviluppatore esperto che vuole massimizzare la produttività o un team lead che sta valutando tool agentici, qui troverai tutto ciò che serve per padroneggiare questo strumento.
Cosa Imparerai
- Cos'è Claude Code e in cosa differisce dagli assistenti AI tradizionali
- Installazione, configurazione e struttura della directory
.claude/ - Architettura interna: tool calling, context window, permission model
- Tutti gli strumenti disponibili: Read, Write, Edit, Bash, Grep, Glob, Task, WebSearch
- Il sistema di permessi e il meccanismo degli hooks
- Come scrivere CLAUDE.md efficaci per guidare il comportamento dell'agente
- Subagenti, esecuzione parallela e worktree di isolamento
- Integrazione MCP (Model Context Protocol) per browser, database e servizi esterni
- Workflow pratici: TDD, code review, debugging, commit automatici
- Confronto con Cursor, GitHub Copilot e altri strumenti IDE-based
- Best practices, limitazioni note e strategie di workaround
Cos'è Claude Code: Il Paradigma Agentico nel Terminale
Claude Code e la CLI ufficiale di Anthropic per lo sviluppo agentico. A differenza dei chatbot tradizionali dove copi e incolli codice tra una finestra di chat e il tuo editor, Claude Code vive nel tuo terminale e ha accesso diretto al filesystem, può eseguire comandi shell, leggere e modificare file, cercare pattern nel codebase e orchestrare workflow multi-step senza intervento manuale.
Il termine agentico e fondamentale per comprendere la natura dello strumento. Un agente AI non si limita a rispondere a domande: agisce. Claude Code analizza il contesto del progetto, pianifica le modifiche necessarie, le implementa attraverso una serie di tool call, verifica i risultati e itera fino al completamento del task. E la differenza tra chiedere a qualcuno "come faccio X?" e dire "fai X" a un collaboratore competente.
Chatbot vs Agente: La Differenza Fondamentale
Un chatbot genera testo in risposta a un prompt. Un agente ha accesso a strumenti (tool) e può compiere azioni nel mondo reale: leggere file, eseguire comandi, modificare codice, navigare il web. Claude Code e un agente che opera nel tuo ambiente di sviluppo con un ciclo continuo di osservazione-ragionamento-azione fino al completamento dell'obiettivo.
Claude Code e alimentato dal modello Claude (attualmente Opus 4.6, Sonnet 4.6 e varianti) e si interfaccia con il codebase attraverso un set di tool nativi progettati specificamente per operazioni di sviluppo software. A febbraio 2026, GitHub ha integrato Claude Code nella piattaforma Agent HQ, consolidandone il ruolo come agente di riferimento nell'ecosistema di sviluppo professionale.
Installazione e Configurazione
L'installazione di Claude Code e diretta e richiede Node.js 18+ e npm. Il processo prevede tre fasi: installazione del pacchetto, configurazione dell'autenticazione e personalizzazione dell'ambiente.
Installazione Base
# Installazione globale
npm install -g @anthropic-ai/claude-code
# Verifica installazione
claude --version
# Primo avvio - si apre il browser per l'autenticazione
claude
# Oppure con API key diretta
export ANTHROPIC_API_KEY=sk-ant-...
claudeAl primo avvio, Claude Code propone l'autenticazione tramite browser (OAuth) oppure tramite API key diretta. Per uso personale e sufficiente la API key; per team e organizzazioni e consigliato l'accesso tramite Anthropic Console con gestione centralizzata delle credenziali.
La Directory .claude/
Dopo l'inizializzazione, Claude Code crea una directory .claude/ nella root
del progetto (e opzionalmente nella home directory dell'utente per configurazioni globali).
Questa directory e il centro nevralgico della configurazione.
.claude/
├── settings.json # Configurazione permessi e tool
├── agents/ # Definizioni agenti personalizzati
│ ├── planner.md
│ ├── code-reviewer.md
│ └── security-reviewer.md
├── commands/ # Comandi slash personalizzati
│ └── review.md
├── hooks/ # Hook pre/post tool execution
│ └── pre-commit-check.sh
├── rules/ # Regole di comportamento
│ └── coding-style.md
├── skills/ # Skill personalizzate
│ └── angular-patterns.md
└── README.md # Documentazione localeIl File settings.json
Il file settings.json controlla i permessi, i tool autorizzati e il
comportamento globale dell'agente. E il primo file da configurare per un'esperienza
produttiva.
{
"permissions": {
"allow": [
"Read",
"Glob",
"Grep",
"Edit",
"Write",
"Bash(npm run lint)",
"Bash(npm run test)",
"Bash(npm run build)",
"Bash(git status)",
"Bash(git diff)",
"Bash(git log)"
],
"deny": [
"Bash(rm -rf *)",
"Bash(git push --force)",
"Bash(git reset --hard)"
]
},
"alwaysThinkingEnabled": true,
"model": "claude-opus-4-6"
}Sicurezza della Configurazione
La sezione deny e critica per la sicurezza del progetto. Bloccare comandi
distruttivi come rm -rf, git push --force e
git reset --hard previene danni accidentali o causati da allucinazioni
del modello. E buona pratica aggiungere al deny qualsiasi comando che possa causare
perdita irreversibile di dati.
CLAUDE.md: Le Istruzioni per l'Agente
Il file CLAUDE.md e il cuore della personalizzazione di Claude Code. Posizionato
nella root del progetto, contiene le istruzioni che l'agente legge automaticamente a ogni
sessione. Pensalo come un onboarding document per un nuovo membro del team:
descrive il progetto, le convenzioni, le architetture e le aspettative.
Struttura di un CLAUDE.md Efficace
# CLAUDE.md
## Project Overview
Questo e un portfolio Angular 21 con SSR.
Stack: Angular 21, TypeScript 5.9, Express, Firebase Hosting.
## Architecture
- Standalone components (no modules)
- Signals per state management
- OnPush change detection
- Component-scoped CSS
## Coding Standards
- TypeScript strict mode
- Immutable data patterns
- File max 800 righe
- Funzioni max 50 righe
- kebab-case per file, PascalCase per classi
## Commands
- `npm start` - Dev server
- `npm run build` - Production build con SSR
- `npm test` - Run tests
- `npm run deploy` - Deploy Firebase
## Important Patterns
- Ogni articolo blog = 4 file (IT/EN component + template)
- Registrazione in src/app/articles/index.ts
- Blog entries in src/app/services/blog.service.ts
- Angular template: escape { } con HTML entities nei code block
## Do NOT
- Non modificare file di configurazione Firebase
- Non committare direttamente su main
- Non usare NgModules (solo standalone)
- Non usare subscribe() - preferire async pipe o toSignal()Un CLAUDE.md ben scritto riduce drasticamente gli errori dell'agente e migliora la qualità dell'output. Le sezioni più importanti sono: Project Overview (contesto generale), Architecture (decisioni tecniche), Coding Standards (convenzioni) e Do NOT (vincoli espliciti).
Rules Directory: Regole Modulari
Oltre al CLAUDE.md, Claude Code supporta una directory .claude/rules/ dove
inserire regole organizzate per dominio. Questo approccio modulare e preferibile per
progetti complessi.
# Coding Style Rules
## Immutability (CRITICAL)
ALWAYS create new objects, NEVER mutate existing ones.
Use spread operator, Object.assign(), or immutable libraries.
## File Organization
- Many small files > few large files
- 200-400 lines typical, 800 max
- Extract utilities from large modules
- Organize by feature/domain, not by type
## Error Handling
- Handle errors explicitly at every level
- Provide user-friendly messages in UI code
- Log detailed context server-side
- Never silently swallow errorsIl Sistema di Memoria
Claude Code dispone di un meccanismo di memoria persistente tra sessioni.
Il file MEMORY.md nella directory .claude/ viene aggiornato
automaticamente dall'agente con le lezioni apprese durante le sessioni di lavoro: pattern
scoperti, errori comuni, configurazioni specifiche del progetto e decisioni architetturali.
# Project Memory
## Angular Template Gotchas
- Curly braces in code blocks: wrap in ngNonBindable
AND escape { with { and } with }
- <T> generic types: escape < with < and > with >
- @ decorators in code: escape with @
## Blog Article Pattern
- Each article = 4 files: IT component + template, EN component + template
- Registration in src/app/articles/index.ts
- Blog entries in src/app/services/blog.service.ts
- Max ID: 288 (as of April 2026)Architettura e Funzionamento Interno
Comprendere come Claude Code funziona internamente e essenziale per usarlo efficacemente. L'architettura si basa su tre pilastri: il ciclo agentico, il tool system e la context window management.
Il Ciclo Agentico
Quando invii un messaggio a Claude Code, il sistema entra in un ciclo che si ripete fino al completamento del task:
- Ricezione - L'agente riceve il tuo messaggio con tutto il contesto accumulato
- Ragionamento - Il modello analizza la richiesta e pianifica le azioni necessarie (extended thinking)
- Tool Call - L'agente invoca uno o più tool (Read, Edit, Bash, etc.)
- Osservazione - I risultati dei tool vengono aggiunti al contesto
- Iterazione - Il modello valuta i risultati e decide se servono altre azioni
- Risposta - Quando il task e completo, l'agente fornisce un riepilogo
Questo ciclo può ripetersi decine di volte per un singolo task complesso. Per esempio, implementare una nuova feature potrebbe richiedere: leggere file esistenti (Read), cercare pattern (Grep/Glob), creare nuovi file (Write), modificare file esistenti (Edit), eseguire test (Bash), correggere errori e ripetere.
Context Window Management
La context window e la quantità di informazione che il modello può elaborare in una singola interazione. Claude Code gestisce il contesto in modo intelligente attraverso diversi meccanismi:
- Caricamento selettivo - Non carica l'intero codebase in memoria. Usa Glob e Grep per trovare file rilevanti e Read per leggere solo quelli necessari.
- Compaction automatica - Quando il contesto si avvicina al limite, Claude Code compatta la conversazione mantenendo le informazioni più rilevanti e scartando dettagli obsoleti.
- Subagenti - Per task complessi che richiedono molto contesto, Claude Code può delegare sotto-task a subagenti con contesto isolato (Task tool).
- Extended thinking - Il modello riserva fino a 31.999 token per il ragionamento interno, separato dal contesto della conversazione.
La Compaction: Quando e Come Avviene
La compaction e il processo con cui Claude Code riassume la conversazione quando il contesto diventa troppo grande. E un'operazione automatica che preserva: le istruzioni del CLAUDE.md, le decisioni architetturali prese, i file modificati e il loro stato attuale, e gli errori incontrati. Tuttavia, dettagli specifici di iterazioni precedenti possono essere persi. Per task molto lunghi, e preferibile suddividere il lavoro in sessioni più brevi e focalizzate.
Gli Strumenti Principali
Claude Code dispone di un set di tool nativi progettati per coprire l'intero spettro delle operazioni di sviluppo. Ogni tool ha un ruolo specifico e regole di utilizzo precise.
Tool di Lettura e Ricerca
| Tool | Funzione | Quando Usarlo |
|---|---|---|
| Read | Legge il contenuto di un file specifico | Quando conosci il path esatto del file |
| Glob | Cerca file per pattern di nome | Per trovare file: **/*.ts, src/**/*.spec.ts |
| Grep | Cerca contenuto all'interno dei file | Per trovare pattern, funzioni, classi nel codebase |
Tool di Scrittura e Modifica
| Tool | Funzione | Quando Usarlo |
|---|---|---|
| Write | Crea o sovrascrive un file intero | Per nuovi file o riscritture complete |
| Edit | Sostituisce porzioni specifiche di un file | Per modifiche chirurgiche a file esistenti |
Tool di Esecuzione
| Tool | Funzione | Quando Usarlo |
|---|---|---|
| Bash | Esegue comandi shell nel terminale | Build, test, git, npm, qualsiasi comando CLI |
| Task | Lancia subagenti con contesto isolato | Per task complessi che richiedono contesto dedicato |
Tool Web e Ricerca
| Tool | Funzione | Quando Usarlo |
|---|---|---|
| WebSearch | Effettua ricerche web | Per documentazione, aggiornamenti, best practices |
| WebFetch | Scarica e analizza contenuto di una URL | Per leggere documentazione, API reference, articoli |
Esempio Pratico: Ciclo Completo di Utilizzo Tool
# L'utente chiede: "Aggiungi un nuovo campo 'priority' al modello Task"
# 1. Claude Code cerca il modello esistente
Glob: src/app/models/**/*.ts
# Risultato: src/app/models/task.model.ts
# 2. Legge il file del modello
Read: src/app/models/task.model.ts
# Risultato: export interface Task { id: string; title: string; }
# 3. Modifica il modello aggiungendo il campo
Edit: src/app/models/task.model.ts
# old_string: "title: string;"
# new_string: "title: string;\n priority: 'low' | 'medium' | 'high';"
# 4. Cerca tutti i file che usano il modello
Grep: pattern "Task" in src/app/**/*.ts
# Risultato: 5 file trovati
# 5. Legge e aggiorna ogni file che crea oggetti Task
# ... (ciclo di Read + Edit per ogni file)
# 6. Esegue i test per verificare
Bash: npm run test
# Risultato: 2 test falliti
# 7. Corregge i test che falliscono
# ... (ciclo di Read + Edit per i test)
# 8. Riesegue i test
Bash: npm run test
# Risultato: All tests passedIl Sistema di Permessi
Il sistema di permessi di Claude Code e progettato secondo il principio del least privilege: l'agente può fare solo ciò che e esplicitamente autorizzato. Questo e fondamentale per la sicurezza, soprattutto quando l'agente opera su codebase di produzione.
Le Tre Modalità di Permesso
| Modalità | Comportamento | Caso d'Uso |
|---|---|---|
| Allow | Il tool viene eseguito senza chiedere conferma | Operazioni sicure: lettura file, ricerche |
| Ask | Claude Code chiede conferma prima di eseguire | Default per la maggior parte delle operazioni |
| Deny | Il tool viene bloccato completamente | Operazioni pericolose: delete, force push |
I permessi possono essere configurati a tre livelli: globale
(~/.claude/settings.json), progetto
(.claude/settings.json) e sessione (tramite il prompt
interattivo). I permessi di progetto sovrascrivono quelli globali, e i permessi di
sessione sovrascrivono quelli di progetto.
Permessi Granulari per Bash
Il tool Bash supporta permessi granulari basati sul comando specifico. Questo permette di autorizzare comandi sicuri mantenendo il blocco su quelli pericolosi.
{
"permissions": {
"allow": [
"Bash(npm run lint)",
"Bash(npm run test)",
"Bash(npm run build)",
"Bash(git status)",
"Bash(git diff)",
"Bash(git log *)",
"Bash(git add *)",
"Bash(git commit *)"
],
"deny": [
"Bash(rm -rf *)",
"Bash(git push --force *)",
"Bash(git reset --hard *)",
"Bash(git clean -f *)",
"Bash(git branch -D *)"
]
}
}Il Principio della Difesa in Profondità
Non affidarti solo ai permessi. Combina: (1) permessi restrittivi nel settings.json, (2) istruzioni esplicite nel CLAUDE.md su cosa NON fare, (3) hooks che validano le operazioni prima dell'esecuzione, e (4) git hooks standard (pre-commit, pre-push) come ultima linea di difesa. La sicurezza e a strati.
Il Sistema di Hooks
Gli hooks di Claude Code sono script che vengono eseguiti automaticamente prima (PreToolUse) o dopo (PostToolUse) l'invocazione di un tool, oppure quando la sessione termina (Stop). Sono il meccanismo più potente per personalizzare e controllare il comportamento dell'agente.
Tipi di Hook
| Hook | Quando si Attiva | Caso d'Uso Tipico |
|---|---|---|
| PreToolUse | Prima dell'esecuzione di un tool | Validazione parametri, blocco condizionale, logging |
| PostToolUse | Dopo l'esecuzione di un tool | Auto-formatting, linting, verifica risultati |
| Stop | Quando la sessione termina | Verifica finale, cleanup, generazione report |
Esempio: Hook per Auto-Formatting
{
"hooks": {
"PostToolUse": [
{
"tool": "Edit",
"command": "npx prettier --write $CLAUDE_FILE_PATH",
"description": "Auto-format dopo ogni modifica"
},
{
"tool": "Write",
"command": "npx prettier --write $CLAUDE_FILE_PATH",
"description": "Auto-format dopo creazione file"
}
],
"PreToolUse": [
{
"tool": "Bash",
"command": "echo 'Executing: $CLAUDE_TOOL_INPUT'",
"description": "Log ogni comando Bash"
}
],
"Stop": [
{
"command": "npm run lint",
"description": "Lint finale prima di chiudere"
}
]
}
}
Gli hooks ricevono informazioni contestuali tramite variabili d'ambiente come
$CLAUDE_FILE_PATH (il file su cui si sta operando) e
$CLAUDE_TOOL_INPUT (i parametri del tool). Questo permette di creare
logiche condizionali sofisticate.
Hook Avanzato: Prevenzione Modifica File Critici
Un hook PreToolUse può impedire la modifica di file sensibili (come configurazioni di
produzione o file di credenziali) verificando il path del file prima di consentire
l'operazione Edit o Write. Se il path corrisponde a un pattern vietato (es.
**/production.config.*), l'hook restituisce un errore e blocca l'operazione.
Agenti e Subagenti: Orchestrazione Multi-Task
Una delle capacità più potenti di Claude Code e il Task tool, che permette di lanciare subagenti con contesto isolato. Ogni subagente opera in una "sandbox" separata, con il proprio contesto, e restituisce risultati al processo principale.
Quando Usare i Subagenti
- Task paralleli indipendenti - Analizzare simultaneamente sicurezza, performance e accessibilità di un componente
- Contesto isolato - Quando un sotto-task richiede contesto specifico che non serve al task principale
- Analisi multi-prospettiva - Far esaminare lo stesso codice da "prospettive" diverse (security expert, performance engineer, UX reviewer)
- Task di lunga durata - Delegare operazioni lunghe mentre il processo principale continua con altro
Esempio: Code Review Multi-Prospettiva
# Prompt al task principale:
"Fai una code review completa del componente
src/app/components/payment-form/"
# Claude Code lancia 3 subagenti in parallelo:
# Subagente 1: Security Review
Task: "Analizza il componente payment-form per
vulnerabilità di sicurezza: XSS, injection,
gestione dati sensibili, CSRF."
# Subagente 2: Performance Review
Task: "Analizza le performance del componente
payment-form: change detection, memory leaks,
ottimizzazione rendering, lazy loading."
# Subagente 3: Accessibility Review
Task: "Verifica l'accessibilità del componente
payment-form: ARIA labels, keyboard navigation,
focus management, color contrast."
# I 3 risultati vengono combinati nel report finaleAgenti Personalizzati
La directory .claude/agents/ permette di definire agenti specializzati con
istruzioni e personalità specifiche. Ogni file Markdown in questa directory diventa un
agente invocabile.
# Code Reviewer Agent
## Role
Sei un senior code reviewer con 15 anni di esperienza.
Sei rigoroso ma costruttivo.
## Review Checklist
Per ogni file analizzato, verifica:
1. Naming: variabili, funzioni e classi hanno nomi chiari
2. Complexity: nessuna funzione > 50 righe
3. Immutability: nessuna mutazione di stato
4. Error handling: tutti gli errori gestiti
5. Types: nessun `any`, tipi specifici ovunque
6. Security: input validati, nessun dato hardcoded
## Output Format
Classifica ogni issue trovata:
- CRITICAL: bug o vulnerabilità (blocca il merge)
- HIGH: problemi architetturali (da risolvere)
- MEDIUM: miglioramenti di qualità (consigliati)
- LOW: suggerimenti stilistici (opzionali)Worktree di Isolamento
Per task che richiedono modifiche sperimentali senza rischiare il branch corrente, Claude
Code supporta i git worktree. Il tool EnterWorktree crea un worktree
isolato in .claude/worktrees/ con un nuovo branch basato su HEAD.
Al termine della sessione, l'utente può scegliere di mantenere o eliminare il worktree.
MCP Integration: Model Context Protocol
Il Model Context Protocol (MCP) e uno standard aperto che permette a Claude Code di comunicare con servizi esterni attraverso server MCP. Questo estende enormemente le capacità dell'agente oltre il filesystem locale.
Architettura MCP
L'architettura MCP segue un modello client-server dove Claude Code agisce come client e i server MCP espongono tool aggiuntivi. Un server MCP può fornire accesso a: browser web, database, API esterne, servizi cloud, sistemi di CI/CD e molto altro.
Casi d'Uso MCP Comuni
| Server MCP | Funzionalità | Esempio d'Uso |
|---|---|---|
| Browser Automation | Navigazione web, click, screenshot, form filling | Test E2E, scraping, automazione workflow |
| Database | Query SQL/NoSQL, schema exploration | Debug dati, migrazione schema |
| GitHub | PR, issues, code review, actions | Automazione workflow GitHub |
| Figma | Lettura design, estrazione componenti | Generazione codice da design |
{
"mcpServers": {
"browser": {
"command": "npx",
"args": ["@anthropic-ai/claude-code-mcp-browser"],
"description": "Browser automation server"
},
"postgres": {
"command": "npx",
"args": ["@modelcontextprotocol/server-postgres"],
"env": {
"DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
}
}
}
}MCP e Sicurezza
Ogni server MCP ha accesso alle risorse che gli vengono configurate. Un server database ha accesso al database, un server browser può navigare il web. E fondamentale applicare il principio del least privilege anche ai server MCP: usa credenziali read-only dove possibile, limita l'accesso a database di sviluppo e non esporre credenziali di produzione.
Skills e Comandi Personalizzati
Il sistema di Skills di Claude Code permette di definire capacità specializzate che l'agente può invocare durante le sessioni. A differenza degli agenti (che definiscono personalità e approccio), le skills definiscono procedure specifiche per task ricorrenti.
Comandi Slash Personalizzati
I comandi slash sono scorciatoie invocabili con la sintassi /nomecomando
durante una sessione. Si definiscono come file Markdown nella directory
.claude/commands/.
# /review Command
Esegui una code review completa dei file modificati
nell'ultimo commit.
## Steps
1. Esegui `git diff HEAD~1` per ottenere le modifiche
2. Per ogni file modificato:
a. Leggi il file completo per contesto
b. Analizza le modifiche per:
- Bug potenziali
- Violazioni degli standard di coding
- Problemi di sicurezza
- Opportunità di miglioramento
3. Genera un report con severity levels:
CRITICAL, HIGH, MEDIUM, LOW
4. Suggerisci fix specifici per issues CRITICAL e HIGHSkill Personalizzate
Le skills nella directory .claude/skills/ sono più elaborate dei comandi
e possono includere contesto tecnico, esempi e procedure multi-step.
# Angular Blog Article Creation Skill
## Context
Questo progetto usa Angular 21 con articoli blog
che richiedono 4 file per articolo (IT + EN).
## Procedure
1. Crea il component TypeScript (IT):
src/app/articles/{series}/{name}.component.ts
2. Crea il template HTML (IT):
src/app/articles/{series}/{name}.component.html
3. Crea il component TypeScript (EN):
src/app/articles/{series}/{name}.en.component.ts
4. Crea il template HTML (EN):
src/app/articles/{series}/{name}.en.component.html
5. Registra in src/app/articles/index.ts
6. Aggiungi BlogPost in blog.service.ts
## Template Rules (CRITICAL)
- Escape { } nei code block con HTML entities
- Wrap code blocks in ngNonBindable
- Escape <T> generics con < >
- Escape @ decorators con @Workflow Pratici con Claude Code
La teoria e importante, ma il valore reale di Claude Code emerge nei workflow quotidiani. Vediamo come utilizzarlo per i task più comuni dello sviluppo software.
1. Test-Driven Development (TDD)
# Prompt:
"Implementa un servizio UserService con TDD.
Deve supportare: getById, create, update, delete.
Usa il pattern Repository per l'accesso ai dati."
# Claude Code:
# 1. Crea i test PRIMA dell'implementazione (RED)
Write: src/app/services/user.service.spec.ts
# Test per getById, create, update, delete
# 2. Esegue i test - devono FALLIRE
Bash: npm run test -- --filter=UserService
# Risultato: 4 test FAILED (come previsto)
# 3. Implementa il servizio (GREEN)
Write: src/app/services/user.service.ts
# Implementazione minima per far passare i test
# 4. Esegue i test - devono PASSARE
Bash: npm run test -- --filter=UserService
# Risultato: 4 test PASSED
# 5. Refactoring (IMPROVE)
Edit: src/app/services/user.service.ts
# Migliora la struttura mantenendo i test verdi
# 6. Verifica copertura
Bash: npm run test -- --coverage2. Debugging Interattivo
# Prompt:
"Il componente Dashboard non renderizza i dati.
La console mostra 'Cannot read properties of undefined'.
Trova e correggi il bug."
# Claude Code:
# 1. Cerca il componente
Glob: src/**/dashboard*
# 2. Legge il componente e il template
Read: src/app/components/dashboard/dashboard.component.ts
Read: src/app/components/dashboard/dashboard.component.html
# 3. Cerca il servizio che fornisce i dati
Grep: pattern "DashboardService" in src/
# 4. Legge il servizio
Read: src/app/services/dashboard.service.ts
# 5. Identifica il problema: la risposta API ha una
# struttura diversa da quella attesa
# 6. Corregge il mapping dei dati
Edit: src/app/services/dashboard.service.ts
# 7. Aggiunge null check nel template
Edit: src/app/components/dashboard/dashboard.component.html
# 8. Verifica la build
Bash: npm run build3. Commit Workflow Automatico
Claude Code ha un workflow integrato per la creazione di commit Git che analizza le modifiche, genera un messaggio descrittivo e gestisce lo staging dei file.
# Prompt:
"Committa le modifiche correnti"
# Claude Code:
# 1. Analizza lo stato del repository
Bash: git status
Bash: git diff
Bash: git log --oneline -5
# 2. Identifica i file rilevanti da committare
# 3. Aggiunge i file specifici (mai git add -A)
Bash: git add src/app/services/user.service.ts
Bash: git add src/app/services/user.service.spec.ts
# 4. Crea il commit con messaggio descrittivo
Bash: git commit -m "feat: add UserService with
Repository pattern and full CRUD operations"
# 5. Verifica il risultato
Bash: git status4. Refactoring Guidato
# Prompt:
"Il file src/app/components/mega-form.component.ts
ha 1200 righe. Scomponilo in componenti più piccoli
seguendo il Single Responsibility Principle."
# Claude Code:
# 1. Analizza il file monolitico
Read: src/app/components/mega-form.component.ts
# 2. Identifica le responsabilità distinte
# 3. Crea componenti separati:
Write: src/app/components/form-header/form-header.component.ts
Write: src/app/components/form-fields/form-fields.component.ts
Write: src/app/components/form-validation/form-validation.component.ts
Write: src/app/components/form-submit/form-submit.component.ts
# 4. Aggiorna il componente originale come orchestratore
Edit: src/app/components/mega-form.component.ts
# 5. Aggiorna i test
# 6. Verifica la build e i test
Bash: npm run build && npm run testClaude Code vs Cursor vs GitHub Copilot
La scelta dello strumento giusto dipende dal contesto, dal tipo di task e dalle preferenze personali. Claude Code, Cursor e GitHub Copilot non sono alternative mutuamente esclusive: sono complementari.
| Aspetto | Claude Code | Cursor | GitHub Copilot |
|---|---|---|---|
| Interfaccia | CLI / Terminale | IDE (VS Code fork) | Plugin IDE |
| Modalità | Agentico (autonomo) | Agentico + inline | Assistente + agentico |
| Autonomia | Alta (cicli autonomi) | Media-Alta | Media |
| Contesto | Intero filesystem | Progetto aperto | File aperti + indice |
| Tool execution | Shell completa | Terminale integrato | Limitato |
| MCP Support | Nativo | Supportato | Tramite estensioni |
| Personalizzazione | CLAUDE.md + rules + hooks | .cursorrules | Copilot instructions |
| Ideale per | Task complessi, automazione, CI/CD | Sviluppo quotidiano | Completamento, snippet |
| Costo | Pay-per-use (API) o Max plan | $20/mese Pro | $10-19/mese |
Quando Usare Quale Strumento
- Claude Code - Task end-to-end complessi (implementa una feature completa, fai un refactoring su 20 file, configura CI/CD), operazioni da terminale, automazione workflow, lavoro su server remoti via SSH.
- Cursor - Sviluppo quotidiano, editing interattivo, quando vuoi vedere le modifiche in tempo reale nell'editor, pair programming con AI, prototipazione rapida.
- GitHub Copilot - Autocompletamento veloce durante la scrittura, generazione rapida di snippet, quando sei già nel flow di coding e vuoi suggerimenti inline.
La combinazione più produttiva per molti sviluppatori e: Cursor per lo sviluppo interattivo quotidiano, Copilot per il completamento inline rapido e Claude Code per task complessi, automazione e operazioni da terminale. Sono strumenti che lavorano su livelli diversi e si completano a vicenda.
Best Practices per un Uso Efficace
Dopo mesi di utilizzo intensivo di Claude Code su progetti reali, ecco le pratiche che fanno la differenza tra un'esperienza frustrante e una altamente produttiva.
1. Scrivi un CLAUDE.md Dettagliato
Il CLAUDE.md e l'investimento con il ROI più alto. Un file ben scritto riduce gli errori dell'agente dell'ordine del 50-70%. Includi sempre: overview del progetto, stack tecnologico, convenzioni di coding, comandi di build/test, pattern architetturali e una sezione esplicita "Do NOT" con i vincoli.
2. Usa Prompt Specifici e Contestuali
# VAGO (risultato imprevedibile):
"Migliora il componente form"
# SPECIFICO (risultato prevedibile):
"Nel componente src/app/components/contact-form/:
1. Aggiungi validazione email con regex
2. Aggiungi campo telefono opzionale
3. Mostra errori inline sotto ogni campo
4. Usa il pattern reactive forms di Angular
5. Mantieni lo stile CSS esistente"3. Lavora in Sessioni Focalizzate
Evita sessioni troppo lunghe che portano alla compaction del contesto. Preferisci sessioni da 15-30 minuti focalizzate su un singolo obiettivo. Quando il task e complesso, suddividilo in sotto-task e affrontali in sessioni separate.
4. Verifica Sempre il Build
Dopo ogni ciclo di modifiche significative, chiedi a Claude Code di eseguire il build e i test. Non dare per scontato che le modifiche siano corrette: il modello può commettere errori sottili che emergono solo a compile-time o runtime.
5. Usa il Sistema di Rules per Progetti Complessi
Per progetti con molte convenzioni, usa la directory .claude/rules/ con file
separati per dominio: coding-style.md, security.md,
testing.md, git-workflow.md. Questo e più manutenibile di un
singolo CLAUDE.md monolitico.
6. Configura Hooks per Automazione
Gli hooks PostToolUse per auto-formatting (Prettier, ESLint) eliminano una categoria intera di errori di stile. Gli hooks PreToolUse per validazione prevengono operazioni pericolose. Investire 10 minuti nella configurazione degli hooks risparmia ore di correzioni manuali.
Limitazioni e Workaround
Claude Code non e perfetto. Comprendere le limitazioni e fondamentale per gestire le aspettative e adottare strategie di mitigazione.
Limitazione 1: Context Window
Il contesto ha un limite fisso. Per progetti molto grandi, il modello non può "vedere" l'intero codebase simultaneamente. La compaction automatica aiuta ma può perdere dettagli importanti.
Workaround: Suddividi i task in sotto-task focalizzati. Usa il CLAUDE.md per fornire contesto architetturale che non richiede la lettura dei file. Usa subagenti (Task tool) per delegare analisi parallele.
Limitazione 2: Allucinazioni
Il modello può generare codice che sembra corretto ma contiene errori logici sottili, riferimenti a API inesistenti o pattern non supportati dalla versione specifica di un framework.
Workaround: Verifica sempre con build e test. Specifica nel CLAUDE.md le versioni esatte dei framework. Quando lavori con API esterne, fornisci la documentazione tramite WebFetch o allega esempi funzionanti.
Limitazione 3: Operazioni Interattive
Claude Code non può gestire comandi interattivi che richiedono input da tastiera
(come git rebase -i o prompt di conferma). I comandi devono essere
non-interattivi.
Workaround: Usa flag non-interattivi dove disponibili
(-y, --yes). Per git, usa comandi specifici invece di
quelli interattivi.
Limitazione 4: File Binari e Immagini
Claude Code può leggere immagini (e multimodale) ma non può generare o modificare file binari come immagini, video o PDF.
Workaround: Per operazioni su immagini, usa comandi CLI come ImageMagick o ffmpeg attraverso il tool Bash.
Limitazione 5: Costo
L'utilizzo basato su API può diventare costoso per sessioni lunghe e intensive. Ogni ciclo agentico consuma token sia per il ragionamento sia per i risultati dei tool.
Workaround: Usa il piano Max per un costo fisso mensile se l'utilizzo e frequente. Ottimizza i prompt per essere specifici (meno iterazioni). Usa subagenti per parallelizzare dove possibile (più veloce = meno token totali).
Errore Comune: Fidarsi Ciecamente dell'Output
L'errore più frequente con Claude Code e accettare tutto l'output senza verifica. Il modello può: creare file in directory sbagliate, usare import errati, introdurre regressioni in file non direttamente legati alla modifica, o generare codice che compila ma ha bug logici. Verifica sempre con build e test. Il vibe coding puro e per prototipi; per codice di produzione serve review umana.
Conclusioni
Claude Code rappresenta un salto qualitativo nel modo in cui gli sviluppatori interagiscono con l'AI. Non e semplicemente un chatbot che suggerisce codice: e un agente autonomo che opera nel tuo ambiente di sviluppo, comprende il contesto del progetto e può gestire task complessi end-to-end.
La potenza dello strumento emerge dalla combinazione di: accesso diretto al filesystem e alla shell, un sistema di permessi granulare, hooks per automazione personalizzata, subagenti per task paralleli e l'integrazione MCP per estendere le capacità oltre il codebase locale. Tutto questo controllato da un file CLAUDE.md che funziona come briefing per un collaboratore esperto.
Ma la potenza comporta responsabilità. Claude Code funziona meglio quando lo sviluppatore mantiene un ruolo attivo di supervisore e orchestratore: definisce obiettivi chiari, configura guardrail appropriati, verifica i risultati e interviene quando necessario. Non e uno strumento "imposta e dimentica": e un moltiplicatore di produttività per chi sa guidarlo.
Prossimi Articoli della Serie
- 03 - Workflow Agentici: Come decomporre problemi complessi per agenti AI, orchestrazione multi-step e pattern di delegazione efficaci
- 04 - Sistemi Multi-Agente: Architetture di collaborazione tra agenti, protocolli di comunicazione e casi d'uso enterprise
- 05 - Testare Codice Generato da AI: Strategie TDD, property-based testing e validazione della qualità del codice AI-generated
Punti Chiave da Ricordare
- Claude Code e una CLI agentica che opera nel terminale con accesso al filesystem, shell e tool di sviluppo
- Il CLAUDE.md e l'investimento più importante: guida il comportamento dell'agente e riduce gli errori del 50-70%
- Il sistema di permessi (allow/ask/deny) implementa il principio del least privilege per proteggere il codebase
- Gli hooks PreToolUse/PostToolUse automatizzano validazione e formatting
- I subagenti (Task tool) permettono esecuzione parallela e analisi multi-prospettiva
- MCP estende le capacità dell'agente a browser, database e servizi esterni
- Claude Code, Cursor e Copilot sono complementari, non alternativi
- Verifica sempre con build e test: il vibe coding puro e per prototipi, la produzione richiede supervisione umana
- Sessioni brevi e focalizzate (15-30 min) producono risultati migliori di sessioni lunghe e generiche