Sonnet, Opus ed effort in Claude Code: scegliere un modello

Materiali pratici su modelli e lavoro con gli agenti: documentazione di Ailoot.

Aggiornato il 23 settembre 2026. Dalla pubblicazione di questo articolo, Anthropic ha cambiato generazione di modelli due volte: prima sono stati rilasciati Opus 5 e Sonnet 5, poi Claude Opus 5.5 il 22 settembre. La logica di selezione di questa guida è ancora valida: usa il modello costoso per l'architettura e il debugging, e il modello di fascia media per il lavoro quotidiano. I nomi e i prezzi sono cambiati. Spiego esattamente cosa è cambiato e come leggere le tabelle qui sotto nella prossima sezione.

Cosa è cambiato a settembre 2026: Opus 5.5, Sonnet 5 e nuove tariffe#

Ecco un riepilogo rapido di cosa è cambiato nei dati e nei comandi:

Tre conclusioni che cambiano il lavoro quotidiano.

Il modello di fascia alta costa meno. Anthropic afferma che Opus 5.5 richiede meno calcolo, quindi il prezzo per token è sceso del 20%, le letture dalla cache sono scese da $0.50 a $0.20 per milione e i carichi di lavoro tipici con le impostazioni predefinite costano il 40% in meno rispetto a Opus 5. La vecchia reazione «Ho attivato Opus: ho consumato il mio limite in mezza giornata» è meno convincente, anche se non è scomparsa.

Ora devi impostare manualmente la profondità di ragionamento. Opus 5.5 parte da medium, mentre gli altri modelli che supportano effort partono da high. Se ti aspetti un'analisi approfondita dal modello di fascia alta, imposta esplicitamente /effort high o xhigh. Un altro dettaglio: la chiave di primo livello effortLevel nelle impostazioni utente non funziona per Opus 5.5, perché ora il livello viene salvato separatamente per ogni modello.

Tutti e tre i modelli attuali hanno una finestra di contesto da un milione di token. Le note sui 200K per il modello di fascia media e sull'upgrade a 1M con opus[1m] non si applicano agli attuali Opus 5.5 e Sonnet 5: hanno un milione di token nativamente.

Le tabelle e i calcoli qui sotto mantengono i nomi e le tariffe originali dei modelli per illustrare la logica di selezione. Usa i prezzi attuali: $4 / $20 per il modello di fascia alta e $2 / $10 per quello di fascia media.

Cosa cambia a maggio 2026: Sonnet 4.6, Opus 4.7, Haiku 4.5 e perché è importante#

Il 6 maggio 2026, alla conferenza Code with Claude, Anthropic ha introdotto cinque importanti aggiornamenti: memoria gestita (Dreaming), outcomes, orchestrazione multi-agente, Remote Control e Agent View. Lo stesso giorno, i limiti di Pro, Max, Team ed Enterprise sono stati raddoppiati. La limitazione nelle ore di punta, in vigore da fine marzo, è stata rimossa del tutto.

Allo stesso tempo, è emerso un diverso accordo sul calcolo. Nel suo S-1, SpaceX ha reso noto un accordo con Anthropic del valore di 1,25 miliardi di dollari al mese fino a maggio 2029 per Colossus (oltre 220.000 GPU NVIDIA, oltre 300 MW). Questo significa che Claude avrà più capacità nei prossimi anni, non meno.

Cosa cambia in pratica per chi programma a colpi di prompt? Il flusso di lavoro tipico suonava così: «Uso Opus perché è più intelligente». Ora i tre modelli si distinguono davvero:

• Opus 4.7 ($5 / $25 per milione di token in ingresso/uscita, contesto da 1M) — rilasciato il 16 aprile 2026. Nuovo tokenizer. SWE-bench Verified: 87,6%, in aumento del 13% rispetto a Opus 4.6.
• Sonnet 4.6 ($3 / $15, contesto da 1M) — 79,6% su SWE-bench Verified. Il 91% del punteggio di Opus 4.7 al 60% del prezzo base di input/output, e quasi alla pari con Opus 4.6 (80,8%): appena 1,2 punti di differenza.
• Haiku 4.5 ($1 / $5, contesto da 200K) — veloce ed economico. Per tutto ciò che non richiede ragionamento architetturale.

