# Claude Opus 5.5 in Claude Code: run lunghe, regole di stop, subagenti

> Claude Opus 5.5 in Claude Code: regole in CLAUDE.md, checklist in TASKS.md, subagenti per audit e migrazioni e struttura del resoconto finale.

Fonte: Giallo Studio (giallostudio.it) · Pagina: https://giallostudio.it/blog/claude-opus-5-5-claude-code · Pubblicato: 2026-09-23 · Aggiornato: 2026-10-09

Con **Claude Opus 5.5** il lavoro in Claude Code cambia di natura: il modello porta avanti compiti lunghi, in più passaggi, con poca supervisione — Anthropic parla di run di ore con supervisione minima nei test dei primi utilizzatori. Il tuo lavoro non è più guidarlo un passo alla volta: è **scrivere le regole** dentro cui può andare avanti da solo, e leggere bene il risultato quando torna.

Questa guida traduce i consigli della guida ufficiale del lancio in tre cose concrete: cosa scrivere in `CLAUDE.md`, come usare una checklist su file, come dividere il lavoro fra subagenti. Dati verificati il **23 settembre 2026**.

<div class="key-points">
  <p class="kp-title">In sintesi</p>
  <ul>
    <li>Dai il compito intero con la <strong>linea di arrivo</strong>, non il primo passo.</li>
    <li>In <code>CLAUDE.md</code> metti la regola <strong>"continua, fermati solo se…"</strong>.</li>
    <li>Tieni una checklist in <strong><code>TASKS.md</code></strong>: sopravvive al riassunto del contesto.</li>
    <li>Sui lavori grandi usa <strong>subagenti</strong>, uno per parte, e verifica le loro prove.</li>
    <li>Chiudi ogni run con tre titoli: <strong>Bloccato su di me · Cambiato · Trovato</strong>.</li>
    <li>I permessi sulle azioni distruttive <strong>restano attivi</strong>: non è autonomia cieca.</li>
  </ul>
</div>

## Che regola di stop mettere in CLAUDE.md per le run lunghe?

È il pezzo che decide tutto. Senza, il modello si ferma a chiederti conferma a ogni passo e il vantaggio delle run lunghe sparisce. Con una regola troppo larga, fa cose che non vuoi. La formulazione consigliata da Anthropic, tradotta:

> "Quando un passo non richiede il mio intervento, continua. Metti le note di stato nello stesso messaggio della prossima azione. Fermati e chiedi solo quando non puoi continuare senza di me, o prima di qualcosa di distruttivo: cancellare dati, forzare un push, o modificare qualcosa fuori da questo repository."

Tre dettagli che contano:

<ol class="steps">
  <li><strong>"Note di stato nello stesso messaggio della prossima azione"</strong>: così il modello non si ferma per raccontarti cosa ha fatto. Racconta e prosegue.</li>
  <li><strong>L'elenco esplicito delle azioni distruttive</strong>: cancellare, forzare, uscire dal repository. Non "fai attenzione", ma i casi precisi.</li>
  <li><strong>I permessi restano attivi.</strong> La guida è chiara: tieni le richieste di permesso sulle azioni distruttive. La regola dice al modello quando <em>chiedere</em>, non gli dà carta bianca.</li>
</ol>

Se invece stai facendo pair programming — lavori insieme, passo per passo — la regola è l'opposto: chiedi **un piano di una riga prima di iniziare e un riepilogo breve alla fine**. Le due modalità non convivono nello stesso file: scegli in base a come lavori quel giorno.

## Come si assegna a Claude Code il compito intero con la linea di arrivo?

Vale quanto in chat, ma in Claude Code pesa di più perché il modello agisce su file veri. L'esempio ufficiale:

> "Migra gli endpoint dei pagamenti dal vecchio client al nuovo. Finito vuol dire: ogni endpoint usa il nuovo client, il vecchio client è cancellato, e la suite di test passa. Fermati e chiedimi qualcosa solo se un test fallisce per un motivo che non riesci a spiegare."

