---
type: "BlogPosting"
title: "Claude Code Plugins: La guida completa al sistema di estensioni 2025"
description: "I plugin Claude Code rivoluzionano lo sviluppo assistito da IA. Comprendi le differenze tra Skills, Plugin, Server MCP e Agents – ed estendi Claude Code con funzionalità personalizzate."
resource: "https://www.contextstudios.ai/it/blog/claude-code-plugins-la-guida-completa-al-sistema-di-estensioni-2025"
language: "it"
tags: ["Claude Code", "Plugins", "MCP", "AI Development", "Anthropic", "Developer Tools", "Automation"]
generated:
  by: "process:contextstudios-md/1"
  at: "2026-10-08T20:59:23.880Z"
status: "stable"
---

# Claude Code Plugins: La guida completa al sistema di estensioni 2025

Published: 2026-01-04
Tags: Claude Code, Plugins, MCP, AI Development, Anthropic, Developer Tools, Automation

![Claude Code Plugins: La guida completa al sistema di estensioni 2025](https://wary-platypus-754.convex.cloud/api/storage/a6e2f14d-e250-41f9-aeaf-a67a5ee19ae1)

# Claude Code Plugins: La guida completa al sistema di estensioni 2025

Claude Code si è affermato come lo strumento di sviluppo IA leader per il terminale. Ma la sua vera potenza risiede nel **sistema di estensioni modulare**, che permette agli sviluppatori di personalizzare Claude Code per i propri workflow specifici. In questa guida scoprirai tutto su Plugin, Skills, Server MCP, Agents e come lavorano insieme.

---

## Panoramica del sistema di estensioni Claude Code

Claude Code offre **cinque diversi meccanismi di estensione**, ognuno che copre diversi casi d'uso:

| Componente | Scopo | Invocazione | Ambito |
|------------|-------|-------------|--------|
| **Plugins** | Pacchetti riutilizzabili con Commands, Agents, Skills & Hooks | `/plugin-name:command` | Team/Community |
| **Skills** | Capacità contestuali per Claude | Automaticamente da Claude | Progetto/Utente |
| **Server MCP** | Integrazione strumenti esterni | Via chiamate strumenti | Universale |
| **Agents/Subagents** | Assistenti IA specializzati | Via delega task | Sessione |
| **CLAUDE.md** | Contesto progetto & regole | Caricato automaticamente | Progetto |

### Comprendere la gerarchia

```
┌─────────────────────────────────────────────────────────────┐
│                      Claude Code CLI                         │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │   Plugins   │  │   Skills    │  │    Server MCP       │  │
│  │  (Pacchetti)│  │ (Capacità)  │  │ (Strumenti esterni) │  │
│  └──────┬──────┘  └──────┬──────┘  └──────────┬──────────┘  │
│         │                │                     │             │
│         ▼                ▼                     ▼             │
│  ┌─────────────────────────────────────────────────────────┐│
│  │                    Agents/Subagents                      ││
│  │              (Assistenti specializzati)                  ││
│  └─────────────────────────────────────────────────────────┘│
│                            ▲                                 │
│                            │                                 │
│  ┌─────────────────────────────────────────────────────────┐│
│  │    CLAUDE.md / AGENTS.md (Contesto progetto & regole)   ││
│  └─────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘
```

---

## 1. Claude Code Plugins – La soluzione completa

I **Plugin** sono il formato di estensione più potente. Raggruppano più componenti in un pacchetto distribuibile:

### Cosa possono contenere i Plugin

- **Slash Commands** – Comandi personalizzati (`/plugin:command`)
- **Agents** – Subagent specializzati
- **Skills** – Capacità sensibili al contesto
- **Hooks** – Gestori eventi per automazione
- **Server MCP** – Configurazioni strumenti esterni
- **Server LSP** – Intelligenza codice per linguaggi

### Struttura di un Plugin

```
my-plugin/
├── .claude-plugin/
│   └── plugin.json          # Metadati plugin (richiesto)
├── commands/                # Slash commands
│   └── hello.md
├── agents/                  # Definizioni subagent
│   └── reviewer.md
├── skills/                  # Agent Skills
│   └── code-review/
│       └── SKILL.md
├── hooks/                   # Gestori eventi
│   └── hooks.json
├── .mcp.json                # Configurazione server MCP
├── .lsp.json                # Configurazione server LSP
└── README.md                # Documentazione
```

### Manifesto del Plugin (plugin.json)

```json
{
  "name": "my-plugin",
  "description": "Descrizione del plugin",
  "version": "1.0.0",
  "author": {
    "name": "Il Tuo Nome",
    "email": "email@example.com"
  },
  "repository": "https://github.com/user/my-plugin",
  "license": "MIT"
}
```

---

## 2. Skills – Capacità contestuali

Gli **Skills** sono invocati dal modello: Claude decide automaticamente quando uno skill è rilevante, basandosi sul contesto del task.

### Differenza dai Plugin

| Aspetto | Skills | Plugins |
|---------|--------|---------|
| Invocazione | Automatica da Claude | Esplicita via `/command` |
| Namespace | Nessun namespace | `plugin-name:command` |
| Distribuzione | Locale o via Plugin | Via marketplace |
| Complessità | SKILL.md singolo | Pacchetto multi-componente |

### Struttura di uno Skill (SKILL.md)

```yaml
---
name: code-review
description: Revisione codice secondo best practices. Usare durante revisioni PR.
---

Durante la revisione del codice, analizza:
1. Struttura e leggibilità del codice
2. Vulnerabilità di sicurezza
3. Implicazioni di performance
4. Copertura test

Fornisci feedback organizzati per priorità:
- Critici (da correggere obbligatoriamente)
- Avvertimenti (da correggere)
- Suggerimenti (da considerare)
```

### Posizioni di archiviazione degli Skills

| Tipo | Percorso | Priorità |
|------|----------|----------|
| Progetto | `.claude/skills/` | Alta |
| Utente | `~/.claude/skills/` | Media |
| Plugin | `plugin/skills/` | Bassa |

---

## 3. Server MCP – Integrazione strumenti esterni

**Model Context Protocol (MCP)** permette a Claude di accedere a fonti dati e strumenti esterni. I server MCP sono indipendenti da Claude Code e possono essere usati da vari client.

### MCP vs. Plugin

| Aspetto | Server MCP | Plugins |
|---------|------------|---------|
| Protocollo | Standardizzato (JSON-RPC) | Specifico Claude Code |
| Client | Qualsiasi client MCP | Solo Claude Code |
| Trasporto | stdio, HTTP, WebSocket | Integrato |
| Focus | Integrazione strumenti | Estensione workflow |

### Integrare MCP nei Plugin

I plugin possono configurare server MCP via `.mcp.json`:

```json
{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "@my-org/db-mcp-server"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    }
  }
}
```

### Quando MCP vs. Plugin?

**Usa MCP quando:**
- Integri API/database esterni
- La funzionalità deve essere agnostica al client
- Vuoi usare server MCP esistenti

**Usa i Plugin quando:**
- Personalizzi i workflow Claude Code
- Hai bisogno di slash commands o hooks
- Vuoi definire agents specializzati

---

## 4. Agents & Subagents – Assistenti specializzati

Gli **Agents** (chiamati anche subagents) sono personalità IA preconfigurate a cui Claude Code può delegare task.

### Differenza dagli Skills

| Aspetto | Agents | Skills |
|---------|--------|--------|
| Esecuzione | Finestra contesto propria | Nel contesto principale |
| Strumenti | Configurabili/limitabili | Eredita tutti gli strumenti |
| Modello | Configurabile | Modello principale |
| Scopo | Delega task | Estensione capacità |

### Definizione di un Agent

```yaml
---
name: code-reviewer
description: Revisione codice esperta. Usare proattivamente dopo modifiche al codice.
tools: Read, Grep, Glob, Bash
model: sonnet
permissionMode: default
---

Sei un senior code reviewer. Concentrati su:
- Qualità e leggibilità del codice
- Best practices di sicurezza
- Considerazioni di performance
- Copertura test

Fornisci feedback azionabili con esempi.
```

### Agent integrati

Claude Code include questi agent integrati:

| Agent | Scopo | Modello |
|-------|-------|---------|
| **general-purpose** | Task multi-step complessi | Sonnet |
| **Explore** | Ricerca codebase (sola lettura) | Haiku |
| **Plan** | Ricerca in modalità piano | Sonnet |

---

## 5. CLAUDE.md & AGENTS.md – Contesto progetto

Questi file Markdown forniscono a Claude contesto persistente sul tuo progetto.

### CLAUDE.md

Caricato automaticamente, contiene:
- Descrizione progetto & architettura
- Convenzioni codice & guide di stile
- Comandi build & test
- File & strutture importanti

```markdown
# Progetto: La Mia Web App

## Architettura
- Frontend: Next.js 14 con App Router
- Backend: Python FastAPI
- Database: PostgreSQL con Prisma

## Comandi
- `npm run dev` - Avvia sviluppo
- `npm test` - Esegui test
- `npm run build` - Build produzione

## Convenzioni
- Usa TypeScript strict mode
- Segui le regole ESLint
- Scrivi test per tutte le nuove funzionalità
```

### AGENTS.md

Istruzioni specifiche per agent IA:

```markdown
# Istruzioni Agent

## Regole revisione codice
- Verifica sempre le vulnerabilità di sicurezza
- Richiedi copertura test per nuove funzionalità
- Segnala uso di API deprecate

## Linee guida commit
- Usa commit convenzionali
- Includi numeri ticket
- Firma i commit con GPG
```

---

## Plugin ufficiali Claude Code

Anthropic fornisce **12 plugin ufficiali** che dimostrano le best practices:

### 1. agent-sdk-dev
**Kit di sviluppo per il Claude Agent SDK**

| Componente | Descrizione |
|------------|-------------|
| Command | `/new-sdk-app` – Setup interattivo per progetti Agent SDK |
| Agents | `agent-sdk-verifier-py`, `agent-sdk-verifier-ts` – Validazione contro best practices |

### 2. claude-opus-4-5-migration
**Migrazione a Claude Opus 4.5**

Migrazione automatizzata da Sonnet 4.x e Opus 4.1:
- Aggiornamenti stringhe modello
- Adattamenti header beta
- Ottimizzazioni prompt

### 3. code-review ⭐
**Revisione PR automatizzata con sistema multi-agent**

| Componente | Descrizione |
|------------|-------------|
| Command | `/code-review` – Avvia workflow revisione |
| Agents | 5 agent Sonnet paralleli per: conformità CLAUDE.md, rilevamento bug, contesto storico, cronologia PR, commenti codice |

### 4. commit-commands
**Automazione workflow Git**

| Command | Funzione |
|---------|----------|
| `/commit` | Esegui commit modifiche |
| `/commit-push-pr` | Commit, push & crea PR |
| `/clean_gone` | Pulisci branch remote eliminati |

### 5. feature-dev ⭐
**Workflow sviluppo funzionalità in 7 fasi**

| Componente | Descrizione |
|------------|-------------|
| Command | `/feature-dev` – Workflow sviluppo guidato |
| Agents | `code-explorer` – Analisi codebase |
| | `code-architect` – Design architettura |
| | `code-reviewer` – Revisione qualità |

### 6. frontend-design
**Design frontend professionale**

Skill per creare interfacce distintive e pronte per la produzione, evitando l'estetica IA generica.

### 7. hookify
**Generatore hook personalizzati**

| Command | Funzione |
|---------|----------|
| `/hookify` | Crea hook personalizzati |
| `/hookify:list` | Elenca hook esistenti |
| `/hookify:configure` | Configura hook |

### 8. plugin-dev ⭐
**Toolkit sviluppo plugin**

| Componente | Descrizione |
|------------|-------------|
| Command | `/plugin-dev:create-plugin` – Processo guidato in 8 fasi |
| Agents | `agent-creator`, `plugin-validator`, `skill-reviewer` |
| Skills | Sviluppo hook, integrazione MCP, struttura plugin |

### 9. pr-review-toolkit
**Sistema revisione PR completo**

```bash
/pr-review-toolkit:review-pr [aspetti]
```

Aspetti disponibili: `comments`, `tests`, `errors`, `types`, `code`, `simplify`, `all`

### 10. security-guidance
**Hook promemoria sicurezza**

Monitora 9 pattern di sicurezza durante modifiche file:
- Injection comandi
- Vulnerabilità XSS
- Uso di eval()
- HTML pericoloso
- E altro...

---

## Installazione Plugin

### Metodo 1: Via Marketplace

```bash
# In Claude Code
/plugin install marketplace-name/plugin-name
```

### Metodo 2: Sviluppo locale

```bash
# Carica directory plugin
claude --plugin-dir ./my-plugin
```

### Metodo 3: Configurazione progetto

In `.claude/settings.json`:

```json
{
  "plugins": [
    {
      "name": "my-plugin",
      "source": "./plugins/my-plugin"
    }
  ]
}
```

---

## Creare Plugin personalizzati

### Passaggio 1: Creare la struttura

```bash
mkdir -p my-plugin/.claude-plugin
mkdir -p my-plugin/commands
mkdir -p my-plugin/agents
```

### Passaggio 2: Creare il manifesto

```json
// my-plugin/.claude-plugin/plugin.json
{
  "name": "my-plugin",
  "description": "Il mio primo plugin Claude Code",
  "version": "1.0.0"
}
```

### Passaggio 3: Aggiungere un comando

```markdown
<!-- my-plugin/commands/hello.md -->
---
description: Saluta l'utente calorosamente
---

# Comando Hello

Saluta l'utente chiamato "$ARGUMENTS" calorosamente e chiedi come puoi aiutare.
```

### Passaggio 4: Testare

```bash
claude --plugin-dir ./my-plugin
# Poi in Claude Code:
/my-plugin:hello Max
```

---

## Best practices

### 1. Convenzioni di nomenclatura

```
plugin-name/           # kebab-case per nomi plugin
├── commands/
│   └── my-command.md  # kebab-case per nomi comandi
├── agents/
│   └── my-agent.md    # kebab-case per nomi agent
└── skills/
    └── my-skill/      # kebab-case per cartelle skill
        └── SKILL.md   # MAIUSCOLO per SKILL.md
```

### 2. Componenti focalizzati

Ogni componente dovrebbe fare **una cosa** bene:

```yaml
# ✅ Buono: Agent specializzati
---
name: security-reviewer
description: Revisione codice per sole vulnerabilità di sicurezza
tools: Read, Grep
---
```

### 3. Descrizioni chiare

Le descrizioni aiutano Claude a decidere quando usare un agent/skill:

```yaml
# ✅ Specifico
description: Revisione codice TypeScript per problemi di tipizzazione. Usare proattivamente quando si modificano file .ts o .tsx.
```

---

## Riepilogo: Quando usare cosa?

| Caso d'uso | Raccomandazione |
|------------|-----------------|
| Personalizzazione workflow personale | Skills in `.claude/skills/` |
| Standard di team | Plugin via marketplace |
| Integrazione API esterne | Server MCP |
| Delega task specializzati | Agent personalizzati |
| Contesto progetto per Claude | CLAUDE.md |
| Regole specifiche IA | AGENTS.md |
| Automazione basata su eventi | Hooks |

---

## Conclusione

Il sistema di estensioni Claude Code offre massima flessibilità:

- **Plugin** per pacchetti completi e distribuibili
- **Skills** per capacità contestuali
- **Server MCP** per integrazione strumenti esterni
- **Agents** per delega task specializzati
- **CLAUDE.md** per contesto progetto

Con i 12 plugin ufficiali come ispirazione e questa guida come riferimento, puoi personalizzare perfettamente Claude Code per i tuoi workflow di sviluppo.

---

## Domande frequenti (FAQ)

### Qual è la differenza tra un Plugin e un server MCP?

I plugin sono pacchetti di estensione specifici per Claude Code che raggruppano Commands, Agents, Skills e Hooks. I server MCP sono server di strumenti basati su protocollo utilizzabili da qualsiasi client compatibile MCP. I plugin possono configurare server MCP, ma i server MCP sono utilizzabili indipendentemente dai plugin.

### Posso convertire configurazioni `.claude/` esistenti in plugin?

Sì! Puoi copiare i tuoi commands esistenti da `.claude/commands/`, agents da `.claude/agents/`, e skills da `.claude/skills/` direttamente in una directory plugin. Aggiungi semplicemente un manifesto `.claude-plugin/plugin.json` e la tua configurazione diventa un plugin condivisibile.

### Quando dovrei usare un Agent personalizzato invece di uno Skill?

Usa gli **Agents** quando hai bisogno: di una finestra di contesto propria, accesso agli strumenti ristretto, un modello diverso (es: Haiku per ricerche veloci), o di delegare task multi-step complessi. Usa gli **Skills** per estensioni di capacità più semplici che devono eseguire nel contesto principale.

### Come posso condividere plugin con il mio team?

Diverse opzioni: 1) Crea un marketplace di team (repository Git con indice plugin), 2) Condividi la directory plugin tramite il vostro monorepo, 3) Pubblica su un marketplace pubblico. Per uso in team, si raccomanda un marketplace privato basato su Git.

### Quali hook sono più utili per i workflow sviluppatore?

Gli hook più popolari sono: `PostToolUse` per linting automatico dopo modifiche file, `PreToolUse` per controlli sicurezza prima di operazioni pericolose, e `SessionStart` per iniezione contesto. Il plugin `security-guidance` dimostra hook PreToolUse efficaci per monitoraggio sicurezza.

## Related

- [Sviluppo agenti AI](https://www.contextstudios.ai/it/sviluppo-agente-ia.md)
- [Sviluppo AI](https://www.contextstudios.ai/it/sviluppo-ia.md)
- [Sviluppo API AI](https://www.contextstudios.ai/it/sviluppo-api-ia.md)
- [Automazione AI](https://www.contextstudios.ai/it/automazione-ai.md)