E il punto principale: tre nuovi comandi di Claude Code aggiornati all'inizio di maggio: /model, /effort, /fast. Ognuno può ridurre l'uso dei token da 2 a 5 volte se sai quando usarlo.

Nella pratica descritta qui, entrambi i modelli principali vengono usati ogni giorno. Ecco la mappa decisionale che ne deriva.

Come scegliere un modello: una mappa decisionale per tipo di attività#

Questa tabella è comoda da tenere a portata di mano e consultare quando passi da un'attività all'altra.

Il principio principale: imposta Sonnet come predefinito. Sonnet 4.6 è il modello predefinito sulla maggior parte dei piani utente per un motivo. La guida ufficiale di Anthropic afferma chiaramente che Sonnet è la scelta giusta per la maggior parte delle attività di programmazione.

Un'abitudine rischiosa in cui cade l'80% dei principianti: impostano Opus come predefinito e si chiedono perché il loro limite finisca in mezza giornata. Il limite finisce perché Opus costa 1,67 volte tanto per token.

In cosa differiscono Sonnet 4.6 e Opus 4.7 nelle attività reali#

Un benchmark da solo non significa molto. Ciò che conta è la differenza nelle attività reali. Ecco entrambi i modelli a confronto sulla stessa attività.

Scenario 1. Refactoring semplice (3–5 file).

Sonnet e Opus si comportano allo stesso modo. Nel confronto descritto, non è stata osservata alcuna differenza nella qualità del codice. Tempo: Sonnet è più veloce del 15–20%. Costo: Sonnet costa 1,67 volte meno, quindi il vincitore è ovvio.

Scenario 2. Debugging di un bug non banale. Supponiamo che su una piattaforma di e-commerce gli avvisi di ricevuta via email smettano di arrivare dopo la migrazione di un gateway di pagamento. Sintomo: cron viene eseguito, il database riceve un record, ma l'email non viene inviata.

• Sonnet: in 15 minuti controlla i log e i punti più ovvi, trova il servizio email nelle variabili d'ambiente e suggerisce di controllare la chiave. Se la chiave è OK, inizia a girare in tondo.
• Opus con effort xhigh: costruisce subito una mappa mentale: «webhook → cron → controllo dello stato → servizio email». In 20 minuti scopre che la migrazione ha cambiato il formato dell'ID dell'ordine, mentre il servizio email filtra usando il formato precedente.

Non è magia. È ragionamento adattivo: a ogni passaggio Opus 4.7 decide quanto ragionare e, davanti a un bug difficile, usa token per ragionare più a fondo, non per rispondere più in fretta.

Scenario 3. Decisione architetturale. «Dovremmo spostare l'analisi in un servizio separato?» Sonnet darà un buon piano per una domanda simile, ma potrebbe trascurare delle sfumature, per esempio che il monitoraggio di due servizi richiederà di spostare gli avvisi. Opus 4.7 esamina sistematicamente queste sfumature.

L'ultima riga è importante. Quando leggi «Opus 4.7 costa tot», ricorda: lo stesso file richiederà dal 20 al 35% di token in più rispetto a Sonnet. Il costo reale per la stessa attività aumenta ancora più di quanto suggeriscano i prezzi nominali della tabella.