Puoi **aggiungere istruzioni in corsa** — "tieni anche i vecchi nomi come alias" — senza far ripartire la run. E vanno tolte dai prompt tutte le righe sul ragionamento: Opus 5.5 pensa sempre prima di agire. Il dettaglio è in [prompt per Claude Opus 5.5](https://giallostudio.it/blog/prompt-per-claude-opus-5-5).

## Perché tenere una checklist in TASKS.md nelle run lunghe?

Nelle run lunghe il contesto viene riassunto, e quello che stava solo in memoria si perde. La soluzione della guida è **una checklist su file**:

> "Tieni una checklist in TASKS.md. Spunta ogni voce quando è fatta, e aggiungi tutto quello che trovi di nuovo."

Il file sopravvive al riassunto, e a fine run è anche il resoconto: cosa era previsto, cosa è stato fatto, cosa è emerso. Per i lavori che attraversano più sessioni è l'unica memoria affidabile.

## Come usare i subagenti per i lavori grandi in Claude Code?

Per audit, migrazioni e revisioni su codebase grandi, un modello solo non basta: il contesto si riempie. La guida propone di **dividere il lavoro fra subagenti**, ciascuno con la sua parte, e di far verificare le prove al modello principale. L'esempio ufficiale, tradotto:

> "Controlla ogni servizio in services/ per il bug sui retry descritto nell'issue collegata. Assegna ogni servizio a un suo subagente. Quando un subagente riporta, verifica le sue prove prima di accettarle. Chiudi con una sola tabella: servizio, affetto sì o no, e la prova."

| Elemento | Perché è lì |
|---|---|
| Un subagente per servizio | Ogni parte ha il suo contesto pulito |
| "Verifica le sue prove prima di accettarle" | I subagenti sbagliano; il principale fa da revisore |
| "Chiudi con una sola tabella" | Il risultato è leggibile in un colpo, non in venti messaggi |
| Colonna "prova" | Un "sì" senza prova non vale niente |

Il costo di una run con subagenti è più alto di una run semplice: usali quando il lavoro è davvero grande, non per abitudine. E ricorda che Opus 5.5 costa il 40% in meno di Opus 5 in esercizio, come spiegato in [Claude Opus 5.5: cos'è](https://giallostudio.it/blog/claude-opus-5-5-cos-e): i conti di sei mesi fa vanno rifatti.

## Come leggere il risultato di una run lunga, partendo dai blocchi?

Quando una run lunga finisce, la tentazione è leggere dall'inizio. La guida dice l'opposto: **cerca prima le cose per cui Claude ti sta aspettando** — decisioni aperte, approvazioni richieste. Per renderlo sistematico, in `CLAUDE.md`:

> "Chiudi ogni run con tre titoli: Bloccato su di me, Cambiato, Trovato."

Il primo titolo è quello che sblocca il lavoro. Il secondo è il diff spiegato. Il terzo è quello che il modello ha notato strada facendo e che non era nel compito: spesso è la parte più preziosa.

Per la revisione del codice prima del merge — con il prompt esatto e il dato sorprendente sul livello di sforzo — vedi [revisione del codice con Opus 5.5](https://giallostudio.it/blog/claude-opus-5-5-revisione-codice).

## Cosa sono la Fast mode e i messaggi segnalati in Claude Code?

Due cose specifiche di Claude Code da conoscere.

**Fast mode** (`/fast`): stesso modello, testo che arriva prima, costo per token più alto, richiede l'utilizzo extra abilitato, in anteprima. Serve per il lavoro a botta e risposta, non per le run lunghe dove nessuno aspetta davanti allo schermo. Quando conviene davvero è in [Fast mode di Opus 5.5](https://giallostudio.it/blog/claude-opus-5-5-fast-mode).

**Messaggi segnalati**: Opus 5.5 ha filtri più severi, e quando un messaggio viene segnalato Claude Code passa a un modello precedente con un avviso. `/model` riporta indietro, `Esc` due volte modifica il messaggio, `/config` gestisce il cambio automatico, `/feedback` segnala i falsi positivi. La guida completa è in [Claude è passato a un modello precedente](https://giallostudio.it/blog/claude-opus-5-5-messaggio-segnalato).

## Come funziona Opus in Claude Code in casi concreti?

**Software house, 12 sviluppatori, Padova.** Migrazione di un servizio da una libreria HTTP a un'altra, 40 endpoint. Prima: una sessione per endpoint, con conferma a ogni file. Con Opus 5.5 e la regola di stop in `CLAUDE.md`: un compito solo, "finito vuol dire: ogni endpoint usa il nuovo client, il vecchio è rimosso, i test passano", `TASKS.md` per la checklist. Il modello si è fermato due volte: entrambe su test che fallivano per motivi che non sapeva spiegare — esattamente la regola.

**Team di due persone, agenzia web, Firenze.** Audit di sicurezza su 9 siti con lo stesso plugin. Un subagente per sito, tabella finale con sito, vulnerabile sì/no, prova. Tre siti risultati vulnerabili; le prove erano i file e le righe, verificabili a mano in dieci minuti. Senza la colonna "prova" sarebbe stato un elenco di opinioni.

## Come scegliere una personalizzazione per il lavoro sul repository?

Il modello e l’ambiente di lavoro risolvono problemi diversi. Un Mod può aggiungere una vista o un controllo alla sessione; non cambia automaticamente la qualità del modello. Per scegliere, separa il momento di installazione, il comportamento della UI e la policy del team.

| Esigenza | Percorso di approfondimento |
|---|---|
| Interfaccia, eventi e strumenti | [Mods di Claude](https://giallostudio.it/blog/mods-claude-cosa-sono) |
| Dal marketplace alla sessione | [Installare un Mod](https://giallostudio.it/blog/installare-mods-claude-code) |
| Tre file, una funzione precisa | [Il primo Mod](https://giallostudio.it/blog/creare-claude-code-mod-typescript) |
| Leggere il contesto disponibile | [Token Weather](https://giallostudio.it/blog/token-weather-claude-code-contesto) |
| Valutare prima di eseguire | [Blast Radius](https://giallostudio.it/blog/blast-radius-claude-code-comandi) |
| Rivedere le modifiche del turno | [Replay Theater](https://giallostudio.it/blog/replay-theater-claude-code-modifiche) |
| Due ingressi alla Mods API | [Comandi e tool](https://giallostudio.it/blog/claude-mods-api-comandi-tool) |
| Fixture, tempo e interfaccia | [Mettere alla prova un Mod](https://giallostudio.it/blog/testare-claude-code-mod) |
| Diagnosi dal sintomo alla causa | [Il Mod non funziona](https://giallostudio.it/blog/claude-code-mod-non-funziona) |
| Distribuzione e confini di fiducia | [Mods per il team](https://giallostudio.it/blog/claude-code-mods-team-sicurezza) |

### Collegare i controlli agli eventi con i Hooks

Un hook interviene su un evento preciso della sessione. Prima di costruirlo, decidi quale prova deve raccogliere e come gestire timeout, errori e reinvocazioni. Questi approfondimenti coprono esigenze distinte:

| Esigenza | Percorso di approfondimento |
|---|---|
| Il controllo nel momento giusto | [Claude Code Hooks](https://giallostudio.it/blog/claude-code-hooks-guida) |
| Proteggere file e comandi | [Prima del tool](https://giallostudio.it/blog/claude-code-pretooluse-proteggere-file) |
| Formatter e test, in ordine | [Dopo la modifica](https://giallostudio.it/blog/claude-code-posttooluse-formatter-test) |
| Notifiche sul tuo computer | [Quando serve attenzione](https://giallostudio.it/blog/claude-code-hooks-notifiche) |
| SessionStart e compaction | [Contesto alla ripartenza](https://giallostudio.it/blog/claude-code-sessionstart-compaction) |
| Stop hook senza loop | [Fermarsi con una prova](https://giallostudio.it/blog/claude-code-stop-hook-loop) |
| Un contratto di controllo | [Hooks via HTTP](https://giallostudio.it/blog/claude-code-http-hooks) |
| Intercettare tool e usare handler | [Hooks e MCP](https://giallostudio.it/blog/claude-code-hooks-mcp) |
| Controlli nella delega | [Hooks e subagent](https://giallostudio.it/blog/claude-code-hooks-subagent-team) |
| Matcher, input e log | [L’hook non parte](https://giallostudio.it/blog/claude-code-hooks-debug) |

## Quali errori evitare con le run lunghe di Claude Code?

<ul class="checklist">
  <li><strong>Togliere i permessi sulle azioni distruttive</strong> per "andare più veloce". La regola di stop serve a chiedere, non a saltare.</li>
  <li><strong>Dare il primo passo invece del compito intero.</strong> Il modello si ferma a ogni bivio.</li>
  <li><strong>Definire "finito" in modo non verificabile.</strong> "Quando funziona" non è una linea di arrivo; "i test passano" sì.</li>
  <li><strong>Tenere la checklist solo in chat.</strong> Il riassunto del contesto la cancella.</li>
  <li><strong>Accettare i risultati dei subagenti senza prove.</strong> Il principale deve verificare.</li>
  <li><strong>Usare Fast mode sulle run lunghe.</strong> Costa di più e nessuno sta guardando.</li>
</ul>

## Come introdurre Opus in Claude Code nel team aziendale?

Per un team che adotta Opus 5.5 in Claude Code, quattro file e regole condivise:

<ol class="steps">
  <li><strong><code>CLAUDE.md</code> con la regola di stop</strong> e l'elenco esplicito delle azioni distruttive del vostro contesto: quali cartelle, quali comandi, quali branch.</li>
  <li><strong>I tre titoli di fine run</strong>, così ogni sviluppatore legge i risultati nello stesso modo.</li>
  <li><strong><code>TASKS.md</code> per ogni lavoro che dura più di una sessione.</strong></li>
  <li><strong>Un prompt condiviso per la revisione pre-merge</strong>, da usare prima di ogni pull request.</li>
</ol>

Se il team lavora anche con altri strumenti, il confronto è in [Claude per il codice](https://giallostudio.it/blog/claude-per-codice).

## Conclusione

Opus 5.5 in Claude Code non è "più veloce a scrivere codice": è **capace di andare avanti da solo dentro regole che scrivi tu**. La differenza fra una run che finisce il lavoro e una che ti interrompe venti volte sta in tre file: la regola di stop, la checklist, il formato del resoconto. Il modello fa la sua parte se tu hai fatto la tua.

Se vuoi passare dai test con ChatGPT a un sistema AI integrato nei processi aziendali, [Giallo Studio](https://giallostudio.it/agenti-ai) progetta agenti e automazioni su misura.

## Domande frequenti

### Cosa cambia in Claude Code con Opus 5.5?

Il modello porta avanti compiti lunghi in più passaggi con poca supervisione, e spiega le modifiche in linguaggio piano, per cui le descrizioni delle pull request sono più facili da rivedere. Il lavoro tuo si sposta da guidarlo passo passo a definire regole di stop e linea di arrivo.

### Cosa mettere in CLAUDE.md per le run lunghe?

La regola consigliata da Anthropic: quando un passo non richiede il mio intervento, continua; metti le note di stato nello stesso messaggio della prossima azione; fermati solo se non puoi proseguire senza di me o prima di qualcosa di distruttivo, come cancellare dati, forzare un push o toccare qualcosa fuori da questo repository.

### A cosa serve TASKS.md?

A tenere una checklist che sopravvive al riassunto del contesto nelle run lunghe. Si chiede al modello di spuntare ogni voce fatta e aggiungere quello che trova strada facendo.

### Quando usare i subagenti?

Per lavori grandi su codebase estese: audit, migrazioni, revisioni. Si assegna a ogni subagente una parte, si chiede al modello principale di verificare le prove di ciascuno prima di accettarle, e si chiude con una tabella riassuntiva.

### Come si legge il risultato di una run lunga?

Cercando prima le cose per cui Claude ti sta aspettando: decisioni aperte, approvazioni. Per renderlo sistematico si aggiunge a CLAUDE.md: chiudi ogni run con tre titoli, Bloccato su di me, Cambiato, Trovato.

### Cos'è Fast mode in Claude Code?

Una modalità che fa arrivare il testo prima, stesso modello, a un costo per token più alto. Si attiva con /fast, richiede l'utilizzo extra abilitato, ed è in anteprima. Serve per il lavoro a botta e risposta, non per le run lunghe.
