> ## 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.

# Revisione locale con /code-review

> Esegui `/code-review` in una sessione di Claude Code per trovare bug nelle modifiche del tuo branch, indirizzare la revisione su una pull request o un percorso e far applicare le correzioni a Claude.

`/code-review` è un comando che digiti nel prompt di Claude Code, nella sessione in cui stai lavorando. Claude revisiona le modifiche sul tuo branch, cerca bug di correttezza e riporta ciò che ha trovato nella tua conversazione. A seconda del modello e del livello di sforzo, la revisione copre anche il riutilizzo, la semplificazione e le pulizie per l'efficienza.

Il comando funziona con qualsiasi piano. La revisione viene eseguita nella tua sessione, quindi viene conteggiata nell'utilizzo del tuo piano o nella fatturazione API allo stesso modo del resto della sessione.

<Note>
  Per far revisionare automaticamente su GitHub ogni pull request di un repository, consulta [Code Review](/docs/it/code-review), un servizio gestito che un Owner attiva per la tua organizzazione.
</Note>

`/review` è un alias di `/code-review`. Prima della v2.1.223, `/review` era un comando separato che eseguiva una revisione a passaggio singolo e di sola lettura di una pull request GitHub.

<Steps>
  <Step title="Esegui /code-review">
    Esegui il comando:

    ```text theme={null}
    /code-review
    ```

    Senza una destinazione, la revisione copre le modifiche sul tuo branch corrente. Per indirizzare invece la revisione su una pull request, un altro branch, un percorso o un intervallo di commit, consulta [Scegli cosa revisionare](#choose-what-to-review).

    Puoi anche aggiungere dei flag:

    * `--fix`: chiede inoltre a Claude di applicare i risultati al tuo albero di lavoro dopo la revisione. Le sue modifiche passano attraverso la tua [modalità di permesso](/docs/it/permission-modes).
    * `--comment`: pubblica i risultati su una pull request GitHub come commenti inline, oppure su una [merge request GitLab](#post-findings-to-a-gitlab-merge-request) come singola nota
  </Step>

  <Step title="Continua a lavorare">
    La revisione viene eseguita come [subagent](/docs/it/sub-agents) in background con la propria finestra di contesto, quindi non riempie la tua conversazione. I risultati arrivano nella tua conversazione quando la revisione è completata.
  </Step>

  <Step title="Agisci sui risultati">
    Chiedi a Claude di correggere ciò che la revisione ha trovato. Con `--fix` o `--comment`, Claude applica o pubblica i risultati come parte della revisione, e potrebbe esserti chiesto di approvare le sue modifiche.
  </Step>
</Steps>

<h2 id="choose-what-to-review">
  Scegli cosa revisionare
</h2>

Per revisionare qualcosa di diverso dal tuo branch corrente, digita una destinazione dopo il livello di sforzo e gli eventuali flag. Claude riceve quel testo come destinazione della revisione. Una destinazione può essere il numero di una pull request, il nome di un branch, il percorso di un file o un intervallo di revisioni Git. Trova ciò che vuoi revisionare nella prima colonna e digita ciò che mostra la seconda colonna:

| Per indirizzare la revisione su | Digita |
| :- | :- |
| Il tuo branch corrente e le modifiche non sottoposte a commit | `/code-review` |
| I tuoi ultimi 15 commit | `/code-review HEAD~15..HEAD` |
| Un branch rispetto a un altro | `/code-review main...my-feature` |
| Un singolo commit, dove `abc1234` è l'hash del commit | `/code-review abc1234^..abc1234` |
| Una pull request per numero | `/code-review 1234` |
| Il percorso di un file o di una directory | `/code-review src/auth` |

Senza una destinazione, `/code-review` revisiona i commit del tuo branch che sono avanti rispetto al suo branch upstream, più le tue modifiche non sottoposte a commit. Se il branch non ha un upstream, Claude confronta con `main` o con il commit precedente.

Con `ultra`, Claude Code interpreta la destinazione in modo diverso, come descritto in [Testo dopo il livello di sforzo e i flag](#text-after-the-effort-level-and-flags).

<h2 id="what-the-review-reads-and-edits">
  Cosa legge e modifica la revisione
</h2>

Verifica questi aspetti prima di eseguire una revisione, soprattutto con `--fix`:

* **Modifiche**: senza `--fix`, le istruzioni della revisione chiedono a Claude solo un report. Con `--fix`, gli chiedono anche di applicare i risultati al tuo albero di lavoro. In entrambi i casi, qualsiasi modifica passa attraverso la tua modalità di permesso.
* **Riavvolgimento**: una revisione in background applica le sue modifiche `--fix` al di fuori dei [checkpoint](/docs/it/checkpointing#subagent-edits-not-restored) della tua sessione. Dopo una di queste, `/rewind` ripristina solo i file che Claude aveva già modificato nella tua conversazione. Le modifiche della revisione ad altri file restano, quindi usa git per annullarle. Quando la revisione [viene eseguita in primo piano](#run-in-the-foreground), modifica il tuo albero di lavoro durante il tuo turno, quindi `/rewind` ripristina le sue modifiche come di consueto.
* **Istruzioni**: la revisione segue il tuo `CLAUDE.md`, anche in un'esecuzione `-p` non interattiva. Non legge `REVIEW.md`. Quel file configura il [servizio Code Review](/docs/it/code-review-customize#use-review-md-for-review-only-rules) gestito sulle pull request GitHub.

<h2 id="how-findings-are-reported">
  Come vengono riportati i risultati
</h2>

Claude riporta i risultati come testo nella risposta in entrambe queste esecuzioni:

* In una sessione del terminale, dove `/code-review` esegue la revisione come [subagent forkato](/docs/it/skills#run-skills-in-a-subagent)
* In un'esecuzione `-p` con output in formato testo o JSON

In un'applicazione host che richiede l'elenco dei risultati, come l'[app desktop](/docs/it/desktop#review-your-code), Claude riporta invece i risultati della revisione tramite lo [strumento `ReportFindings`](/docs/it/tools-reference). Il report appare come elenco di risultati, e ogni voce mostra la posizione nel file, un riepilogo di una frase e un tag di categoria come `correctness` quando il risultato ne ha uno. Una richiesta dell'host si applica a ogni livello di sforzo e richiede Claude Code v2.1.218 o successiva.

Quando Claude corregge i risultati riportati più avanti nella sessione, li riporta di nuovo. Claude Code contrassegna quindi ogni risultato nell'elenco aggiornato come corretto, ignorato o nessuna modifica necessaria.

<h2 id="tune-effort-and-arguments">
  Regola lo sforzo e gli argomenti
</h2>

Oltre a `--fix` e `--comment`, il comando accetta questi flag:

* `--post`: in una revisione cloud `ultra` di una pull request su `github.com`, preseleziona la pubblicazione dei risultati finali sulla PR nella finestra di avvio. Consulta [Pubblica i risultati sulla pull request](/docs/it/ultrareview#post-findings-to-the-pull-request). Richiede Claude Code v2.1.227 o successiva.
* `--max-findings <n>`, `--max-findings all` o `--max-findings default`: riporta fino a `n` risultati, oppure tutti i risultati con `all`, al posto del limite abituale della revisione. Quando la revisione riporta tramite lo strumento dei risultati, il limite è 32. Le revisioni successive riutilizzano il valore che hai digitato finché non passi `--max-findings default`, ma un valore passato in un'esecuzione `-p` non interattiva non viene memorizzato. Richiede Claude Code v2.1.288 o successiva.

Passa un [livello di sforzo](/docs/it/model-config#adjust-effort-level) per bilanciare copertura e affidabilità. Con `low`, la revisione riporta i risultati di cui è più sicura, quindi vedi meno falsi positivi. Da `medium` fino a `max`, la revisione amplia la copertura.

Quando non digiti un livello, la revisione riutilizza l'ultimo livello tra `low` e `max` che hai digitato, anche in una sessione precedente. Claude Code mostra un avviso come `Reusing high effort, the level you typed last time`. Queste regole decidono quale livello usa un'esecuzione:

* **Digitare un livello**: un livello che digiti, come `/code-review high`, cambia ciò che riutilizzano le esecuzioni successive
* **Esecuzioni non interattive**: un livello che passi in un'esecuzione `-p` non interattiva non aggiorna il livello memorizzato
* **`ultra`**: la revisione non usa né aggiorna il livello memorizzato
* **Nessun livello mai digitato**: la revisione usa lo sforzo corrente della sessione

Prima della v2.1.223, un `/code-review` senza livello usava sempre lo sforzo corrente della sessione.

<h3 id="post-findings-to-a-gitlab-merge-request">
  Pubblica i risultati su una merge request GitLab
</h3>

Quando passi `--comment` per una merge request GitLab, Claude Code pubblica i risultati tramite la CLI `glab` di GitLab. Richiede Claude Code v2.1.257 o successiva. Quando `glab` non è installato, Claude stampa invece i risultati nel terminale.

Passa la merge request come URL o come riferimento `!123`. Claude Code tratta un numero semplice o il nome di un branch come merge request solo quando l'origin del checkout si trova su `gitlab.com`. Su un'istanza GitLab self-managed, passa l'URL o la forma `!123`.

<h3 id="text-after-the-effort-level-and-flags">
  Testo dopo il livello di sforzo e i flag
</h3>

Dopo il livello di sforzo e i flag, Claude Code legge il resto della riga come destinazione della revisione. L'argomento `ultra` cambia questa interpretazione:

* **Con `ultra`**: Claude Code legge una singola parola come branch di base o numero di PR. Un testo più lungo che non nomina un branch o una PR diventa [una nota allegata alla revisione](/docs/it/ultrareview#pass-a-request-in-plain-words). `/code-review ultra check my auth changes` revisiona il tuo branch corrente e Claude mette in relazione i risultati con la tua nota.
* **Senza `ultra`**: tutto ciò che rimane è la destinazione della revisione, anche quando inizia con il nome di un altro comando. `/code-review /fix-issue 123` esegue la revisione con `/fix-issue 123` come testo della destinazione invece di caricare `/fix-issue` come seconda [skill in sequenza](/docs/it/skills#pass-arguments-to-skills). Prima della v2.1.218, un comando posto in sequenza dopo `/code-review` veniva espanso come skill a sé stante.

<h2 id="run-in-the-foreground">
  Esegui in primo piano
</h2>

Per far eseguire la revisione in primo piano, esegui una di queste operazioni:

* Eseguila in modalità non interattiva, con il flag `-p` o con l'Agent SDK. Claude Code attende la revisione e include i risultati nella risposta, tranne che per `ultra`, che [non attende la revisione cloud](/docs/it/ultrareview#run-ultrareview-non-interactively).
* Imposta [`CLAUDE_CODE_DISABLE_BACKGROUND_TASKS`](/docs/it/env-vars) su `1`, il che disattiva anche tutte le altre funzionalità delle attività in background
* Esegui di nuovo `/code-review` mentre una revisione precedente è ancora in corso

Prima della v2.1.218, la revisione veniva eseguita all'interno della tua conversazione.

<h2 id="let-claude-start-the-review">
  Lascia che Claude avvii la revisione
</h2>

Claude può avviare `/code-review` da solo, senza che tu digiti il comando:

* **Quando lo chiedi in linguaggio naturale**: chiedi a Claude di revisionare le tue modifiche e può eseguire la skill
* **Da un'attività pianificata**: un'[attività pianificata](/docs/it/scheduled-tasks) con `/code-review` come prompt esegue la revisione

Un'attività pianificata non avvia mai la [revisione cloud](#escalate-to-ultrareview), quindi pianifica `/code-review` senza l'argomento `ultra`.

Per impedire sia a Claude sia alle attività pianificate di avviare la revisione mantenendo `/code-review` disponibile per essere digitato da te, aggiungi una voce [`skillOverrides`](/docs/it/skills#override-skill-visibility-from-settings) a un [file di impostazioni](/docs/it/settings#where-settings-live) come `~/.claude/settings.json`:

```json theme={null}
{
  "skillOverrides": {
    "code-review": "user-invocable-only"
  }
}
```

Prima della v2.1.246, Claude avviava `/code-review` da solo solo dove un feature flag recuperato da Anthropic lo attivava. Nelle [sessioni che non recuperano i feature flag](/docs/it/env-vars#features-that-need-feature-flag-fetching), `/code-review` veniva eseguito solo quando lo digitavi, e un `/code-review` pianificato arrivava a Claude come testo semplice.

<h2 id="escalate-to-ultrareview">
  Passa a ultrareview
</h2>

`/code-review ultra --fix` esegue nel cloud la più approfondita [ultrareview](/docs/it/ultrareview), quindi chiede a Claude di applicare i suoi risultati al tuo albero di lavoro quando tornano nella tua sessione.

Ultrareview usa un proprio ambito:

* **Cosa confronta**: il tuo branch corrente rispetto al branch predefinito del repository, più le modifiche non sottoposte a commit e quelle in staging nell'albero di lavoro
* **File sensibili**: per le modifiche non sottoposte a commit a file con nomi simili a credenziali o chiavi, come i file `.env` e `*.tfvars`, Claude Code segue le regole per il [caricamento di un repository locale in una sessione cloud](/docs/it/claude-code-on-the-web#send-local-repositories-without-github)
* **Una base diversa**: passa il nome di un branch, come `/code-review ultra develop`, per confrontare con una base diversa

Quando la destinazione è una pull request su `github.com`, puoi far [pubblicare a Claude i risultati finali sulla PR](/docs/it/ultrareview#post-findings-to-the-pull-request) come commento dal tuo account GitHub. Richiede Claude Code v2.1.227 o successiva.

<Note>
  Ultrareview richiede l'autenticazione con un account claude.ai. Non è disponibile su Amazon Bedrock, Agent Platform di Google Cloud o Microsoft Foundry, né per le organizzazioni con Zero Data Retention abilitato o con la [configurazione HIPAA](/docs/it/hipaa-setup) applicata. In questi casi, `/code-review ultra` esegue invece una revisione locale nella tua sessione. Le organizzazioni che usano [chiavi di crittografia gestite dal cliente](https://platform.claude.com/docs/en/manage-claude/cmek) (CMEK) non possono eseguire ultrareview. Per revisionare le tue modifiche in locale, esegui `/code-review`.
</Note>

Per eseguire una revisione cloud da uno script o da un job CI, usa il [sottocomando `claude ultrareview`](/docs/it/ultrareview#run-ultrareview-non-interactively), che attende i risultati e li stampa su stdout.

<h2 id="change-or-build-on-the-review">
  Modifica la revisione o costruiscici sopra
</h2>

`/code-review` è una [skill inclusa](/docs/it/skills#bundled-skills): le sue istruzioni sono integrate in Claude Code, quindi non esiste un file `SKILL.md` su disco da aprire o modificare. Per fornire a ogni revisione regole di progetto da seguire, aggiungile al tuo `CLAUDE.md`. Per andare oltre, parti da una di queste pagine:

* **Sostituisci il comando**: una skill di progetto o personale chiamata `code-review` viene eseguita al posto di quella inclusa, e l'alias `/review` continua a eseguire la revisione inclusa. Consulta [Risolvi le skill che condividono un nome](/docs/it/skills#resolve-skills-that-share-a-name).
* **Crea il tuo revisore**: scrivi un [subagent](/docs/it/sub-agents) revisore o una [skill](/docs/it/skills) di revisione
* **Usa un comando affine**: [`/simplify`](/docs/it/commands) esegue la revisione solo per la pulizia e applica le sue correzioni, e [`/verify`](/docs/it/commands) esegue la tua app per confermare che una modifica funzioni

Il comando si chiamava `/simplify` prima della v2.1.147, quando applicava le correzioni per impostazione predefinita. Se hai scritto script che usano `/simplify` per trovare bug, passa a `/code-review --fix`.

<h2 id="related-resources">
  Risorse correlate
</h2>

* [Code Review](/docs/it/code-review): il servizio gestito che revisiona ogni pull request su GitHub per la tua organizzazione
* [Ultrareview](/docs/it/ultrareview): configurazione, limiti e costi della revisione cloud più approfondita
* [Comandi](/docs/it/commands): il riferimento in una riga per `/code-review`, `/review`, `/simplify` e `/verify`
* [Skill](/docs/it/skills): come funzionano le skill incluse e come scriverne di tue