Nelle mie recenti conversazioni con gli utenti di Claude Code, un tema ricorre spesso: la finestra di contesto da 1 milione di token è un'arma a doppio taglio.
Permette a Claude Code di operare in modo autonomo più a lungo e di gestire le attività in modo più affidabile, ma apre anche la porta all'inquinamento del contesto se non si è attenti nella gestione delle sessioni.
La gestione delle sessioni è più importante che mai e sembra che ci siano molti dubbi in merito. Si tiene una sessione aperta in un terminale, o due? Si ricomincia da capo a ogni prompt? Quando usare compact, rewind o subagenti? Cosa causa un cattivo compact?
C'è una quantità sorprendente di dettagli che può davvero influenzare la tua esperienza con Claude Code, e quasi tutto deriva dalla gestione della finestra di contesto.
Breve introduzione a contesto, compattazione e degrado del contesto
La finestra di contesto è tutto ciò che il modello può "vedere" contemporaneamente quando genera la sua risposta successiva. Include il prompt di sistema, la conversazione finora, ogni chiamata di strumento e il suo output, e ogni file che è stato letto. Claude Code ha una finestra di contesto di un milione di token.
Sfortunatamente, l'uso del contesto ha un leggero costo, spesso chiamato degrado del contesto. Il degrado del contesto è l'osservazione che le prestazioni del modello diminuiscono man mano che il contesto cresce, perché l'attenzione si distribuisce su più token e i contenuti più vecchi e irrilevanti iniziano a distrarre dal compito corrente. Per il nostro modello da 1 MM di contesto, osserviamo un certo livello di degrado del contesto intorno a ~300-400k token, ma dipende molto dal compito, non è una regola fissa.
Le finestre di contesto hanno un limite netto, quindi quando ti stai avvicinando alla fine della finestra di contesto, dovrai riassumere il compito su cui hai lavorato in una descrizione più piccola e continuare il lavoro in una nuova finestra di contesto. Chiamiamo questo processo compattazione. Puoi anche attivare la compattazione manualmente.
Ogni Turno è un Punto di Diramazione
Diciamo che hai appena chiesto a Claude di fare qualcosa e ha finito. Ora hai alcune informazioni nel tuo contesto (chiamate di strumenti, output degli strumenti, le tue istruzioni) e hai un numero sorprendente di opzioni su cosa fare dopo:
- Continua — invia un altro messaggio nella stessa sessione
- /rewind (esc esc) — torna a un messaggio precedente e riprova da lì
- /clear — avvia una nuova sessione, di solito con un brief che hai distillato da ciò che hai appena imparato
- Compact — riassume la sessione finora e continua sulla base del riassunto
- Subagenti — delega il prossimo blocco di lavoro a un agente con il suo contesto pulito, e riporta solo il suo risultato
Sebbene la cosa più naturale sia semplicemente continuare, le altre quattro opzioni esistono per aiutarti a gestire il tuo contesto.
Quando Avviare una Nuova Sessione
La nuova finestra di contesto da 1M significa che ora puoi svolgere compiti più lunghi in modo più affidabile, ad esempio per fargli creare un'app full-stack da zero. Ma solo perché il tuo modello non ha esaurito il contesto, non significa che non dovresti avviare una nuova sessione.
La nostra regola generale è: quando inizi un nuovo compito, dovresti anche iniziare una nuova sessione.
Un'area grigia è quando potresti voler svolgere compiti correlati in cui parte del contesto è ancora necessaria, ma non tutto.
Ad esempio, scrivere la documentazione per una funzionalità che hai appena implementato. Sebbene tu possa avviare una nuova sessione, Claude dovrebbe rileggere i file che hai appena implementato, il che sarebbe più lento e costoso. Poiché la documentazione potrebbe non essere un compito ad alta sensibilità intellettiva, il contesto extra vale probabilmente il guadagno in efficienza di non dover rileggere i file pertinenti.
Riavvolgere Invece di Correggere
Se dovessi scegliere un'abitudine che indica una buona gestione del contesto, sarebbe il riavvolgimento.
In Claude Code, premendo due volte Esc (o eseguendo /rewind) puoi tornare a qualsiasi messaggio precedente e reimpostare il prompt da lì. I messaggi successivi a quel punto vengono rimossi dal contesto.
Il riavvolgimento è spesso l'approccio migliore per la correzione. Ad esempio, Claude legge cinque file, prova un approccio e non funziona. Il tuo istinto potrebbe essere di scrivere "non ha funzionato, prova X invece", ma la mossa migliore è riavvolgere fino a subito dopo la lettura dei file e reimpostare il prompt con ciò che hai imparato. "Non usare l'approccio A, il modulo foo non espone quello — vai direttamente a B."
Puoi anche usare "riassumi da qui" per far sì che Claude riassuma i suoi apprendimenti e crei un messaggio di passaggio di consegne, un po' come un messaggio all'iterazione precedente di Claude da parte del suo sé futuro che ha provato qualcosa e non ha funzionato.
Compattazione vs. Sessioni Nuove
Una volta che una sessione diventa lunga, hai due modi per alleggerirla: /compact o /clear (e ricominciare da capo). Sembrano simili ma si comportano in modo molto diverso.
Compact chiede al modello di riassumere la conversazione finora, quindi sostituisce la cronologia con quel riassunto. È con perdita di informazioni: ti fidi che Claude decida cosa è importante, ma non hai dovuto scrivere nulla tu stesso e Claude potrebbe essere più accurato nell'includere apprendimenti o file importanti. Puoi anche guidarlo passando istruzioni (/compact concentrati sul refactoring dell'autenticazione, salta il debug dei test).
Con /clear, *tu* scrivi ciò che è importante ("stiamo rifattorizzando il middleware di autenticazione, il vincolo è X, i file importanti sono A e B, abbiamo escluso l'approccio Y") e inizi da capo. È più lavoro, ma il contesto risultante è ciò che hai deciso essere rilevante.
Cosa Causa un Cattivo Compact?
Se esegui molte sessioni di lunga durata, potresti aver notato momenti in cui la compattazione potrebbe essere particolarmente negativa. In questo caso, abbiamo spesso scoperto che i cattivi compact possono verificarsi quando il modello non riesce a prevedere la direzione del tuo lavoro.
Ad esempio, l'autocompact si attiva dopo una lunga sessione di debug e riassume l'indagine, e il tuo messaggio successivo è "ora correggi quell'altro avviso che abbiamo visto in bar.ts."
Ma poiché la sessione era focalizzata sul debug, l'altro avviso potrebbe essere stato omesso dal riassunto.
Questo è particolarmente difficile perché, a causa del degrado del contesto, il modello è al suo punto di minore intelligenza durante la compattazione. Con un milione di contesto, hai più tempo per eseguire /compact in modo proattivo con una descrizione di ciò che vuoi fare.
Subagenti e Finestre di Contesto Nuove
I subagenti sono una forma di gestione del contesto, utili quando sai in anticipo che un blocco di lavoro produrrà molti output intermedi di cui non avrai più bisogno.
Quando Claude genera un subagente tramite lo strumento Agente, quel subagente ottiene la propria finestra di contesto nuova. Può svolgere tutto il lavoro necessario e poi sintetizzare i suoi risultati in modo che solo il rapporto finale torni al genitore.
Il test mentale che usiamo: avrò bisogno di nuovo di questo output dello strumento, o solo della conclusione?
Sebbene Claude Code chiami automaticamente i subagenti, potresti volergli dire di farlo esplicitamente. Ad esempio, potresti volergli dire di:
- "Avvia un subagente per verificare il risultato di questo lavoro in base al seguente file di specifiche"
- "Avvia un subagente per leggere questo altro codebase e riassumere come ha implementato il flusso di autenticazione, poi implementalo tu stesso allo stesso modo"
- "Avvia un subagente per scrivere la documentazione su questa funzionalità in base alle mie modifiche git"
Riepilogo
In sintesi, quando Claude ha terminato un turno e stai per inviare un nuovo messaggio, hai un punto decisionale.
Col tempo, prevediamo che Claude ti aiuterà a gestirlo da solo, ma per ora questo è uno dei modi in cui puoi guidare l'output di Claude.
