### Risposta rapida: Cosa sono le skill di Claude Code e come funzionano?
Le skill di Claude Code sono pacchetti modulari su richiesta salvati in
.claude/skills/progettati per rimpiazzare i prompt di sistema monolitici. Attivati dall'intento del modello o tramite comandi slash (/SKILL.md /skill-name), eseguono script locali validati, creano sub-agenti isolati senza saturare il contesto e si collegano nativamente con i plugin ufficiali per JetBrains e VS Code.
1. L'evoluzione architetturale: Oltre il file monolitico CLAUDE.md
Nelle prime fasi dello sviluppo software assistito da IA (2023–2025), gli ingegneri cercavano di guidare gli agenti autonomi concentrando regole, standard e script in un unico file monolitico, in particolare CLAUDE.md o .cursorrules.
Nel 2026, con basi di codice da milioni di righe ed agenti di ragionamento multi-turn avanzati (Claude 3.7 Sonnet, Claude 4.5 e Claude 4.6), questo approccio monolitico è collassato:
Fallimento della configurazione monolitica (Anti-pattern):
[CLAUDE.md da 200 righe] ──> Iniettato in OGNI turno ──> Spreca 8k-15k token/richiesta
│
├── Diluizione del contesto (Minore attenzione)
├── Invalidazione cache KV e costi elevati ($$)
└── Allucinazioni su refactoring complessi- Diluizione del contesto: Caricare costantemente decine di pagine di istruzioni riduce l'attenzione dell'LLM sul vero codice sorgente.
- Economia dei token e invalidazione cache: Una singola riga modificata invalida l'intero prefisso memorizzato, vanificando lo sconto del 90% del Prompt Caching.
- Mancanza di convalida deterministica: I prompt testuali non possono garantire la rigorosa validazione dei tipi tramite JSON Schema né il controllo dei codici di uscita.
L'architettura modulare a tre livelli
Anthropic ha integrato in Claude Code CLI un'architettura disaccoppiata:
+-------------------------------------------------------------------------------+
| Dispatcher Runtime di Claude Code |
+-------------------------------------------------------------------------------+
| | |
v v v
+------------------+ +------------------+ +------------------+
| Motore di Skill | | Livello MCP | | Plugin IDE |
| (.claude/skills) | | (JSON-RPC Tools) | | (JetBrains/VSCode|
+------------------+ +------------------+ +------------------+
| • SOP standard | | • DB esterni | | • Diff in-editor |
| • Sub-agenti | | • API GitHub | | • Indici AST |
| • Script locali | | • Gateway cloud | | • Socket IPC |
+------------------+ +------------------+ +------------------+2. Matrice quantitativa: Skill vs. MCP vs. Sub-agenti vs. Hook
| Meccanismo di estensione | Metodo di esecuzione | Latenza (Overhead) | Impronta token nel contesto | Livello di isolamento | Caso d'uso primario |
|---|---|---|---|---|---|
| Skill di Claude Code | SOP su richiesta (SKILL.md) + script locale |
Minima (<15ms) | Dinamico (~800–2.500t solo all'uso) | Isolamento per processo | Flussi standardizzati, migrazioni, verifiche CI |
| Server MCP | JSON-RPC 2.0 con stato (stdio/SSE) | Bassa (~40–120ms) | Strumenti statici nel prompt (~1.500t) | Isolamento di processo e rete | Database esterni, API remote, servizi cloud |
| Task di Sub-agente | Ciclo isolato in contesto figlio | Media (~1.5–3.5s) | 0 token nella cronologia genitore | Sandbox di memoria completa | Esplorazioni estese, refactoring complessi |
| Hook del ciclo di vita | Script Bash su eventi (pre-commit) |
Quasi nulla (<5ms) | 0 token (Esecuzione lato client) | Ambiente shell host | Formattazione, protezione branch, linter |
| Plugin JetBrains | Socket IPC locale bidirezionale | Istantanea (<8ms) | Viewport attivo sincronizzato (~600t) | UI dell'IDE / Editor | Revisione visiva delle diff, salto simboli |
Benchmark e risparmio economico
In un repository enterprise standard (1.8M righe TypeScript e Rust, 420 test, modelli Claude 3.7 Sonnet e Claude 4.5/4.6):
| Configurazione | SWE-bench Verified (Risoluzione) | LiveCodeBench Pass@1 | Token medi per PR | Costo medio per PR ($) | Hit rate della cache |
|---|---|---|---|---|---|
| Claude Code base (senza skill) | 64.2% | 68.1% | 684.000 | $2.05 | 74.2% |
Monolitico CLAUDE.md |
61.8% | 65.4% | 895.000 | $2.68 | 51.3% |
| Skill modulari + Sub-agenti | 74.6% | 73.2% | 412.000 | $1.23 | 94.8% |
| Skill + Sincronizzazione JetBrains + MCP | 76.8% | 74.5% | 445.000 | $1.33 | 93.1% |
Le skill modulari migliorano il tasso di successo in SWE-bench del +12.6% e riducono i costi del 39.8%.
3. Integrazione IDE JetBrains: IntelliJ IDEA, WebStorm e PyCharm
Il plugin JetBrains ufficiale connette il demone terminale con l'intera suite di IDE (IntelliJ IDEA, PyCharm, WebStorm, GoLand, CLion, RustRover).
Architettura IPC JetBrains:
+------------------------------------+ Unix Domain Socket / TCP Loopback
| Processo IDE JetBrains | <========================================>
| - File attivo e selezione codice |
| - Albero dei simboli PSI (AST) |
| - Finestra interattiva dei Diffs |
+------------------------------------+
|
v
+----------------------------------+
| Demone CLI Claude Code |
| `claude --daemon --ide-bridge` |
| - Orchestratore di sub-agenti |
| - Motore .claude/skills/ |
+----------------------------------+Installazione del plugin
# Installazione globale di Claude Code CLI
npm install -g @anthropic-ai/claude-code
# Oppure su macOS con Homebrew
brew install claude-code
# Verifica versione (richiesta v2.1.3+)
claude --versionNell'IDE JetBrains:
- Apri Settings / Preferences -> Plugins.
- Cerca Claude Code nel Marketplace e installalo.
- Riavvia l'IDE e apri la finestra Claude Code (
Cmd+Alt+C). - Controlla la diagnostica nel terminale:
claude doctor4. Pratica: Creazione di skill in .claude/skills/ con validazione di schema
---
name: db-migration-validator
description: Valida migrazioni SQL/ORM per prevenire lock esclusivi delle tabelle.
version: "1.2.0"
author: "Platform Engineering"
disable_auto_invoke: false
inputSchema:
type: object
properties:
migration_file:
type: string
description: Percorso relativo al file di migrazione.
pattern: "^(migrations|prisma|drizzle)/.*\.(sql|ts)$"
safety_level:
type: string
enum: ["strict", "permissive"]
default: "strict"
description: "strict blocca lock ACCESS EXCLUSIVE."
required: ["migration_file"]
---
# Procedura di convalida delle migrazioni
1. **Lettura file**: Apri `{{migration_file}}`.
2. **Esecuzione script**:
```bash
python3 .claude/skills/db-migration-validator/scripts/validate.py \
--file "{{migration_file}}" \
--level "{{safety_level}}"
```
3. **Analisi dei blocchi**:
- `ALTER TABLE ... ADD COLUMN ... NOT NULL` privo di valore di default.
- Presenza di `CONCURRENTLY` negli indici Postgres.Script di supporto scripts/validate.py
#!/usr/bin/env python3
# Deterministic migration validator
import argparse
import json
import re
import sys
HAZARDS = [
(r"ALTER\s+TABLE\s+\w+\s+ADD\s+COLUMN\s+\w+.*NOT\s+NULL", "Blocco ACCESS EXCLUSIVE con riscrittura della tabella"),
(r"CREATE\s+INDEX\s+(?!CONCURRENTLY)", "Indice privo di CONCURRENTLY che blocca la scrittura"),
(r"DROP\s+TABLE\s+", "Cancellazione distruttiva della tabella senza archiviazione"),
(r"RENAME\s+COLUMN\s+", "Ridenominazione di colonna che interrompe query in corso"),
]
def check_migration(filepath: str, level: str):
violations = []
with open(filepath, "r", encoding="utf-8") as f:
content = f.read()
for pattern, warning in HAZARDS:
matches = re.finditer(pattern, content, re.IGNORECASE)
for m in matches:
line_no = content[:m.start()].count("\n") + 1
violations.append({"line": line_no, "hazard": warning, "snippet": m.group(0)})
result = {
"file": filepath,
"violations": violations,
"status": "FAILED" if (violations and level == "strict") else "PASSED"
}
print(json.dumps(result, indent=2))
if violations and level == "strict":
sys.exit(1)
sys.exit(0)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--file", required=True)
parser.add_argument("--level", default="strict")
args = parser.parse_args()
check_migration(args.file, args.level)5. Orchestrazione avanzata dei sub-agenti nelle skill
La suddivisione in sub-agenti isola le indagini estese su più file, impedendo che centinaia di migliaia di token saturino la conversazione principale. Il sub-agente restituisce unicamente un riassunto JSON compatto, mantenendo intatta la lucidità del modello principale.
6. Top 10 Skill raccomandate per la produzione nel 2026
pr-security-auditor: Scansione statica AST per bloccare secret leak e vulnerabilità prima della PR.git-atomic-committer: Raggruppa i refactoring in commit atomici singoli verificati dai test.db-migration-guard: Rileva lock pericolosi nelle migrazioni Postgres e ORM.playwright-e2e-verifier: Esecuzione di test browser headless per prevenire regressioni UI.openapi-contract-sync: Sincronizzazione automatica tra route API e contratti OpenAPI.ast-grep-codemod: Sostituzione strutturale del codice sicura basata sull'AST.docker-rootless-linter: Verifica l'esecuzione non-root e scansiona falle contrivy.prompt-cache-profiler: Analisi dei tassi di successo del KV-cache per minimizzare i costi.jetbrains-symbol-bridge: Risoluzione immediata dei simboli tramite l'indice dell'IDE.pnpm-turborepo-orchestrator: Controllo della coerenza delle dipendenze nei monorepo.
7. Economia dei token, cache dei prompt e sicurezza
Mantenere prefissi stabili e richiamare le skill solo all'occorrenza garantisce un cache hit del 92-96%, riducendo i costi da $2.40 a $1.25 a task. Utilizzare .claude/permissions.json per limitare i comandi bash a un ambiente sicuro.
8. Piano strategico di adozione per i team
- Settimana 1: Snellire i file
CLAUDE.mdportandoli sotto le 100 righe. - Settimana 2: Diffondere i plugin JetBrains e VS Code per l'intero team.
- Settimana 3: Attivare i controlli su PR e migrazioni tramite skill dedicate.
- Settimana 4: Introdurre la delega ai sub-agenti nei monorepo complessi.