> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Creare un mod

> Fai scrivere a Claude un mod di Claude Code da una descrizione, oppure scrivi tu stesso uno che conta le chiamate ai tool e aggiunge un comando. Impara il ciclo di ricaricamento e convalida.

Un mod è un [plugin](/docs/it/plugins/overview) di Claude Code con un file di ingresso, chiamato modulo hooks: un file JavaScript o TypeScript le cui funzioni Claude Code chiama quando accadono eventi. Ci sono due modi per crearne uno:

* **Chiedi a Claude di scriverlo**: [descrivi quello che vuoi](#ask-claude-for-a-mod) in una sessione di Claude Code
* **Scrivilo tu stesso**: [segui il tutorial](#write-a-mod-yourself) per imparare come funziona il codice di un mod. Non hai bisogno di Node.js, di un bundler o di un passo di build, perché Claude Code carica i file `.js` e `.ts` direttamente.

Se non hai ancora deciso se un mod è lo strumento giusto, leggi prima il [confronto nella panoramica](/docs/it/plugins/mods/overview#compare-mods-settings-hooks-skills-and-mcp-servers).

<Note>
  I mod richiedono Claude Code v2.1.287 o successivo. Nel tuo shell, esegui `claude --version` per verificare. Per vedere se i mod possono caricarsi per te, vedi [Verificare se i mod possono caricarsi](/docs/it/plugins/mods/troubleshoot#check-whether-mods-can-load).
</Note>

<h2 id="ask-claude-for-a-mod">
  Chiedi a Claude un mod
</h2>

Descrivi il mod che vuoi in una sessione interattiva di Claude Code, e Claude lo scrive. Claude lavora da una [skill](/docs/it/skills) integrata denominata `plugin-authoring`, che gli dice dove scrivere il mod, quali eventi e metodi ha la tua versione e come il mod viene caricato. Claude può caricare la skill quando chiedi un mod, oppure puoi caricarla tu stesso eseguendo `/plugin-authoring` al prompt di Claude Code.

Il mod viene eseguito una volta che lo approvi, tranne nelle [sessioni in cui un mod scritto da Claude non può caricarsi](#sessions-that-skip-the-approval).

<Steps>
  <Step title="Descrivi il mod">
    Chiedi il mod con le tue parole, ad esempio `make a mod that shows the current git branch above the prompt`. Claude scrive il mod in una directory propria nella cartella dei mod della sessione, che è `~/.claude/dev-mods/` seguita dall'ID della sessione. Il percorso completo di un mod è simile a `~/.claude/dev-mods/3f2a9c1e-5b7d-4e8a-9c21-6d0f4b8a7e13/git-branch/`.

    <Note>
      Nelle [modalità di autorizzazione](/docs/it/permission-modes#protected-paths) `default` e `acceptEdits`, Claude Code chiede prima che Claude crei ciascuno dei file del mod, perché `~/.claude` è un percorso protetto. Approva ogni file quando appare.
    </Note>
  </Step>

  <Step title="Approva il mod">
    Quando Claude salva il primo file, Claude Code chiede se abilitare il ricaricamento a caldo per la sessione. Il ricaricamento a caldo esegue i mod scritti da Claude in questa sessione e raccoglie ogni modifica successiva.

    Scegli una di queste risposte:

    * **Abilita per questa sessione**: i mod nella cartella dei mod della sessione si caricano quando il turno termina e si ricaricano alla fine di ogni turno che li modifica. La tua risposta dura per la sessione, anche dopo averla ripresa.
    * **Non ora**: nulla si carica per ora. I file rimangono dove Claude li ha scritti e i mod si caricano la prossima volta che quella sessione inizia. Per impedire che un mod si carichi mai, elimina la sua directory.
  </Step>

  <Step title="Verifica che il mod sia stato caricato">
    Esegui `/plugin` al prompt di Claude Code e premi Tab finché la scheda **Installed** non è selezionata. Elenca il mod e puoi disattivarlo lì.
  </Step>

  <Step title="Prova il mod">
    Usa quello che hai chiesto. Per il prompt di esempio, il nome del ramo corrente appare sopra la casella del prompt. Se il mod non fa quello che volevi, dì a Claude cosa cambiare. Il mod si ricarica alla fine di ogni turno che modifica i suoi file, quindi puoi provare la modifica non appena Claude finisce.
  </Step>
</Steps>

<h3 id="use-the-mod-in-other-sessions">
  Usa il mod in altre sessioni
</h3>

Un mod scritto da Claude si carica solo nella sessione che lo ha creato, e Claude Code elimina la cartella dei mod di quella sessione una volta che è più vecchia di [`cleanupPeriodDays`](/docs/it/settings-reference#cleanupperioddays). Per mantenere il mod, copia la sua directory fuori dalla cartella dei mod in un posto tuo, come `~/mods/git-branch`. Quindi scegli come caricarlo:

* **In una sessione che avvii**: nel tuo shell, esegui `claude --plugin-dir ~/mods/git-branch`
* **Per altre persone**: [aggiungilo a un marketplace](#share-your-mod) in modo che possano installarlo

<h3 id="sessions-that-skip-the-approval">
  Sessioni in cui un mod scritto da Claude non può caricarsi
</h3>

Un mod scritto da Claude si carica solo dopo che lo approvi, in uno spazio di lavoro affidabile dove i mod possono essere eseguiti. In queste sessioni non si carica:

* **Nessuno è lì per approvare**: la sessione non può mostrarti un prompt, come in un'esecuzione `claude -p` o in modalità [`dontAsk`](/docs/it/permission-modes)
* **Lo spazio di lavoro non è affidabile**: non hai accettato il prompt di fiducia per la directory
* **I mod sono fermati**: hai avviato con `--safe-mode` o `--bare`, hai impostato `disableAllHooks`, o le [impostazioni gestite](/docs/it/plugins/mods/admin#choose-how-much-to-allow) della tua organizzazione lo bloccano

<h2 id="write-a-mod-yourself">
  Scrivi un mod tu stesso
</h2>

In questo tutorial costruisci un mod denominato `first-mod` che conta le chiamate ai tool che Claude fa, mostra il conteggio accanto al spinner mentre Claude lavora e aggiunge un comando `/tally` che lo stampa. Quindi leggi le dichiarazioni di tipo che Claude Code scrive accanto al tuo mod ed esegui `claude plugin validate`. Insieme mostrano gli eventi e i metodi che la tua versione offre e cosa Claude Code legge dal tuo codice.

Questa registrazione mostra il mod finito. Lo spinner conta le chiamate ai tool, `/tally` stampa il conteggio e una modifica al codice ha effetto mentre la sessione è in esecuzione:

<Frame>
  <video autoPlay muted loop playsInline controls className="w-full dark:hidden" src="https://mintcdn.com/claude-code/dgiVO_Od1X1faduV/images/mods-first-mod-light.mp4?fit=max&auto=format&n=dgiVO_Od1X1faduV&q=85&s=eb561134afa90375777408453ba51c77" aria-label="In a Claude Code session, the prompt 'list the files here and read the README' is typed and sent. The spinner reads 'Thinking · tool calls: 1' and the count rises as Claude works. The /tally command prints 'first-mod: Claude has made 3 tool calls since this mod loaded'. A line says first-mod reloaded and lists its four hooks. On the next prompt the spinner reads 'Thinking · tools used: 1'." data-path="images/mods-first-mod-light.mp4" />

  <video autoPlay muted loop playsInline controls className="w-full hidden dark:block" src="https://mintcdn.com/claude-code/dgiVO_Od1X1faduV/images/mods-first-mod-dark.mp4?fit=max&auto=format&n=dgiVO_Od1X1faduV&q=85&s=09779dadc7ef66c2b1e2da0c2e31ac72" aria-label="In a Claude Code session, the prompt 'list the files here and read the README' is typed and sent. The spinner reads 'Thinking · tool calls: 1' and the count rises as Claude works. The /tally command prints 'first-mod: Claude has made 3 tool calls since this mod loaded'. A line says first-mod reloaded and lists its four hooks. On the next prompt the spinner reads 'Thinking · tools used: 1'." data-path="images/mods-first-mod-dark.mp4" />
</Frame>

Scrivi tre file:

```text theme={null}
first-mod/
├── .claude-plugin/
│   └── plugin.json
└── hooks/
    ├── hooks.json
    └── register.js
```

* **`plugin.json`**: il [manifest](/docs/it/plugins/manifest-reference) del plugin
* **`hooks.json`**: [punta al tuo file di codice](/docs/it/plugins/mods/reference#files)
* **`register.js`**: il tuo codice, chiamato modulo hooks

<Steps>
  <Step title="Crea la directory del plugin">
    Crea le due directory che contengono i file:

    <Tabs>
      <Tab title="Bash o Zsh">
        ```bash theme={null}
        mkdir -p first-mod/.claude-plugin first-mod/hooks
        ```
      </Tab>

      <Tab title="PowerShell">
        ```powershell theme={null}
        New-Item -ItemType Directory -Force first-mod\.claude-plugin, first-mod\hooks
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Scrivi il manifest">
    Un mod è un plugin e un mod ha bisogno di un [manifest](/docs/it/plugins/manifest-reference). Il manifest di questo mod non ha campi speciali. Salva questo come `first-mod/.claude-plugin/plugin.json`:

    ```json first-mod/.claude-plugin/plugin.json theme={null}
    {
      "name": "first-mod",
      "version": "0.1.0",
      "description": "Counts Claude's tool calls, shows the count beside the spinner, and adds a /tally command",
      "author": { "name": "Your Name" }
    }
    ```
  </Step>

  <Step title="Dì a Claude Code dove si trova il tuo codice">
    Quando Claude Code carica un plugin, legge il `hooks/hooks.json` del plugin. La chiave `modules` in quel file fornisce il percorso al tuo codice, e averlo è quello che rende il plugin un mod. Elenca un percorso, relativo a `hooks.json`. Qui punta a `register.js`, che scrivi nel passo successivo.

    Salva questo come `first-mod/hooks/hooks.json`:

    ```json first-mod/hooks/hooks.json theme={null}
    {
      "description": "The first-mod hooks module",
      "modules": ["./register.js"]
    }
    ```
  </Step>

  <Step title="Scrivi il codice">
    Questo file è il codice del mod, chiamato modulo hooks. Quando il mod si carica, Claude Code chiama la funzione `register` che il file esporta e le passa una funzione denominata [`on`](/docs/it/plugins/mods/reference#the-hook-function). Ogni chiamata a `on` registra un gestore di eventi, chiamato hook, per l'evento che nomina.

    Salva questo come `first-mod/hooks/register.js`:

    ```javascript first-mod/hooks/register.js theme={null}
    // The count, shared by the hooks below
    let calls = 0

    // Claude Code calls this once when the mod loads
    export function register(on) {
      // Runs when the session starts, before your first prompt
      on('session.start', async ($, e, next) => {
        // Add the /tally command
        await $.command.register({
          name: 'tally',
          description: 'Show how many tool calls Claude has made',
        })
        // Let the session start as usual
        return next(e)
      })

      // Runs each time Claude is about to use a tool
      on('tool.call', async ($, e, next) => {
        calls += 1
        // Ask Claude Code to draw the interface again, so the new count shows
        $.ui.invalidate('ui.render')
        // Let the tool run as usual
        return next(e)
      })

      // Runs when you type /tally, and only then, because of the matcher
      on('command.run', { command: 'tally' }, async () => {
        // The text to print in the transcript
        return { text: 'Claude has made ' + calls + ' tool calls since this mod loaded' }
      })

      // Runs each time Claude Code draws the spinner
      on('ui.render', { component: 'Spinner' }, async ($, e, next) => {
        // Keep Claude Code's spinner, with the count added after its word
        return next({ ...e, props: { ...e.props, suffix: ' · tool calls: ' + calls + '…' } })
      })
    }
    ```

    Il file mantiene un conteggio in `calls` e registra quattro hook:

    * **[`session.start`](/docs/it/plugins/mods/reference#session)** viene eseguito quando la sessione inizia, prima del tuo primo prompt, e di nuovo ogni volta che il mod si ricarica. Aggiunge il comando `/tally` a Claude Code.
    * **[`tool.call`](/docs/it/plugins/mods/reference#tools)** viene eseguito ogni volta che Claude sta per usare un tool. Aggiunge uno a `calls` e chiede a Claude Code di disegnare di nuovo l'interfaccia.
    * **[`command.run`](/docs/it/plugins/mods/reference#commands-and-configuration)** viene eseguito quando digiti `/tally`. Restituisce il testo da stampare.
    * **[`ui.render`](/docs/it/plugins/mods/reference#interface)** viene eseguito ogni volta che Claude Code disegna lo spinner. Aggiunge il conteggio dopo la parola dello spinner.

    [Come funziona il mod di esempio](#how-the-example-mod-works) spiega i tre argomenti che ogni hook accetta e cosa ciascuno restituisce.
  </Step>

  <Step title="Carica il mod">
    Avvia Claude Code con il flag `--plugin-dir`, che carica una directory di plugin per una sessione senza installarla:

    ```bash theme={null}
    claude --plugin-dir ./first-mod
    ```
  </Step>

  <Step title="Prova il mod">
    Chiedi a Claude di fare qualcosa che richieda alcuni tool call, come `list the files here and read the README`. Mentre Claude lavora, la parola dello spinner è seguita da un conteggio che aumenta, come in `Thinking · tool calls: 2…`. Quando Claude finisce, digita `/tally` e premi Invio. La trascrizione mostra `first-mod: Claude has made 2 tool calls since this mod loaded`, con il tuo conteggio. Claude Code mette il nome del plugin davanti al testo del comando.

    Per verificare il comando senza una sessione interattiva, eseguilo in modalità non interattiva:

    ```bash theme={null}
    claude -p "/tally" --plugin-dir ./first-mod
    ```

    ```text theme={null}
    first-mod: Claude has made 0 tool calls since this mod loaded
    ```

    Se `/tally` non è nell'elenco dei comandi, il modulo non è stato caricato. Vedi [Scopri perché un mod non fa nulla](/docs/it/plugins/mods/troubleshoot#find-out-why-a-mod-does-nothing).
  </Step>

  <Step title="Cambia il codice mentre la sessione è in esecuzione">
    Lascia la sessione aperta. In `register.js`, cambia `' · tool calls: '` in `' · tools used: '` nell'hook `ui.render` e salva. La riga evidenziata è quella che cambia:

    ```javascript first-mod/hooks/register.js {4} theme={null}
      // Runs each time Claude Code draws the spinner
      on('ui.render', { component: 'Spinner' }, async ($, e, next) => {
        // Keep Claude Code's spinner, with the count added after its word
        return next({ ...e, props: { ...e.props, suffix: ' · tools used: ' + calls + '…' } })
      })
    ```

    Una riga nella trascrizione dice che `first-mod` si è ricaricato ed elenca i suoi hook, e lo spinner successivo usa il nuovo testo, come in `Thinking · tools used: 1…`.
  </Step>
</Steps>

<h3 id="how-the-example-mod-works">
  Come funziona il mod di esempio
</h3>

Ogni funzione che passi a `on` è un hook, che è un gestore di eventi. Claude Code passa a ogni hook gli stessi tre argomenti:

* **L'API dei mod**, denominata `$`: ogni metodo che un mod può chiamare per raggiungere l'esterno, in [namespace](/docs/it/plugins/mods/reference#mods-api-methods) come `$.ui` e `$.command`
* **L'evento**, denominato `e`: l'[input dell'evento](/docs/it/plugins/mods/reference#events) come dati semplici, come il nome e gli argomenti di una chiamata a un tool
* **Il gestore successivo**, denominato [`next`](/docs/it/plugins/mods/events#how-a-hook-handles-an-event): una funzione che passa l'evento agli altri mod e poi al comportamento proprio di Claude Code, e restituisce il risultato

Gli hook in `first-mod` gestiscono i loro eventi nei tre modi in cui un hook può:

* **Osservare**: l'hook `session.start` registra il comando e l'hook `tool.call` conta la chiamata e chiede un ridisegno. Entrambi restituiscono `next(e)`, quindi la sessione inizia e il tool viene eseguito come al solito.
* **Rispondere**: l'hook `command.run` restituisce il suo risultato e non chiama mai `next`. Il secondo argomento a `on`, `{ command: 'tally' }`, è un filtro, chiamato [matcher](/docs/it/plugins/mods/events#filter-which-events-a-hook-handles), quindi l'hook viene eseguito solo per `/tally`.
* **Riscrivere**: l'hook `ui.render` chiama `next` con una copia di `e` il cui `suffix` contiene il conteggio, quindi Claude Code disegna il suo spinner usuale con il tuo testo dopo la parola

Claude Code osserva una directory caricata con `--plugin-dir` e ricarica a caldo il modulo hooks quando un file in essa cambia. Ogni ricaricamento esegue di nuovo `register`, quindi `calls` torna a `0` e `/tally` inizia a contare di nuovo. Per mantenere un valore tra i ricaricamenti, vedi [Mantieni lo stato](/docs/it/plugins/mods/interface#keep-state).

<h2 id="keep-working-on-a-mod">
  Continua a lavorare su un mod
</h2>

Una volta che un mod si carica, puoi far cambiare a Claude il mod, verificare il tuo codice rispetto alle definizioni di tipo per la tua versione, elencare gli eventi e le chiamate che Claude Code trova in esso e testarlo.

<h3 id="change-a-mod-with-claude">
  Cambia un mod con Claude
</h3>

Per cambiare un mod che hai già, avvia la sessione con `--plugin-dir` puntato alla directory del mod, in modo che quello che Claude scrive si carichi nella stessa sessione:

```bash theme={null}
claude --plugin-dir ./first-mod
```

Quindi chiedi il cambiamento, ad esempio `add a /tally-reset command to this mod that sets the tally back to zero`. Claude modifica il modulo hooks, esegue `claude plugin validate` e corregge quello che segnala. Una directory che carichi con `--plugin-dir` è un [percorso protetto](/docs/it/permission-modes#protected-paths), quindi nelle modalità `default` e `acceptEdits` ti viene chiesto di approvare ogni modifica di Claude al mod. La tabella dei percorsi protetti fornisce il risultato per le altre modalità di autorizzazione.

I file che Claude salva durante il suo turno si ricaricano quando il turno termina, quindi puoi provare `/tally-reset` non appena Claude finisce.

<h3 id="get-the-types-for-your-build">
  Ottieni le definizioni di tipo per la tua versione
</h3>

Ogni volta che Claude Code carica o ricarica un mod da una directory che passi a `--plugin-dir`, o un mod [scritto da Claude per te](#ask-claude-for-a-mod), scrive file di dichiarazione TypeScript, che terminano in `.d.ts`, in `.claude-plugin/types/` dentro la directory del mod. Descrivono gli eventi esatti, i metodi dell'API dei mod e gli elementi nelle superfici della versione di Claude Code che stai eseguendo, quindi il tuo editor può completare automaticamente e controllare il tipo dei tuoi hook. Per sfogliare le dichiarazioni online, leggi [`mods/types/claude-code.d.ts`](https://github.com/anthropics/claude-code/blob/main/mods/types/claude-code.d.ts) nel repository di Claude Code, la cui prima riga nomina la versione che l'ha scritto. La directory contiene questi file:

| Percorso | Cosa dichiara |
| :- | :- |
| `claude-code/index.d.ts` | Ogni evento e il suo input e risultato, ogni namespace e metodo dell'API dei mod, e gli elementi che ogni superficie può disegnare |
| `claude-code-tools/index.d.ts` | Gli input e i risultati dei tool integrati, in modo che il controllo `e.tool === 'Bash'` restringa `e` |
| `claude-code-mcp/index.d.ts` | Gli input dei tool MCP che erano connessi l'ultima volta che hai salvato un file nel mod |
| `index.d.ts` in una directory denominata per un plugin | Quello che quel plugin aggiunge all'API dei mod. C'è una directory per ogni plugin che il tuo `plugin.json` elenca sotto `dependencies`. |
| `tsconfig.json` | Opzioni del compilatore che si adattano a un modulo hooks |

Se il tuo mod non ha un suo `tsconfig.json`, Claude Code ne aggiunge uno alla radice del mod che estende quello generato, quindi il tuo editor e `tsc -p ./first-mod` controllano il tipo del mod senza ulteriore configurazione.

Gli eventi e i metodi possono cambiare tra le versioni, quindi affidati a questi file rispetto a qualsiasi pagina, inclusa questa, quando non sono d'accordo.

`claude-code/index.d.ts` è il riferimento più completo per la tua build, con un commento e un esempio per ogni metodo dell'API dei mod. Per cercare qualcosa, cerca il file per il suo nome, come `'tool.call'`.

<h3 id="check-what-claude-code-reads-from-your-mod">
  Verifica cosa Claude Code legge dal tuo mod
</h3>

Per vedere il tuo mod nel modo in cui Claude Code lo vede, senza eseguire il tuo codice o avviare una sessione, usa `claude plugin validate`. Controlla il manifest ed esegue la stessa analisi statica sul sorgente del modulo hooks che Claude Code esegue quando carica un mod. Nel tuo shell, eseguilo sulla directory del mod:

```bash theme={null}
claude plugin validate ./first-mod
```

Per `first-mod`, l'output include queste righe.

```text theme={null}
  ❯ ./register.js hooks: session.start, tool.call, command.run{command=tally}, ui.render{component=Spinner}
  ❯ ./register.js calls: $.command.register, $.ui.invalidate

✔ Validation passed
```

La riga `hooks:` elenca gli eventi che il tuo modulo aggancia, ciascuno con il suo filtro tra parentesi graffe. La riga `calls:` elenca ogni metodo dell'API dei mod che chiama. Un modulo che legge o imposta variabili di ambiente ottiene anche righe `env reads:` e `env writes:`, e uno che usa [`$.state`](/docs/it/plugins/mods/interface#keep-state) ottiene `state reads:` e `state writes:`.

Se un evento che intendevi agganciare manca dalla prima riga, Claude Code non chiamerà nemmeno quell'hook. La causa usuale è un nome di evento scritto male, che il comando segnala come un errore come `"tool.calls" is not an event`.

Segui queste regole in modo che l'analisi statica possa trovare ogni hook e chiamata:

* Scrivi ogni chiamata all'API dei mod per intero: `$`, il namespace, quindi il metodo, come in `$.store.get('notes')`. Puoi passare `$` a una funzione dichiarata al livello superiore dello stesso file, e per una tua funzione denominata `loadNotes`, la riga `calls:` legge quindi `$.store.get (via loadNotes)`. Passare `$` a un metodo, una funzione definita dentro l'hook, o una funzione che importi da un altro dei tuoi file non supera la convalida. Le funzioni `read` e `update` che [`$.state`](/docs/it/plugins/mods/interface#keep-state) usa sono le importazioni che possono prenderlo. Non assegnare `$` o uno dei suoi namespace a una variabile, destrutturarlo o indicizzarlo con un nome calcolato. `const ui = $.ui` fallisce con `$.ui is used as a value`.
* Scrivi il nome dell'evento in ogni chiamata `on` come un letterale di stringa, come in `'tool.call'`. Una variabile, o un ciclo su un elenco di nomi, fallisce con `the event name passed to on() is not a string literal`.
* Dentro `register`, non dichiarare una seconda variabile o parametro denominato `on`. La convalida fallisce con `"on" is declared again (shadowed)`.
* Importa solo da file dentro la directory del plugin, per percorso relativo. L'unica importazione nuda consentita è `claude-code`, per i tipi e alcuni helper.
* Usa dichiarazioni `import` in cima al file, come in `import { name } from './file.js'`. Un `import()` dinamico fallisce con `a dynamic import(); a hooks module imports its own files with an import declaration`.
* Scrivi ogni file come un modulo ES, con `import` e non `require`. Il [riferimento](/docs/it/plugins/mods/reference#files) elenca le estensioni di file che Claude Code carica.

<h3 id="test-the-mod">
  Testa il mod
</h3>

Puoi scrivere test automatizzati per un mod ed eseguirli dal tuo shell con `claude plugin test`, senza sessione, accesso o rete. Un test solleva gli eventi che i tuoi hook gestiscono e verifica cosa hanno fatto gli hook.

Questo test solleva due tool call, esegue `/tally` e verifica che la risposta conti entrambi. Salvalo come `first-mod/tests/first-mod.test.ts`:

```typescript first-mod/tests/first-mod.test.ts theme={null}
import { expect, test } from 'claude-code/testing'

test('/tally reports the tool calls the mod has seen', async ($, on) => {
  // Answer each tool call in Claude Code's place, so no tool runs
  on('tool.call', () => ({ result: 'ok' }))

  // Raise two tool calls, which the mod's tool.call hook counts
  await $.tool.call({ tool: 'Bash', command: 'ls' })
  await $.tool.call({ tool: 'Read', file_path: 'README.md' })

  // Run /tally and check the text its hook returns
  const answer = await $.command.run({ command: 'tally', args: '' })
  expect(answer.text).toBe('Claude has made 2 tool calls since this mod loaded')
})
```

Nel tuo shell, esegui i test dalla directory `first-mod`:

```bash theme={null}
claude plugin test
```

L'output nomina ogni test e se è passato, con tempi che variano da esecuzione a esecuzione:

```text theme={null}
tests/first-mod.test.ts:
(pass) /tally reports the tool calls the mod has seen [22.87ms]

 1 pass
 0 fail
Ran 1 test across 1 file. [0.19s]
```

[Testa un mod](/docs/it/plugins/mods/test) copre lo stub di una chiamata a un modello o dello store, e il test di timer e disegni.

<h2 id="share-your-mod">
  Condividi il tuo mod
</h2>

Un mod è un plugin, quindi lo versioni nel manifest e le persone lo installano e aggiornano con i comandi `/plugin`. Per darlo ad altre persone, [aggiungilo a un marketplace](/docs/it/plugins/publish).

Prima di farlo, controlla il `name` del plugin: `claude plugin validate` fallisce un nome che [sembra uno dei propri di Anthropic](/docs/it/plugins/manifest-reference#name), come uno che inizia con `claude-`. Gli eventi e i metodi possono cambiare tra le versioni, quindi il tuo README è il posto per dire quale versione di Claude Code hai testato.

Continua a sviluppare rispetto alla directory con `--plugin-dir`, non rispetto a una copia installata. Claude Code memorizza nella cache un plugin installato per versione, quindi le tue modifiche non raggiungono la copia installata finché non aumenti la versione e installi di nuovo.

<h2 id="next-steps">
  Prossimi passi
</h2>

* [Disegna nell'interfaccia](/docs/it/plugins/mods/interface): apri un riquadro, disegna sopra il prompt e aggiungi pulsanti e campi di testo
* [Reagisci agli eventi](/docs/it/plugins/mods/events): aggancia le chiamate ai tool, i prompt e i turni
* [Usa l'API dei mod](/docs/it/plugins/mods/api): aggiungi comandi e tool, chiama un modello ed esegui lavoro su un timer
* [Testa un mod](/docs/it/plugins/mods/test): stub quello che Claude Code risponderebbe, e testa timer e disegni
* [Risolvi i problemi di un mod](/docs/it/plugins/mods/troubleshoot): i motivi per cui un mod non fa nulla e il log di debug
* [Leggi il sorgente dei mod integrati](/docs/it/plugins/mods/overview#read-the-source-of-built-in-mods): plugin completi, ciascuno con il suo modulo hooks e test