Agent Skills: Creare capacità Modulari per Claude
Le Agent Skills rappresentano uno dei meccanismi più potenti per estendere le capacità di Claude Code. Si tratta di moduli di competenza che aggiungono conoscenze specializzate e workflow predefiniti all'agente, permettendogli di eseguire task complessi che vanno ben oltre la semplice generazione di codice.
In questo tredicesimo articolo della serie, esploreremo l'architettura delle skill, le dieci categorie principali con esempi reali dalla community, e impareremo a creare skill personalizzate per i nostri workflow specifici. Le skill trasformano Claude Code da un assistente generico a un team di esperti specializzati a disposizione nel terminale.
Cosa Imparerai
- Comprendere l'architettura e la struttura delle Agent Skills
- Esplorare le 10 categorie principali di skill disponibili
- Installare e configurare skill dalla community
- Creare skill personalizzate step by step
- Integrare le skill nel workflow di sviluppo quotidiano
- Applicare best practice per il design di skill efficaci
- Gestire dipendenze e conflitti tra skill multiple
- Costruire librerie di skill riutilizzabili per il team
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 | Comandi e configurazione |
| 13 | Agent Skills (sei qui) | 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. Architettura delle Agent Skills
Una Agent Skill è un file Markdown posizionato nella directory
.claude/skills/ del progetto. Ogni file descrive una competenza specifica
che Claude può invocare quando il contesto della conversazione lo richiede.
A differenza dei subagenti (che vedremo nel prossimo articolo), le skill non sono
entità autonome ma estensioni di conoscenza che arricchiscono le capacità
dell'agente principale.
Struttura della Directory
.claude/
skills/
document-generator.md # Skill per generazione documenti
api-tester.md # Skill per testing API
database-migration.md # Skill per migrazioni DB
code-review-checklist.md # Skill per code review
performance-analyzer.md # Skill per analisi performance
security-audit.md # Skill per audit di sicurezza
csv-data-analyzer.md # Skill per analisi dati CSV
deployment-validator.md # Skill per validazione deploy
agents/ # Subagenti (articolo 14)
commands/ # Custom slash commands
settings.json # Configurazione progetto
settings.local.json # Configurazione localeAnatomia di una Skill
Ogni file skill segue una struttura predefinita che Claude interpreta automaticamente. La struttura include il nome della skill, la descrizione delle sue capacità, le istruzioni operative e i vincoli di utilizzo.
# Nome della Skill
## Descrizione
Breve descrizione di cosa fa questa skill e quando viene attivata.
## capacità
- capacità 1: cosa sa fare
- capacità 2: cosa sa fare
- capacità N: cosa sa fare
## Istruzioni
Istruzioni dettagliate su come eseguire il task:
1. Passo 1
2. Passo 2
3. Passo N
## Vincoli
- Non fare X
- Preferire Y rispetto a Z
- Formato output atteso
## Esempi
### Esempio 1: [Titolo]
Input: ...
Output: ...
### Esempio 2: [Titolo]
Input: ...
Output: ...Come Claude Seleziona le Skill
Claude analizza il prompt dell'utente e il contesto della conversazione per
determinare quali skill sono rilevanti. La selezione avviene in modo automatico
basandosi sulla corrispondenza semantica tra la richiesta e le descrizioni
delle skill disponibili. Non è necessario invocare esplicitamente una skill:
basta formulare una richiesta che rientri nel suo dominio di competenza.
Per invocare una skill specifica, è possibile usare il comando
/skill nome-skill.
Ciclo di Vita di una Skill
Fasi del Ciclo di Vita
| Fase | Descrizione | Azione Claude |
|---|---|---|
| Discovery | Claude scansiona .claude/skills/ all'avvio |
Carica i metadati di tutte le skill disponibili |
| Matching | Analisi semantica del prompt utente | Identifica le skill rilevanti per la richiesta |
| Loading | Caricamento completo della skill selezionata | Legge le istruzioni, i vincoli e gli esempi |
| Execution | Applicazione delle istruzioni della skill | Esegue il task seguendo le linee guida |
| Validation | Verifica del risultato contro i vincoli | Controlla che l'output rispetti i criteri definiti |
2. Le 10 Categorie di Skill
La community ha sviluppato centinaia di skill organizzate in dieci categorie principali. Ogni categoria copre un dominio specifico e offre competenze pronte all'uso che possono essere adottate immediatamente nei propri progetti.
Categoria 1: Document Skills
Le Document Skills permettono a Claude di creare, modificare e convertire documenti in formati professionali. Queste skill trasformano Claude in un generatore di contenuti strutturati che produce output pronti per la distribuzione.
Skill Principali per Documenti
| Skill | Formato | capacità |
|---|---|---|
| docx-generator | Microsoft Word (.docx) | Genera documenti Word con stili, tabelle, immagini e indice automatico |
| pdf-creator | Crea PDF professionali con layout personalizzato, header/footer e watermark | |
| pptx-builder | PowerPoint (.pptx) | Genera presentazioni con slide master, grafici e animazioni |
| xlsx-analyzer | Excel (.xlsx) | Crea fogli di calcolo con formule, pivot table e grafici |
| revealjs-presenter | HTML (Reveal.js) | Genera presentazioni web interattive con transizioni e codice live |
# Document Generator (DOCX)
## Descrizione
Genera documenti Microsoft Word professionali a partire da contenuti
strutturati. Supporta stili personalizzati, tabelle, immagini inline,
intestazioni/pie' di pagina e indice automatico.
## capacità
- Creare documenti .docx da zero con template professionale
- Applicare stili di formattazione coerenti
- Inserire tabelle con dati strutturati
- Generare indice automatico dai titoli
- Inserire header e footer con numerazione pagine
- Supportare contenuto multilingue
## Istruzioni
1. Analizzare la struttura del contenuto richiesto
2. Creare lo script Node.js usando la libreria `docx`
3. Definire gli stili del documento (heading, body, table)
4. Costruire la struttura del documento sezione per sezione
5. Eseguire lo script per generare il file .docx
6. Verificare che il file sia stato creato correttamente
## Dipendenze
- npm: docx (per generazione .docx)
- npm: @types/docx (per TypeScript)
## Vincoli
- Usare sempre stili coerenti nel documento
- Includere numerazione pagine nel footer
- Formato data: DD/MM/YYYY per documenti italiani
- Dimensione massima consigliata: 50 pagineCategoria 2: Development & Code Tools
Le skill di sviluppo estendono le capacità di coding di Claude con pattern avanzati, framework specifici e metodologie di lavoro strutturate. Queste skill sono particolarmente utili per mantenere coerenza e qualità nel codice prodotto.
Skill Principali per lo Sviluppo
| Skill | Tecnologia | capacità |
|---|---|---|
| web-artifacts-builder | HTML/CSS/JS | Genera componenti web self-contained con HTML, CSS e JavaScript inline |
| tdd-workflow | Multi-linguaggio | Guida lo sviluppo Test-Driven: scrivi test prima, poi implementazione |
| git-worktrees | Git | Gestisce worktree Git per sviluppo parallelo su più branch |
| aws-cdk-builder | AWS CDK | Genera stack CDK con best practice per infrastruttura cloud |
| api-design-first | OpenAPI | Progetta API partendo dalla specifica OpenAPI, genera server e client |
| angular-component-gen | Angular | Genera componenti Angular standalone con signal, test e storybook |
# TDD Workflow
## Descrizione
Guida lo sviluppo seguendo rigorosamente il ciclo Red-Green-Refactor
del Test-Driven Development. Ogni feature viene implementata partendo
dai test che descrivono il comportamento atteso.
## capacità
- Scrivere test che definiscono il comportamento desiderato (Red)
- Implementare il minimo codice per far passare i test (Green)
- Refactoring del codice mantenendo tutti i test verdi (Refactor)
- Gestire test unitari, di integrazione e e2e
- Applicare test doubles (mock, stub, spy) dove necessario
## Istruzioni
### Fase Red
1. Analizzare il requisito e scomporlo in comportamenti testabili
2. Scrivere un test che descrive il comportamento atteso
3. Eseguire il test e verificare che FALLISCA
4. Se il test passa gia: il test non testa nulla di nuovo
### Fase Green
5. Scrivere il MINIMO codice necessario per far passare il test
6. Non ottimizzare, non aggiungere feature extra
7. Eseguire tutti i test e verificare che PASSINO tutti
### Fase Refactor
8. Rifattorizzare il codice eliminando duplicazione
9. Migliorare naming e struttura
10. Eseguire tutti i test dopo ogni modifica
11. I test devono rimanere VERDI dopo il refactoring
## Vincoli
- MAI scrivere codice di produzione senza un test che lo richiede
- Un test alla volta, una feature alla volta
- I test devono essere indipendenti tra loro
- Naming dei test: should_[comportamento]_when_[condizione]Categoria 3: Data & Analysis
Le skill di analisi dati trasformano Claude in un data analyst capace di esplorare dataset, generare query complesse, produrre visualizzazioni e identificare anomalie nei dati.
Skill Principali per Dati e Analisi
| Skill | Dominio | capacità |
|---|---|---|
| root-cause-tracing | Debugging | Analisi sistematica delle cause radice di bug complessi con diagramma causale |
| csv-data-summarizer | Dataset CSV | Analisi esplorativa, statistiche descrittive, correlazioni e anomalie |
| postgresql-query-builder | PostgreSQL | Genera query ottimizzate con indici, CTE, window function e explain plan |
| log-analyzer | Log applicativi | Parsing e analisi di log con pattern recognition e timeline degli eventi |
| metrics-dashboard | Monitoring | Genera configurazioni Grafana/Prometheus da requisiti business |
# CSV Data Summarizer
## Descrizione
Analizza file CSV per produrre report statistici completi con
visualizzazioni, correlazioni e identificazione di anomalie.
## capacità
- Caricare e parsare file CSV di qualsiasi dimensione
- Calcolare statistiche descrittive (media, mediana, moda, deviazione standard)
- Identificare valori mancanti, duplicati e outlier
- Generare correlazioni tra variabili numeriche
- Produrre visualizzazioni con grafici ASCII o script Python/matplotlib
- Creare report strutturati in formato Markdown
## Istruzioni
1. Leggere il file CSV e identificare le colonne
2. Classificare le colonne: numeriche, categoriche, date, testo
3. Per ogni colonna numerica:
- Calcolare min, max, media, mediana, std dev
- Identificare outlier (IQR method)
- Verificare distribuzione
4. Per ogni colonna categorica:
- Contare valori unici e frequenze
- Identificare valori dominanti
5. Calcolare matrice di correlazione per colonne numeriche
6. Identificare pattern temporali (se presenti date)
7. Generare report con tutte le scoperte
## Formato Output
```markdown
# Report Analisi: [nome_file]
## Panoramica Dataset
- Righe: N, Colonne: M
- Valori mancanti: X%
## Statistiche per Colonna
[tabella per ogni colonna]
## Correlazioni Significative
[matrice e insights]
## Anomalie Rilevate
[lista anomalie con spiegazione]
```Categoria 4: Scientific & Research
Le skill scientifiche portano competenze di dominio avanzate come bioinformatica, simulazione di materiali e analisi di dati di ricerca. Sono progettate per ricercatori e team tecnici che lavorano con dati scientifici.
Skill per Ambito Scientifico
| Skill | Dominio | capacità |
|---|---|---|
| bioinformatics-pipeline | Bioinformatica | Analisi sequenze DNA/RNA, allineamento, annotazione genica |
| ml-experiment-tracker | Machine Learning | Tracking esperimenti ML con metriche, iperparametri e confronti |
| materials-simulation | Scienza dei materiali | Simulazione proprietà di materiali con modelli computazionali |
| statistical-analysis | Statistica | Test statistici, regressione, analisi di varianza e intervalli di confidenza |
Categoria 5: Writing & Research
Le skill di scrittura e ricerca assistono nella creazione di contenuti tecnici di alta qualità, dall'estrazione di informazioni da fonti web alla stesura di articoli completi con citazioni e riferimenti.
Skill per Scrittura e Ricerca
| Skill | Funzione | capacità |
|---|---|---|
| article-extractor | Estrazione contenuti | Estrae e struttura contenuti da URL web, PDF e documenti |
| content-research-writer | Ricerca e scrittura | Ricerca approfondita su un argomento e produzione di contenuti originali |
| technical-blog-writer | Blog tecnico | Stesura di articoli tecnici con codice, diagrammi e spiegazioni chiare |
| changelog-generator | Release notes | Genera changelog da commit Git con categorizzazione automatica |
# Changelog Generator
## Descrizione
Genera changelog professionali a partire dalla storia dei commit Git.
Categorizza automaticamente le modifiche seguendo Conventional Commits.
## capacità
- Analizzare commit tra due tag/versioni
- Categorizzare: feat, fix, docs, refactor, perf, test, chore
- Generare formato Keep a Changelog
- Linkare commit e issue/PR correlati
- Rilevare breaking changes
- Supportare versionamento semantico (SemVer)
## Istruzioni
1. Identificare l'intervallo di commit (ultimo tag -> HEAD)
2. Parsare ogni messaggio di commit per tipo e scope
3. Raggruppare per categoria
4. Ordinare per importanza (breaking > feat > fix > others)
5. Generare il documento CHANGELOG.md
6. Suggerire la nuova versione SemVer
## Formato Output
```markdown
# Changelog
## [1.2.0] - 2026-02-14
### Breaking Changes
- **auth:** Rimossa compatibilità con token v1
### Features
- **user:** Aggiunto form di modifica profilo (#123)
- **notif:** Sistema notifiche push (#145)
### Bug Fixes
- **cart:** Corretto calcolo totale con sconti (#167)
### Performance
- **api:** Cache su endpoint /products (-40% latenza)
```Categoria 6: Learning & Knowledge
Le skill di apprendimento trasformano Claude in un sistema di gestione della conoscenza che può organizzare, collegare e presentare informazioni in modo strutturato e incrementale.
Skill per Apprendimento e Conoscenza
| Skill | Funzione | capacità |
|---|---|---|
| tapestry | Knowledge Graph | Crea reti di documenti interconnessi con link bidirezionali e navigazione |
| ship-learn-next | Apprendimento iterativo | Ciclo Ship-Learn-Improve: rilascia, analizza feedback, migliora |
| concept-mapper | Mappe concettuali | Genera mappe concettuali da testi e documentazione tecnica |
| learning-path-builder | Percorsi formativi | Crea percorsi di apprendimento personalizzati con risorse e milestone |
Categoria 7: Media & Content
Le skill multimediali permettono a Claude di lavorare con contenuti video, audio e formati di pubblicazione digitale, estendendo le sue capacità oltre il solo testo.
Skill per Media e Contenuti
| Skill | Formato | capacità |
|---|---|---|
| youtube-transcript | YouTube | Estrae trascrizioni da video YouTube, genera riassunti e note strutturate |
| video-downloader | Video | Download di video da piattaforme supportate con selezione qualità |
| epub-converter | EPUB | Converte contenuti Markdown o HTML in formato EPUB per e-reader |
| podcast-notes | Audio | Genera note strutturate da trascrizioni di podcast con timestamp |
| diagram-generator | Mermaid/PlantUML | Genera diagrammi tecnici da descrizioni in linguaggio naturale |
# Diagram Generator
## Descrizione
Genera diagrammi tecnici in formato Mermaid o PlantUML
a partire da descrizioni in linguaggio naturale o analisi del codice.
## capacità
- Diagrammi di sequenza da flussi di codice
- Diagrammi di classe da modelli di dominio
- Diagrammi ER da schema database
- Diagrammi di stato da macchine a stati
- Diagrammi di flusso da logica di business
- Diagrammi di architettura C4
## Istruzioni
1. Analizzare la richiesta o il codice sorgente
2. Identificare il tipo di diagramma più appropriato
3. Estrarre entità, relazioni e flussi
4. Generare il codice Mermaid/PlantUML
5. Salvare in un file .md o .puml
6. Se possibile, generare un preview ASCII
## Formato Mermaid
```mermaid
sequenceDiagram
participant U as User
participant A as API
participant DB as Database
U->>A: POST /login
A->>DB: SELECT user
DB-->>A: User data
A-->>U: JWT Token
```
## Vincoli
- Preferire Mermaid per semplicità
- Usare PlantUML per diagrammi complessi
- Includere sempre legenda se il diagramma ha più di 5 entità
- Massimo 20 entità per diagramma (dividere se necessario)Categoria 8: Health & Life Sciences
Le skill per le scienze della vita assistono professionisti sanitari e ricercatori nell'analisi di dati medici, nella lettura di report clinici e nella ricerca biomedica. Queste skill operano sempre con l'avvertenza che non sostituiscono il parere medico professionale.
Skill per Scienze della Vita
| Skill | Dominio | capacità |
|---|---|---|
| claude-ally-health | Report medici | Analizza report medici, evidenzia valori anomali e suggerisce follow-up |
| clinical-trial-analyzer | Trial clinici | Analisi di protocolli e risultati di trial clinici con sintesi strutturata |
| pharma-interaction-checker | Farmacologia | Verifica interazioni tra farmaci basandosi su database pubblici |
Disclaimer Importante
Le skill di ambito sanitario sono strumenti di supporto e non sostituiscono in alcun modo il parere di un professionista medico. Ogni analisi prodotta deve essere verificata da personale qualificato prima di qualsiasi decisione clinica. Claude Code non è un dispositivo medico certificato.
Categoria 9: Collaboration & PM
Le skill di collaborazione e project management integrano Claude con strumenti di gestione del lavoro come Linear, Jira e sistemi di analytics per riunioni. Permettono di automatizzare la gestione di task, sprint e reportistica.
Skill per Collaborazione e PM
| Skill | Strumento | capacità |
|---|---|---|
| linear-integration | Linear | Crea e gestisce issue, cicli e progetti su Linear via API |
| jira-workflow | Jira | Sincronizza task, aggiorna stati e genera report sprint su Jira |
| meeting-analytics | Meeting notes | Analizza note di riunione, estrae action item e assegna responsabilità |
| sprint-planner | Agile | Pianifica sprint basandosi su velocity, capacità e priorità del backlog |
| standup-reporter | Daily standup | Genera report di standup da commit, PR e task completati nelle ultime 24h |
# Meeting Analytics
## Descrizione
Analizza note di riunione per estrarre decisioni, action item,
rischi e metriche di partecipazione. Genera report strutturati
e traccia il follow-up delle azioni nel tempo.
## capacità
- Parsare note di riunione in formato libero
- Estrarre decisioni prese e rationale
- Identificare action item con responsabile e deadline
- Rilevare rischi e impedimenti menzionati
- Calcolare metriche di partecipazione
- Generare email di follow-up con riassunto
- Tracciare azioni aperte tra riunioni successive
## Formato Output
```markdown
# Meeting Report - [Data]
## Partecipanti
[Lista con ruolo]
## Decisioni
1. [Decisione] - Motivazione: [perchè]
2. ...
## Action Items
| # | Azione | Responsabile | Deadline | Stato |
|---|--------|-------------|----------|-------|
| 1 | ... | @nome | GG/MM | Open |
## Rischi Identificati
- [Rischio] - Impatto: [alto/medio/basso]
## Prossima Riunione
- Data: [suggerita]
- Agenda: [punti proposti]
```Categoria 10: Security & Web Testing
Le skill di sicurezza equipaggiano Claude con competenze di penetration testing, vulnerability assessment e security audit. Queste skill seguono standard riconosciuti come OWASP e producono report conformi ai requisiti di compliance.
Skill per Sicurezza e Testing
| Skill | Standard | capacità |
|---|---|---|
| owasp-checklist | OWASP Top 10 | Verifica sistematica delle OWASP Top 10 vulnerabilità su applicazioni web |
| ffuf-fuzzer | Web fuzzing | Configura ed esegue sessioni di fuzzing con FFUF per scoperta endpoint e parametri |
| secure-env-manager | Secrets management | Gestione sicura di variabili d'ambiente, rotazione segreti e vault integration |
| dependency-auditor | CVE database | Audit completo delle dipendenze con identificazione CVE e suggerimenti fix |
| api-security-tester | OWASP API Security | Test di sicurezza specifici per API REST e GraphQL |
# OWASP Security Checklist
## Descrizione
Verifica sistematica della sicurezza dell'applicazione web
contro le OWASP Top 10 vulnerabilità. Produce un report
di audit con severity, evidenze e raccomandazioni.
## Checklist OWASP Top 10
1. A01 - Broken Access Control
2. A02 - Cryptographic Failures
3. A03 - Injection (SQL, NoSQL, OS, LDAP)
4. A04 - Insecure Design
5. A05 - Security Misconfiguration
6. A06 - Vulnerable and Outdated Components
7. A07 - Identification and Authentication Failures
8. A08 - Software and Data Integrity Failures
9. A09 - Security Logging and Monitoring Failures
10. A10 - Server-Side Request Forgery (SSRF)
## Istruzioni per Ogni Voce
1. Identificare i file e gli endpoint rilevanti
2. Analizzare il codice per pattern vulnerabili
3. Classificare la severity: Critical/High/Medium/Low/Info
4. Documentare l'evidenza con riferimento al codice
5. Proporre la remediation con codice di esempio
6. Stimare l'effort di correzione
## Formato Report
| # | Vulnerabilità | Severity | File | Stato |
|---|--------------|----------|------|-------|
| A01 | Access Control | ... | ... | ... |3. Creare Skill Personalizzate Step by Step
Creare skill personalizzate è il modo migliore per adattare Claude Code alle esigenze specifiche del proprio progetto e del proprio team. Vediamo il processo completo dalla progettazione al testing.
Step 1: Identificare l'Esigenza
Prima di creare una skill, è fondamentale identificare un pattern ripetitivo nel workflow che può essere standardizzato. Le migliori skill nascono da task che vengono eseguiti frequentemente, hanno regole chiare e producono output prevedibili.
Criteri per una Buona Skill
- Ripetitivita: Il task viene eseguito più volte alla settimana
- Regole chiare: Esistono step definiti e prevedibili
- Output strutturato: Il risultato ha un formato coerente
- Dominio definito: La skill copre un ambito specifico e delimitato
- Valore aggiunto: L'automazione risparmia tempo significativo
Step 2: Progettare la Skill
# Angular Standalone Component Generator
## Descrizione
Genera componenti Angular standalone seguendo le convenzioni
del progetto. Crea il file component.ts, il template HTML,
il foglio di stile CSS e il file di test .spec.ts.
## capacità
- Generare componenti standalone con signal per state management
- Creare template con design system del progetto
- Generare stili seguendo le convenzioni CSS/SCSS del progetto
- Scrivere test unitari con TestBed e ComponentFixture
- Applicare OnPush change detection
- Integrare con il router se richiesto
## Convenzioni del Progetto
- File naming: kebab-case (user-profile.component.ts)
- Selector prefix: app- (app-user-profile)
- State management: Angular Signals (non RxJS per stato locale)
- Change detection: OnPush
- Stili: CSS scoped al componente
- Test: Jasmine + TestBed
## Template Componente
```typescript
import { Component, signal, input, output } from '@angular/core';
@Component({
standalone: true,
selector: 'app-[nome]',
templateUrl: './[nome].component.html',
styleUrls: ['./[nome].component.css'],
changeDetection: ChangeDetectionStrategy.OnPush,
imports: []
})
export class [Nome]Component {
// Input signals
// State signals
// Output events
// Methods
}
```
## Template Test
```typescript
describe('[Nome]Component', () => {
let component: [Nome]Component;
let fixture: ComponentFixture<[Nome]Component>;
beforeEach(async () => {
await TestBed.configureTestingModule({
imports: [[Nome]Component]
}).compileComponents();
fixture = TestBed.createComponent([Nome]Component);
component = fixture.componentInstance;
fixture.detectChanges();
});
it('should create', () => {
expect(component).toBeTruthy();
});
});
```
## Vincoli
- Usare SEMPRE standalone: true
- NON usare ngModule
- Preferire signal() a BehaviorSubject per stato locale
- Includere almeno 3 test nel file .spec.ts
- Documentare ogni input/output con commento JSDocStep 3: Testare la Skill
Dopo aver creato il file della skill, è essenziale testarlo con diversi prompt per verificare che Claude la invochi correttamente e produca risultati coerenti.
# Test 1: Richiesta diretta
> Crea un componente UserProfile con campo nome ed email
# Verifica:
# - Ha creato user-profile.component.ts con standalone: true?
# - Ha usato signal() per lo stato?
# - Ha generato il file .spec.ts con almeno 3 test?
# Test 2: Richiesta con routing
> Genera un componente Dashboard che sia una route lazy-loaded
# Verifica:
# - Ha configurato il routing correttamente?
# - Ha applicato OnPush change detection?
# Test 3: Richiesta complessa
> Crea un componente ProductList con paginazione, filtri e ordinamento
# Verifica:
# - Ha gestito lo stato con signal?
# - Ha separato la logica in metodi chiari?
# - I test coprono i casi edge?Step 4: Iterare e Migliorare
Le skill migliori sono quelle che evolvono nel tempo. Dopo i primi test, e comune dover aggiungere vincoli mancanti, chiarire istruzioni ambigue e aggiungere esempi per casi specifici.
Checklist di Miglioramento
- Il nome della skill descrive chiaramente la sua funzione?
- Le istruzioni sono sufficientemente dettagliate?
- I vincoli coprono tutti gli edge case incontrati?
- Gli esempi rappresentano i casi d'uso più comuni?
- Il formato di output è coerente e utile?
- La skill gestisce correttamente gli errori?
- La documentazione è chiara per i nuovi membri del team?
4. Integrazione delle Skill nel Workflow
Le skill raggiungono il loro massimo potenziale quando vengono integrate organicamente nel workflow di sviluppo quotidiano del team. Ecco i pattern di integrazione più efficaci.
Pattern 1: Skill Chain (Catena di Skill)
Combinare più skill in sequenza per task complessi. Ad esempio, per una nuova
feature si può usare: api-design-first per definire l'API, poi
tdd-workflow per i test, poi angular-component-gen
per il frontend.
# Passo 1: Progettazione API
> Progetta l'API per il modulo notifiche push
> Endpoint: GET /notifications, POST /notifications/subscribe,
> DELETE /notifications/{id}
# La skill api-design-first genera la specifica OpenAPI
# Passo 2: Test first
> Genera i test per il NotificationService seguendo TDD
> Basa i test sulla specifica API appena generata
# La skill tdd-workflow genera i test (fase Red)
# Passo 3: Implementazione
> Implementa il NotificationService per far passare i test
# La skill tdd-workflow guida l'implementazione (fase Green)
# Passo 4: Frontend
> Crea il componente NotificationPanel per visualizzare le notifiche
# La skill angular-component-gen crea il componente
# Passo 5: Documentazione
> Genera la documentazione per il modulo notifiche
# La skill changelog-generator o docx-generator documenta tuttoPattern 2: Skill Gate (Skill come Quality Gate)
Usare le skill come checkpoint di qualità prima di operazioni critiche. Ad esempio,
eseguire owasp-checklist prima di ogni merge in main, o
dependency-auditor prima di ogni rilascio.
Pattern 3: Skill Library (Libreria di Skill del Team)
Condividere le skill nel repository del progetto permette a tutti i membri
del team di beneficiarne. La directory .claude/skills/ committata
nel repository diventa una libreria di competenze condivise del team.
.claude/
skills/
# Skill di sviluppo
dev/
angular-component-gen.md
spring-service-gen.md
api-design-first.md
tdd-workflow.md
# Skill di qualità
quality/
code-review-checklist.md
owasp-checklist.md
dependency-auditor.md
performance-analyzer.md
# Skill di documentazione
docs/
docx-generator.md
changelog-generator.md
adr-writer.md
# Skill di analisi
analysis/
csv-data-summarizer.md
log-analyzer.md
root-cause-tracing.md
# Skill di project management
pm/
meeting-analytics.md
sprint-planner.md
standup-reporter.md5. Best Practice per il Design di Skill
Dopo aver lavorato con decine di skill, emergono pattern chiari su cosa rende una skill efficace. Ecco le best practice consolidate dalla community.
Best Practice per le Skill
| Principio | Descrizione | Esempio |
|---|---|---|
| Single Responsibility | Ogni skill fa una cosa sola e la fa bene | Separare "generate tests" da "run tests" |
| Explicit Instructions | Istruzioni chiare e non ambigue | "Usa Jasmine per i test" non "Usa un framework di test" |
| Concrete Examples | Almeno 2-3 esempi con input e output atteso | Template di codice completi, non pseudo-codice |
| Clear Constraints | Vincoli espliciti su cosa NON fare | "NON usare ngModule, solo standalone: true" |
| Output Format | Formato di output definito e coerente | Template Markdown, struttura file, naming |
| Error Handling | Gestione dei casi limite e errori | "Se il file esiste gia, chiedi conferma prima di sovrascrivere" |
| Dependency Declaration | Dichiarare le dipendenze esterne | "Richiede: npm docx, @types/docx" |
| Versioning | Includere la versione della skill nel file | "Versione: 1.2.0 - Ultimo aggiornamento: 2026-02-14" |
Anti-Pattern da Evitare
Errori Comuni nella Creazione di Skill
- Skill troppo generiche: "Genera codice" è troppo vago - specificare il linguaggio, il framework, le convenzioni
- Istruzioni vaghe: "Scrivi buon codice" non dice nulla - definire metriche di qualità concrete
- Mancanza di esempi: Senza esempi concreti, Claude interpreta le istruzioni in modo imprevedibile
- Vincoli contraddittori: "Usa TypeScript strict" e "Non usare type annotations" si contraddicono
- Skill monolitiche: Una skill che fa tutto (genera, testa, documenta, deploya) e ingestibile
- Nessun formato output: Senza un formato definito, ogni esecuzione produce risultati diversi
- Ignorare le dipendenze: Se la skill richiede npm package, dichiararlo esplicitamente
6. Gestione Avanzata delle Skill
Composizione di Skill
Le skill possono essere composte tra loro creando workflow complessi. Il segreto è progettare ogni skill con input e output compatibili, in modo che l'output di una possa alimentare l'input della successiva.
# Full Feature Pipeline
## Descrizione
Orchestrazione completa per la creazione di una nuova feature,
dalla specifica API al deploy. Combina le skill: api-design-first,
tdd-workflow, angular-component-gen, e changelog-generator.
## Pipeline
### Fase 1: Design (api-design-first)
- Input: Requisiti della feature in linguaggio naturale
- Output: Specifica OpenAPI completa
- Gate: Approvazione della specifica da parte dell'utente
### Fase 2: Backend (tdd-workflow)
- Input: Specifica OpenAPI dalla Fase 1
- Output: Service + Controller + Test con copertura 80%+
- Gate: Tutti i test passano
### Fase 3: Frontend (angular-component-gen)
- Input: API endpoints dalla Fase 1 + modelli dati
- Output: Componenti Angular standalone con test
- Gate: Build senza errori + test passano
### Fase 4: Documentazione (changelog-generator)
- Input: Tutti i file creati/modificati nelle fasi precedenti
- Output: Entry changelog + aggiornamento README
- Gate: Review della documentazione
## Vincoli
- Ogni fase richiede approvazione prima di procedere
- Se una fase fallisce, tornare alla fase precedente
- Mantenere git commit separati per ogni faseVersionamento delle Skill
Le skill evolvono con il progetto. E' buona pratica includere un header di versione in ogni skill e mantenere un changelog delle modifiche.
# Angular Component Generator
> Versione: 2.1.0 | Ultimo aggiornamento: 2026-02-14
> Changelog:
> - 2.1.0: Aggiunto supporto per lazy-loaded routes
> - 2.0.0: Migrazione da ngModule a standalone
> - 1.3.0: Aggiunto template per form reattivi
> - 1.2.0: Aggiunto OnPush change detection
> - 1.1.0: Aggiunto supporto signal()
> - 1.0.0: Rilascio iniziale
## Descrizione
...Testing Automatico delle Skill
Per garantire che le skill continuino a funzionare correttamente nel tempo, e possibile creare script di test automatizzati che verificano l'output delle skill contro aspettative predefinite.
#!/bin/bash
# Test automatico delle skill di Claude Code
echo "=== Testing Agent Skills ==="
# Test 1: Angular Component Generator
echo "Testing: Angular Component Generator..."
OUTPUT=$(claude --print "Crea un componente TestWidget con un input 'title' di tipo string" \
--output-format json --max-iterations 5 2>&1)
if echo "$OUTPUT" | grep -q "standalone: true"; then
echo " PASS: standalone component generated"
else
echo " FAIL: standalone not found in output"
fi
if echo "$OUTPUT" | grep -q "signal\|input()"; then
echo " PASS: signal/input used"
else
echo " FAIL: signal/input not found"
fi
# Test 2: TDD Workflow
echo "Testing: TDD Workflow..."
OUTPUT=$(claude --print "Scrivi i test per una funzione calculateDiscount(price, percentage)" \
--output-format json --max-iterations 5 2>&1)
if echo "$OUTPUT" | grep -q "describe\|it("; then
echo " PASS: test structure generated"
else
echo " FAIL: test structure not found"
fi
echo "=== Test Complete ==="Conclusione
Le Agent Skills trasformano Claude Code da un assistente generico a un ecosistema di competenze specializzate che si adattano al progetto e al team. Le dieci categorie di skill - dalla generazione di documenti alla sicurezza, dall'analisi dati al project management - coprono l'intero spettro delle esigenze di sviluppo software.
Punti Chiave
- Le skill sono file Markdown in
.claude/skills/: Semplici da creare, versionare e condividere nel team - 10 categorie coprono ogni esigenza: Documenti, sviluppo, dati, ricerca, scrittura, apprendimento, media, salute, PM, sicurezza
- Design con Single Responsibility: Ogni skill fa una cosa sola e la fa bene
- Esempi concreti sono fondamentali: Claude interpreta meglio le skill con template e output attesi
- Composizione per workflow complessi: Skill chain, skill gate e full feature pipeline
- Iterazione continua: Le skill migliori evolvono con il progetto e il feedback del team
- Condivisione nel repository: Le skill committate diventano una libreria di conoscenza del team
Nel prossimo articolo esploreremo i Subagenti Specializzati: agenti autonomi con ruoli specifici che operano in modo indipendente all'interno di Claude Code. Vedremo come creare esperti di linguaggio, DevOps specialist e security auditor che lavorano in sinergia con l'agente principale.