Quando usare Haiku 4.5 (e perché l'80% delle attività di Claude Code usa Sonnet)#

Dove Haiku è davvero vantaggioso:

• Script di una riga: «scrivi uno script bash per riavviare nginx se il processo non risponde per 30 secondi».
• Semplici richieste di spiegazione del codice: «cosa fa questa funzione?»
• Generare messaggi di commit convenzionali.
• Controlli sintattici di base / correzioni lint.
• Tradurre commenti tra lingue.

Dal punto di vista tecnico, Haiku funziona in Claude Code proprio come tramite /model haiku. C'è però una particolarità: gli subagent e le attività in background usano Haiku per impostazione predefinita, a meno che non lo sovrascrivi con la variabile d'ambiente ANTHROPIC_DEFAULT_HAIKU_MODEL.

Il contesto di Haiku è di 200K token. È sufficiente per la maggior parte dei file, ma raggiungerai il limite se lavori con un monorepo o trascrizioni lunghe. In quel caso, Sonnet e Opus hanno 1M.

Costo: 1.000 richieste simili (per esempio, generare messaggi di commit da 200 token in ingresso + 50 in uscita) costano $0.45 su Haiku. Lo stesso carico di lavoro costa $1.35 su Sonnet e $2.25 su Opus. La differenza è di tre volte.

Il comando /model: come cambiare modello durante una sessione#

Sei modi per impostare il modello in Claude Code, in ordine di priorità:

1. Durante una sessione: /model <alias>: cambia modello all'istante. La cronologia della conversazione, i file e il contesto vengono mantenuti; cambia solo il modello che elabora il messaggio successivo. Se nella sessione è già stato generato dell'output, il menu di selezione chiederà conferma: la risposta successiva rileggerà l'intera cronologia senza cache.
2. All'avvio: claude --model <alias>.
3. Variabile d'ambiente: ANTHROPIC_MODEL=<alias>.
4. File delle impostazioni: il campo model in ~/.claude/settings.json.

Comandi di base:

# Avvia con il modello di fascia alta (attualmente Opus 5.5)
claude --model opus

# Passa a Sonnet durante una sessione
/model sonnet

# Apri il menu di selezione (per la selezione interattiva)
/model

# Passa a Opus con contesto da 1M
/model opus[1m]

# Passa a una versione specifica (fissandola)
/model claude-opus-5-5

Alias e modelli a cui puntano nell'API Anthropic (al 23 settembre 2026):

• opus → Opus 5.5 (richiede Claude Code v2.1.280 o successiva)
• sonnet → Sonnet 5
• haiku → Haiku 4.5
• best → il modello più intelligente disponibile
• default → Opus 5.5 su Pro, Max, Team, Enterprise e API Anthropic
• opusplan → un ibrido di Opus + Sonnet (trattato separatamente più avanti)

⚠️ Le impostazioni predefinite differiscono presso i provider cloud: su Amazon Bedrock e Google Cloud, l'alias sonnet punta a Sonnet 4.5; su Microsoft Foundry, opus risolve ancora in Opus 4.6. Se lavori tramite un provider cloud, fissa una versione specifica (claude-opus-5-5) oppure imposta la variabile ANTHROPIC_DEFAULT_OPUS_MODEL.

Dalla versione 2.1.144, il cambiamento principale è che /model non scrive più la selezione nelle impostazioni. Si applica alla sessione corrente e scompare quando la sessione viene chiusa. Per salvare un modello predefinito in modo permanente, premi d sulla riga evidenziata nel menu di selezione. Questo scrive il campo model in ~/.claude/settings.json.

Le sessioni riepilogate (claude --resume, --continue, /resume) mantengono il modello usato in quella sessione, indipendentemente dalle impostazioni correnti. Questo impedisce che un'altra sessione cambi il modello quando riprendi il lavoro.

Per controllare quale modello è attivo, usa /status: mostra sia l'account sia il modello corrente.

/model opusplan: confronta separatamente pianificazione ed esecuzione#

Nella pratica descritta qui, questa modalità viene usata per le attività che richiedono più di 10 passaggi.

La logica:

• In Plan Mode (/plan), discuti l'architettura e le opzioni e concordi un approccio. Opus è costoso in questa fase, ma vale il suo prezzo perché il suo ragionamento è sostanzialmente diverso.
• Appena Plan Mode termina e Claude inizia a modificare file, scrivere test ed eseguire comandi, si passa all'esecuzione. Per l'esecuzione, Sonnet 4.6 eguaglia Opus in qualità.

Per abilitarlo:

# All'avvio
claude --model opusplan

# Oppure durante una sessione
/model opusplan

Un calcolo specifico. Supponiamo che un refactoring di 50 passaggi abbia una distribuzione tipica:

• Pianificazione (5 passaggi, circa 30.000 token in ingresso + 8.000 in uscita): Opus 4.7
• Esecuzione (45 passaggi, circa 200.000 token in ingresso + 50.000 in uscita): Sonnet 4.6

La base usa 230,000 token di input e 58,000 di output: $2.60 alle tariffe storiche Opus. Opusplan mantiene 30,000 input e 8,000 output su Opus ($0.35) e usa 200,000 input e 50,000 output su Sonnet ($1.35), per $1.70 totali. Il risparmio è ($2.60 − $1.70) / $2.60 = 34.6%. A conteggi identici e con queste tariffe, sostituire l’esecuzione risparmia il 40% di quella porzione; anche con il 90% del costo iniziale nell’esecuzione, il totale scenderebbe del 36%. Differenze di tokenizer richiedono conteggi distinti per modello e non giustificano da sole un 75–80%.

⚠️ Un dettaglio: Opus in Plan Mode con opusplan usa il contesto standard da 200K. L'upgrade automatico a 1M, disponibile con l'alias opus, NON si applica a opusplan. Se pianifichi un'attività enorme con milioni di token di contesto (per esempio, l'analisi di un grande monorepo), usa /model opus[1m] in modo esplicito oppure passa a opusplan DOPO la pianificazione.

