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

# Leggere e richiedere revisioni su una pull request

> Leggi i risultati di Code Review sulla tua pull request GitHub, rispondi o ignorali e richiedi una revisione con `@claude review`.

Code Review è un servizio gestito che un Owner della tua organizzazione Claude attiva per un insieme di repository GitHub. Una volta attivo, Claude revisiona le pull request in quei repository e pubblica i suoi risultati come commenti inline, un riepilogo nel corpo della revisione e un check run denominato **Claude Code Review**. Una revisione non approva né blocca mai la tua pull request, e il check run non si conclude mai con un errore.

Un Owner controlla [quando vengono eseguite le revisioni](/docs/it/code-review-setup#set-when-reviews-run) e [quanto sono approfondite](/docs/it/code-review-setup#set-the-default-review-level) per ciascun repository.

<Note>
  Se il tuo piano non include Code Review, puoi comunque far revisionare il tuo branch a Claude da una sessione di Claude Code: consulta [Revisionare in locale con `/code-review`](/docs/it/code-review-local).
</Note>

<h2 id="severity-levels">
  Livelli di gravità
</h2>

Claude pubblica ogni risultato come commento inline sulle righe interessate e lo contrassegna con uno di tre livelli di gravità:

| Indicatore | Gravità | Significato |
| :- | :- | :- |
| 🔴 | Important | Un bug che dovrebbe essere corretto prima del merge |
| 🟡 | Nit | Un problema minore, che vale la pena correggere ma non bloccante |
| 🟣 | Pre-existing | Un bug che esiste nel codebase ma non è stato introdotto da questa PR |

Quando la revisione ha registrato il suo ragionamento, il risultato include una sezione compressa **Why this was flagged**. Espandila per leggere perché Claude ha segnalato il problema e come lo ha verificato.

Per cambiare ciò che Claude segnala nel tuo repository o come classifica la gravità, consulta [Personalizzare Code Review](/docs/it/code-review-customize).

<h2 id="respond-to-findings">
  Rispondere ai risultati
</h2>

Puoi fare il merge senza rispondere a un risultato, a meno che le regole del tuo repository non lo richiedano. Se la protezione del branch [richiede la risoluzione delle conversazioni](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches#require-conversation-resolution-before-merging), risolvi il thread di ogni risultato prima di fare il merge.

Per eliminare un risultato, risolvi il suo thread o esegui il push di una correzione.

* **Ignoralo senza modificare il codice**: risolvi tu stesso il thread su GitHub. Rispondere soltanto non fa ignorare un risultato.
* **Correggi il problema**: modifica il codice ed esegui il push. La revisione successiva della pull request risolve il thread precedente quando ritiene che il problema sia stato corretto, sia che quella revisione venga eseguita automaticamente al tuo push sia che tu la richieda.
* **Spiega o dissenti**: rispondi al commento. Claude non risponde subito e una risposta non avvia una revisione. La revisione successiva della pull request legge le risposte ai suoi risultati precedenti e può risolvere il thread o pubblicare una risposta di follow-up. Se lo stesso tipo di risultato continua a ripresentarsi, chiedi a un maintainer di aggiungere una regola a [`REVIEW.md`](/docs/it/code-review-customize#choose-what-to-write-in-review-md).

Per ottenere quella revisione successiva senza eseguire il push, scrivi `@claude review` come [commento di primo livello sulla pull request](#comment-commands).

<h2 id="check-run-output">
  Output del check run
</h2>

Il link **Details** sul check run **Claude Code Review** apre i risultati in un'unica tabella ordinata per gravità, inclusi i risultati il cui commento inline non è stato accettato da GitHub:

| Gravità | File:Riga | Problema |
| - | - | - |
| 🔴 Important | `src/auth/session.ts:142` | Il refresh del token entra in race condition con il logout, lasciando attive sessioni obsolete |
| 🟡 Nit | `src/auth/session.ts:88` | `parseExpiry` restituisce silenziosamente 0 con input malformato |

Un risultato che ha una riga ma non è stato pubblicato come commento inline appare come annotazione nella scheda **Files changed**, sulle righe interessate. I risultati Important vengono mostrati in rosso, i nit in giallo e i bug preesistenti in grigio.

Il check run si conclude come neutral, oppure come skipped quando una revisione automatica non è stata eseguita perché un push non ha modificato alcun file. Non si conclude mai con un errore, quindi una revisione completata non fa fallire un check obbligatorio. Se non vedi risultati o una revisione non è stata eseguita, consulta [Risoluzione dei problemi di Code Review](/docs/it/code-review-troubleshooting).

<h3 id="read-the-result-from-a-script">
  Leggere il risultato da uno script
</h3>

Per vincolare un merge o pubblicare un riepilogo dalla tua CI, analizza l'ultima riga del testo Details con `gh` e jq. Quella riga è un commento leggibile dalla macchina.

<Steps>
  <Step title="Trova l'ID del check run">
    Dalla tua shell, elenca i check run del commit e prendi l'`id` del run `Claude Code Review`. Sostituisci `OWNER` e `REPO` con il proprietario e il nome del tuo repository, e `<commit-sha>` con il commit di testa della pull request:

    ```bash theme={null}
    gh api repos/OWNER/REPO/commits/<commit-sha>/check-runs --jq '.check_runs[] | {id, name}'
    ```
  </Step>

  <Step title="Leggi i conteggi per gravità">
    Leggi i conteggi da quel check run, sostituendo `CHECK_RUN_ID` con l'ID:

    ```bash theme={null}
    gh api repos/OWNER/REPO/check-runs/CHECK_RUN_ID \
      --jq '.output.text | split("bughunter-severity: ")[1] | split(" -->")[0] | fromjson'
    ```

    Questo stampa un oggetto JSON con un conteggio per ciascuna gravità e le chiavi in ordine alfabetico, ad esempio `{"nit": 1, "normal": 2, "pre_existing": 0}`. I conteggi includono i risultati delle revisioni precedenti della pull request i cui thread sono ancora aperti.
  </Step>

  <Step title="Agisci in base al risultato">
    Fai in modo che il tuo script gestisca questi casi:

    * **`normal` è maggiore di zero**: fai fallire il job se vuoi vincolare il merge. La chiave `normal` contiene il conteggio dei risultati Important, quindi Claude ha trovato almeno un bug che vale la pena correggere prima del merge.
    * **La riga è assente**: trattala come assenza di verdetto anziché come zero risultati. Un check run per una revisione che è fallita, è andata in timeout, è stata annullata o è stata sostituita da una più recente non ha tale riga, e nemmeno alcune revisioni completate ce l'hanno.
  </Step>
</Steps>

<h2 id="request-a-review">
  Richiedere una revisione
</h2>

Se la tua pull request è una bozza o proviene da un fork, le revisioni automatiche la saltano, quindi [richiedi la revisione con un comando nei commenti](#review-drafts-and-pull-requests-from-forks). Per ottenere una revisione sulla tua pull request, esegui una di queste azioni:

* **Aprila o contrassegnala come pronta**: in un repository impostato su **Once after PR creation** o **After every push**, una revisione si avvia quando apri o riapri la pull request, oppure quando contrassegni una bozza come pronta per la revisione.
* **Scrivi un comando in un commento**: pubblica [`@claude review`](#comment-commands) sulla pull request.
* **Esegui il push di un commit**: un push avvia una revisione in un repository impostato su **After every push**, oppure su una pull request che hai sottoscritto con `@claude review always`.
* **Fai clic su Re-run**: dopo che una revisione è fallita o è andata in timeout su una pull request che non proviene da un fork, [eseguila di nuovo](/docs/it/code-review-troubleshooting#retrigger-a-failed-or-timed-out-review) dal check run.
* **Attendi il nuovo tentativo automatico**: una revisione la cui sessione è stata interrotta viene riprovata automaticamente una volta. Il [riepilogo del check run](/docs/it/code-review-troubleshooting#retrigger-a-failed-or-timed-out-review) indica quando ciò sta accadendo.

<h3 id="comment-commands">
  Comandi nei commenti
</h3>

Pubblica uno di questi comandi come commento sulla pull request:

| Comando | Cosa fa | Quando usarlo |
| :- | :- | :- |
| `@claude review` | Avvia una singola revisione senza sottoscrivere la PR ai push futuri | Vuoi una revisione adesso, ad esempio su una pull request in un repository impostato su Manual, oppure un'altra revisione immediata nelle altre modalità |
| `@claude review always` | Avvia una revisione e sottoscrive la PR alle revisioni attivate dai push da quel momento in poi | Vuoi che ogni push successivo avvii una nuova revisione, ad esempio su una PR ad alta priorità in un repository impostato su Manual |
| `@claude review once` | Uguale a `@claude review`: avvia una singola revisione senza sottoscrivere | Gli stessi casi di `@claude review` |

Affinché uno qualsiasi di questi comandi avvii una revisione, devono essere soddisfatte tutte queste condizioni:

* Pubblicalo come nuovo commento di primo livello sulla pull request, non come commento inline su una riga del diff né nel corpo di una revisione. La modifica di un commento precedente non conta.
* Metti il comando all'inizio del commento, con `always` sulla stessa riga del resto del comando. Le maiuscole non contano.
* Ti servono i permessi write, maintain o admin sul repository. Claude lo verifica con GitHub per ogni persona che commenta, e i commenti dei bot non avviano revisioni.
* La pull request deve essere aperta.

Quando il comando viene accettato, sulla pull request appare un check run **Claude Code Review** con il titolo **Code review queued...**. Il titolo cambia in **Code review in progress...** quando la revisione inizia. Claude può anche reagire al tuo commento con 👀, ma quella reazione può comparire anche quando non si avvia alcuna revisione, quindi cerca piuttosto il check run.

Se una revisione è già in esecuzione sull'ultimo commit della pull request, una nuova richiesta non ne avvia una seconda.

<Note>
  Prima di un aggiornamento di luglio 2026, `@claude review` sottoscriveva la PR alle revisioni attivate dai push. Se facevi affidamento su quel comportamento, scrivi invece `@claude review always`.
</Note>

<h3 id="what-a-later-review-covers">
  Cosa copre una revisione successiva
</h3>

Una revisione successiva che si avvia da sola, ad esempio dopo un push, si concentra su ciò che è cambiato dall'ultima revisione e pubblica meno nit e risultati preesistenti. Il suo riepilogo conta ciò che ha tralasciato, in una riga che termina con "found and not posted" o "outside the scope of this re-review and not posted."

Per ottenere una revisione che non tralasci nulla di tutto ciò, scrivi [`@claude review`](#comment-commands). Copre di nuovo l'intera pull request.

<h3 id="review-drafts-and-pull-requests-from-forks">
  Revisionare bozze e pull request provenienti da fork
</h3>

Le revisioni automatiche saltano entrambe, quindi richiedi la revisione con un comando nei commenti:

* **Pull request in bozza**: un comando nei commenti viene eseguito su una bozza, quindi puoi richiedere una revisione prima di contrassegnare la pull request come pronta. I push su una bozza non avviano revisioni, nemmeno dopo `@claude review always`. La sottoscrizione ha effetto quando contrassegni la pull request come pronta.
* **Pull request provenienti da fork**: Claude non revisiona automaticamente una pull request proveniente da un fork, indipendentemente dall'impostazione **Review runs** del repository. Per avviarne una, scrivi `@claude review` sulla pull request. Si applicano comunque le [condizioni per i comandi nei commenti](#comment-commands), e l'accesso in scrittura di cui hai bisogno è sul repository di base, non sul fork.

Su una pull request proveniente da un fork, anche `@claude review always` funziona, ma non sottoscrive la pull request alle revisioni sui push successivi. Fare clic su **Re-run** sul check run non avvia una revisione in quel caso.

<h3 id="use-code-review-alongside-the-claude-code-github-action">
  Usare Code Review insieme alla GitHub Action di Claude Code
</h3>

Se il repository esegue anche la [GitHub Action di Claude Code](/docs/it/github-actions) in modalità interattiva con la sua frase di attivazione predefinita `@claude`, un commento `@claude review` avvia anche la Action. Per tenere separate le due cose, imposta l'input `trigger_phrase` della Action su una frase diversa.

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

* [Risoluzione dei problemi di Code Review](/docs/it/code-review-troubleshooting): una revisione che non si è avviata, è fallita o è stata saltata per il budget
* [Code Review](/docs/it/code-review): cos'è il servizio e come viene eseguita una revisione
* [Configurare Code Review](/docs/it/code-review-setup): per gli Owner, attiva Code Review e scegli quando eseguire le revisioni e a quale livello
* [Personalizzare Code Review](/docs/it/code-review-customize): cambia ciò che Claude segnala con `REVIEW.md` e `CLAUDE.md`
* [Costi e utilizzo di Code Review](/docs/it/code-review-costs): come vengono fatturate le revisioni e dove si imposta il limite di spesa
* [Revisionare in locale con `/code-review`](/docs/it/code-review-local): esegui una revisione del tuo branch da una sessione di Claude Code