Il comando /effort: 5 livelli di ragionamento adattivo#

È il secondo comando più importante dopo /model. Effort è ragionamento adattivo: a ogni passaggio, il modello decide quanto a fondo ragionare in base alla complessità dell'attività. Più alto è il livello, più approfondito è il ragionamento e più token vengono usati.

Livelli (in base all'attività):

Sono supportati tre modelli: Opus 4.7, Opus 4.6 e Sonnet 4.6. Effort non è disponibile sugli altri.

Cosa è cambiato a settembre 2026. I livelli low, medium, high, xhigh e max sono disponibili su Opus 5.5, Opus 5, Sonnet 5, Opus 4.8 e Opus 4.7; Opus 4.6 e Sonnet 4.6 non hanno xhigh e, se richiesto, xhigh viene eseguito come high su questi modelli. Il livello predefinito è high su tutti i modelli che supportano effort, tranne Opus 5.5 (medium) e Opus 4.7 (xhigh). Ciò significa che sul modello di fascia alta attuale l'analisi approfondita va richiesta esplicitamente. È comparsa anche una modalità separata, ultracode: è un'impostazione di Claude Code, non un livello del modello; invia xhigh e chiede inoltre a Claude di creare flussi di lavoro dinamici per attività grandi.

Come impostarlo:

# Apri il cursore interattivo
/effort

# Imposta direttamente il livello
/effort high
/effort xhigh

# Ripristina il valore predefinito del modello
auto

# Tramite un flag di avvio
claude --effort high

# Tramite una variabile d'ambiente (si applica all'avvio)
export CLAUDE_CODE_EFFORT_LEVEL=high

# Nelle impostazioni (max non funziona: vale solo per la sessione)
{
  "effortLevel": "high"
}

# Nel frontmatter di una skill / subagent
---
name: my-skill
effort: low
---

Il livello appare accanto al logo e allo spinner in Claude Code, per esempio «with low effort», quindi non è necessario aprire /model per controllarlo.

Il cursore di effort appare anche all'interno del menu di selezione /model: usa le frecce sinistra/destra per impostarlo.

Un dettaglio importante. Quando passi a Opus 4.7 da un altro modello, effort viene impostato forzatamente su xhigh, anche se avevi high per Opus 4.6 o Sonnet 4.6. Per ripristinare il livello desiderato, esegui di nuovo /effort.

Un'altra tecnica: ultrathink nel prompt. Se includi la parola ultrathink nel testo del prompt, Claude userà un ragionamento più profondo per quel singolo turno, senza cambiare l'effort della sessione. Espressioni simili («think», «think hard», «think more») non attivano questo comportamento: vengono semplicemente passate come testo ordinario.

Il comando /fast: Opus è 2,5 volte più veloce a 6 volte il prezzo: quando conviene?#

La modalità fast è una funzionalità in anteprima di ricerca. Richiede Claude Code v2.1.36+ e puoi verificarne la versione con claude --version.

Per abilitarla:

# Attiva o disattiva la modalità fast (disponibile nella CLI di Claude Code e nell'estensione VS Code)
/fast

# Oppure nelle impostazioni
{
  "fastMode": true
}

Dopo l'attivazione:

• Se stai usando un altro modello, Claude Code passerà automaticamente a Opus.
• Apparirà una conferma «Fast mode ON».
• Accanto al prompt apparirà l'icona ↯.

Opzioni e dettagli:

• Il modello predefinito in modalità fast è il modello Opus più potente disponibile. Al 23 settembre 2026 è Opus 5.5; la modalità fast non funziona affatto su Opus 4.7 e, se passi a quest'ultimo, viene disattivata.
• La modalità fast viene salvata tra le sessioni per impostazione predefinita. Gli amministratori Team/Enterprise possono richiedere l'attivazione esplicita per ogni sessione con fastModePerSessionOptIn: true.
• Quando disattivi la modalità fast eseguendo di nuovo /fast, resti su Opus: il modello non torna a quello precedente. Per cambiare, usa /model.
• Se la attivi a metà conversazione, il prezzo della modalità fast si applica all'intero contesto della conversazione. È quindi più conveniente attivare la modalità fast all'inizio della sessione, non a metà.

Quando usare la modalità fast:

• Debugging in tempo reale: stai osservando una trace e il tempo di risposta è fondamentale.
• Scadenza ravvicinata per un lavoro interattivo: stai preparando una demo per le 18:00 e ti servono iterazioni rapide.
• Iterazione rapida sul codice: stai verificando ipotesi una dopo l'altra.

Quando non usarla:

• Attività autonome lunghe in cui la velocità non è fondamentale. Paghi 6 volte tanto per una velocità di 2,5 volte: non conviene se vai a pranzo mentre Claude lavora.
• Elaborazione in batch, pipeline CI/CD: non è una modalità interattiva.
• Carichi di lavoro sensibili ai costi: la scelta è ovvia.

Disponibilità:

• NON funziona su Bedrock, Vertex o Foundry.
• Richiede crediti di utilizzo nell'account (fatturazione oltre il limite incluso nel piano). Per gli account individuali, si attiva nelle impostazioni di fatturazione della Console. Per Team/Enterprise, deve abilitarla un amministratore.
• I token della modalità fast NON vengono detratti dal limite incluso nel piano. Vengono addebitati direttamente ai crediti di utilizzo, ai prezzi della modalità fast fin dal primo token.

Se raggiungi il limite di richieste della modalità fast o esaurisci i crediti di utilizzo, la modalità fast passa automaticamente a velocità e prezzi standard, l'icona ↯ diventa grigia e il lavoro continua. Quando il limite si reimposta, la modalità fast si riattiva.

Modalità fast ed effort non sono impostazioni in competizione. Puoi combinarle: modalità fast + effort low = velocità massima per le attività semplici.

Quanto costa davvero ogni modello: analisi della fattura mensile#

Prezzi per milione di token (API Anthropic, USD):

Cosa riduce davvero la fattura:

1. Prompt caching. Anthropic memorizza in cache le sezioni ripetute dei prompt: il prompt di sistema, CLAUDE.md, le descrizioni degli strumenti. Una cache hit costa il 10% del prezzo di input. Su Sonnet, il prezzo passa da $3 per milione di token a $0.30: 10 volte meno. Si abilita automaticamente tramite cache_control: { type: "ephemeral" } nella richiesta API. In Claude Code funziona per impostazione predefinita.

2. Batch API: sconto del 50% su input e output per le attività che possono attendere (report, generazione massiva di testi in batch). Sonnet tramite Batch API = $1.50 / $7.50. Non funziona direttamente in Claude Code, ma se crei automazioni con l'Anthropic SDK, usala.

3. opusplan invece di solo Opus: circa 34.6% nell’esempio storico svolto; il totale effettivo dipende da quota d’esecuzione, token, tariffe, cache e nuovi tentativi.

4. Sonnet come predefinito + Opus quando serve: la principale fonte di risparmio. Se Opus è attivo «per ogni evenienza», nella pratica descritta qui si passa a Sonnet. Se l'attività richiede Opus, diventa evidente al terzo o quarto passaggio e si passa esplicitamente con /model opus.

5. Ricorda il nuovo tokenizer di Opus 4.7. Sullo stesso file, Opus 4.7 usa fino al 35% di token in più rispetto a Sonnet 4.6. Il costo reale per la stessa attività aumenta più di quanto suggerisca la tabella.

Un esempio specifico: un'attività tipica per un'agenzia immobiliare che crea il prototipo di un sito per un nuovo cliente: «crea una pagina con tre sezioni, un modulo e l'integrazione con un gateway di pagamento». I risultati sono stati:

• Solo Opus 4.7 (effort high): circa $4.80 a sessione (1,5 ore di lavoro).
• opusplan: circa $1.90 (Opus pianifica, Sonnet esegue).
• Solo Sonnet 4.6 (effort high): circa $1.30, ma la decisione architetturale era peggiore (Sonnet ha adottato un approccio basato su un template, mentre Opus con opusplan ne ha ideato uno adatto ai requisiti non standard).

Per questa attività, vince opusplan. Il risparmio è del 60%, con la qualità di Opus per la parte critica.

Claude Code non mostra direttamente il conteggio dei token per i limiti: questi sono dinamici e dipendono dal piano. Ma in /status puoi vedere il tuo piano e l'utilizzo attuale. Per un controllo più preciso, c'è una guida dettagliata: Come evitare di esaurire i limiti di Claude Code in un giorno.

Quale flusso di lavoro quotidiano dovresti impostare? 4 preset pronti all'uso#

Questi quattro preset si possono alternare in base alla giornata di lavoro e all'attività.

Preset 1. Codice quotidiano: l'80% del tempo di lavoro nella pratica descritta qui.

claude --model sonnet --effort high
# Nella sessione, passa a Opus se serve
/model opus

A cosa serve: nuove funzionalità, piccoli refactoring, debugging di bug semplici, documentazione. Sonnet con effort high è il punto ideale.

Preset 2. Refactoring impegnativo: un grande cambiamento architetturale.

claude --model opusplan
# Prima usa /plan per discutere la struttura
# Dopo aver lasciato Plan Mode, Sonnet gestisce l'esecuzione

A cosa serve: riscrivere un modulo in oltre 15 file, passare da un gateway di integrazione a un altro. Opus gestisce l'architettura (analizzando le dipendenze) e Sonnet l'esecuzione (modificando rapidamente i file). Queste attività possono far risparmiare oltre il 70%.

Preset 3. Correzione rapida: modifiche di una riga e script.

claude --model haiku --effort low

A cosa serve: «cambia il nome di una variabile in tutti i file», «scrivi uno script bash per riavviare nginx», «cosa fa questa funzione?». Haiku gestisce queste attività e costa tre volte meno di Sonnet.

Preset 4. Sessione di architettura: una decisione strategica.

claude --model opus --effort xhigh
# Usa il massimo effort quando entri in Plan Mode:
/plan
# Aggiungi la parola ultrathink al prompt per le domande critiche

A cosa serve: «X dovrebbe essere un servizio separato?», «quali strumenti dovremmo usare per il prototipo?», «come dovremmo organizzare uno schema di database per l'uso multi-tenant?». È qui che Opus 4.7 è costoso, ma vale il suo prezzo, perché un errore in quest'ambito costa settimane di lavoro.

Questi preset possono essere salvati come Skills (un modello per skill) oppure come alias in ~/.zshrc:

alias claude-daily='claude --model sonnet --effort high'
alias claude-refactor='claude --model opusplan'
alias claude-quick='claude --model haiku --effort low'
alias claude-architect='claude --model opus --effort xhigh'

Se lavori in un team, puoi standardizzare tramite impostazioni gestite. Un amministratore imposta availableModels: ["sonnet", "haiku", "opusplan"] nella policy dell'organizzazione e gli utenti non possono scegliere fisicamente Opus direttamente, ma solo tramite attivazione esplicita. È una buona protezione contro il consumo accidentale del limite.

Per chi crea subagent, è anche possibile impostare modelli diversi per ciascun subagent tramite CLAUDE_CODE_SUBAGENT_MODEL o il campo model nel frontmatter della definizione dell'agente. Questo aggiunge un ulteriore livello di ottimizzazione.

Cosa fare quando esaurisci la capacità: 5 tecniche pratiche#

Se /status mostra che hai raggiunto il limite di Opus:

1. Passa a Sonnet 4.6: /model sonnet. Ha una disponibilità separata e non noterai differenze nell'80% delle attività. Sull'API Anthropic, anche quando raggiungi il limite di Opus, Claude Code potrebbe passare automaticamente a Sonnet se ti avvicini alla soglia.

2. Usa opusplan per il lavoro ancora da fare: /model opusplan. Se hai ancora attività in Plan Mode per la giornata, useranno Opus in misura minima (solo per la pianificazione); l'esecuzione sarà interamente su Sonnet.

3. Controlla il prompt caching: assicurati di non averlo disabilitato con DISABLE_PROMPT_CACHING=1. Se CLAUDE.md o il prompt di sistema contiene un megabyte di impostazioni, dovrebbe essere memorizzato nella cache. Con il 90% di letture, l'utilizzo si riduce di dieci volte.

4. Sposta le attività in batch: se hai generazione massiva (report, testi, traduzioni), spostala in uno script con la Batch API: sconto del 50% su input e output. Non funziona direttamente in Claude Code, ma bastano 30 minuti per configurarla con uno script tsx + Anthropic SDK.

5. Usa Haiku per le attività secondarie: per le attività di routine come «scrivi un messaggio di commit» o «spiega cosa fa questo file», passa Claude Code a Haiku. Usa tre volte meno token di Sonnet e cinque volte meno di Opus.

E il promemoria principale: dal 6 maggio 2026, i limiti di Pro, Max, Team ed Enterprise sono raddoppiati e la limitazione nelle ore di punta è stata rimossa. Se Opus esaurisce la tua capacità in mezza giornata, il problema non sono i limiti: si sta usando Opus dove Sonnet sarebbe sufficiente. La mappa decisionale nella seconda sezione di questa guida ti restituisce il controllo.

Per un approfondimento sui limiti e otto regole pratiche per risparmiare token, consulta questo articolo pilastro: Come evitare di esaurire i limiti di Claude Code in un giorno: 8 regole per risparmiare token nel 2026. Un altro complemento utile è Plan Mode in Claude Code: una guida passo passo, perché opusplan non funziona senza Plan Mode. E la base per ogni modello è Come configurare CLAUDE.md nel 2026.

Una configurazione efficace per programmare a colpi di prompt.

Altri materiali e strumenti: Ailoot.