Apri l'editor e avvii una sessione. Prima che tu scriva qualsiasi cosa, prima ancora che il cursore si fermi nel campo di input, l'agente ha già letto parecchio. Ha assorbito il proprio system prompt, le definizioni di ogni strumento che può chiamare, le istruzioni sul comportamento, il CLAUDE.md del tuo progetto (o .cursorrules, o AGENTS.md), tutte le regole legate a percorsi specifici che si applicano e qualsiasi cosa si trovi nel suo file di memoria. Nel momento in cui pronunci la prima parola, l'agente ha già un modello di te, del tuo progetto e di come dovrebbe comportarsi.
Il modello mentale ingenuo è: tu scrivi, l'agente risponde. La sequenza reale è: l'agente legge il tuo contesto, tu scrivi, l'agente risponde. È in quel primo passo silenzioso, con l'agente che ti legge prima che tu parli, che si decide una parte sorprendentemente grande del risultato. E le prove sul fatto che il contesto che gli dai aiuti davvero sono più scomode di quanto la maggior parte di noi immagini.
La versione breve
- Gli agenti di coding basati su IA caricano un contesto già scritto prima del tuo primo messaggio: prompt di sistema, definizioni degli strumenti e file di istruzioni specifici dello strumento come CLAUDE.md, le regole di Cursor, le istruzioni di GitHub Copilot o AGENTS.md dove è supportato o importato. Non sei tu ad avviare la conversazione: è la lettura dell'agente.
- Questo pre-caricamento divora una fetta consistente della finestra di contesto utilizzabile prima ancora che tu abbia digitato un solo carattere, quindi il tuo budget di lavoro effettivo è più piccolo di quanto suggerisca la finestra dichiarata del modello.
- Il dato empirico è la parte controintuitiva: i file di contesto scritti dagli sviluppatori aiutano un po' (circa +4% di successo sui task) a un costo reale (circa +19% di costo di inferenza), mentre i file di contesto generati da un LLM o copiati e incollati possono rendere i risultati leggermente peggiore.
- L'auto-hosting del tuo modello cambia ciò che puoi vedi, non quello che devi do. L'architettura pre-sessione è la stessa ovunque; gli strumenti locali ti permettono solo di ispezionarla e verificarla. La disciplina di scrivere contesto che capisci davvero non scompare.
Il modello ingenuo è sbagliato: l'agente legge per primo
Immagina l'istante esatto in cui parte una sessione di Claude Code. Entra il prompt di sistema. Entrano le definizioni degli strumenti. Poi, prima che tu abbia detto qualcosa, viene consegnato il tuo CLAUDE.md, e qui il dettaglio meccanico conta. La documentazione di Anthropic dice esplicitamente che Il contenuto di CLAUDE.md viene “consegnato come messaggio utente dopo il prompt di sistema,” caricato “all’inizio di ogni conversazione.” Quindi il primissimo turno dell’utente nella trascrizione non sei tu. È il tuo file, che parla a tuo nome, stabilendo le condizioni prima che tu arrivi.
Quello che si carica davvero in quel momento iniziale è un intero stack: il system prompt, le definizioni degli strumenti, le istruzioni sul comportamento, i tuoi file di contesto di progetto e utente, tutte le regole legate a percorsi che corrispondono ai file in gioco e un file di memoria che l'agente mantiene da solo. In Claude Code i file di contesto si risolvono attraverso una gerarchia a quattro livelli (policy gestita, poi utente (~/.claude/CLAUDE.md), poi progetto (./CLAUDE.md), poi locale (./CLAUDE.local.md)), concatenati in quest'ordine. La memoria automatica aggiunge la sua fetta: le prime 200 righe (o 25KB) di un MEMORY.md che l'agente scrive e legge da sé, caricato a ogni sessione.
Niente di tutto questo è gratis. Il costo infrastrutturale (prompt di sistema, definizioni degli strumenti, istruzioni comportamentali) consuma una quota significativa della finestra di contesto effettiva prima ancora che arrivi il tuo primo messaggio. È la tassa che paghi perché l'agente sappia come si fa a essere un agente, ed è invisibile a meno che tu non vada a cercarla.
Si sta formando un nome attorno alla disciplina di gestire tutto questo. Il team di IA applicata di Anthropic lo chiama ingegneria del contesto: «l'insieme delle strategie per selezionare e mantenere l'insieme ottimale di token (informazioni) durante l'inferenza di un LLM». È un termine utile perché trasforma il file che scrivi da bigliettino per il robot a decisione architetturale su cosa occupa una risorsa scarsa e costosa.
Quattro agenti, quattro modi di leggerti per primi
Gli agenti non ti leggono tutti nello stesso modo. Si dividono lungo due assi che vale la pena nominare: cosa viene caricato all'avvio della sessione (una gerarchia curata di file, rispetto a regole sempre attive o a una scansione dell'intero repository), e quanto di ciò puoi ispezionare, cioè se il meccanismo è un artefatto deterministico e verificabile oppure un indice semantico che devi prendere per buono. È su questi due assi che Claude Code, Cursor, GitHub Copilot e Aider divergono davvero.
| Strumento | Cosa si carica all'avvio della sessione | Meccanismo | Verificabilità |
|---|---|---|---|
| Claude Code | CLAUDE.md hierarchy + .claude/rules/ + memoria automatica; AGENTS.md solo se importato o con symlink | Gerarchia basata su file; le regole delimitate per percorso possono essere caricate in modo lazy; il comportamento di compattazione e rilettura varia | Elevata per i tuoi file e la memoria; il prompt di sistema rimane proprietario |
| Cursor | Regole di Progetto, Team e Utente; supporto AGENTS.md; indice del codebase per contesto semantico | File di regole leggibili più indicizzazione semantica del codice | Misto: le regole sono leggibili, ma il recupero dell'indice è meno trasparente |
| GitHub Copilot | Sull'intero repository copilot-instructions.md più specifici per percorso .instructions.md dove supportato | File di istruzioni personalizzati applicati ai flussi di lavoro Copilot | Moderato: i file sono leggibili, ma la portata dipende dalla superficie del prodotto |
| Aider | Una repo-map compatta derivata dal repository git, più file aggiunti/letti manualmente | Mappa del repository basata su simboli/grafi ottimizzata per un budget di token | Alta: la repo-map può essere ispezionata, ma è comunque una mappa selezionata, non l'intero repo verbatim |
La suddivisione di Cursor è la più istruttiva. Le sue regole vivono in file leggibili che controlli, ma costruisce anche una indice semantico dell'intera codebase, embedding vettoriali che alimentano la ricerca @codebase e che non è possibile ispezionare davvero. Aider si trova all'estremità opposta: legge l'intero repository git e costruisce un repo-map, in modo deterministico, senza alcun embedding. Puoi verificare esattamente cosa è stato passato al modello. Stessa inversione architetturale, visibilità molto diversa. Per il confronto più approfondito strumento per strumento, abbiamo raccontato il panorama delle CLI agentiche nel nostro confronto tra CLI di codifica agentica e si sono confrontati direttamente in OpenCode vs Claude Code altrove.
Sotto i formati specifici di ciascuno strumento si sta consolidando uno standard comune. AGENTS.md è nato nell'ecosistema degli strumenti per agenti (OpenAI Codex, Amp, Jules di Google, Cursor e Factory) ed è ora gestito dalla Agentic AI Foundation sotto la Linux Foundation, adottato in oltre 60.000 repository. È il file di contesto pre-sessione che viene promosso da comodità legata al singolo strumento ad artefatto portabile di prima classe: il settore concorda sul fatto che «ciò che l'agente legge prima che tu parli» meriti uno standard proprio.
Cosa dicono le prove su se tutto questo aiuta
Qui si rompe la storia confortante. Un team dell'ETH Zurich (Gloaguen, Mündler, Müller, Raychev e Vechev) ha condotto una valutazione controllata, “Valutare AGENTS.md,” per capire se questi file di contesto a livello di repository migliorino davvero le prestazioni degli agenti di coding. Su tutti gli agenti e i modelli studiati, il risultato non è stato “i file di contesto funzionano” né “i file di contesto falliscono”. L'abstract attuale dice che i file di contesto in genere non migliorano il successo dei task e aumentano il costo di inferenza di oltre il 20% in media. Nei risultati dettagliati dell'articolo i file scritti dagli sviluppatori sono stati l'eccezione: hanno migliorato le prestazioni di circa il 4% in media, ma hanno aumentato il costo fino al 19%. I file generati da un LLM sono andati nella direzione sbagliata, riducendo le prestazioni di circa il 3% in media e alzando il costo di oltre il 20%. Un terzo risultato lo mette a fuoco: gli agenti chiamano uno strumento 1,6-2,5 volte più spesso quando quello strumento è nominato in un file di contesto, cosa che aiuta o danneggia interamente a seconda che quelle chiamate in più fossero giustificate.
Fermati un attimo sulla riga dei file generati da un LLM, perché è quella portante. Un file che non hai scritto tu, sia stato generato da un modello o scaricato da un pacchetto della community con «le migliori configurazioni CLAUDE.md» e lasciato cadere nel tuo repository, all'agente suona come istruzioni di qualcuno che la tua codebase non la conosce davvero. Nei modelli dello studio il saldo era negativo: pagavi più token per risultati leggermente peggiori. Il articolo su Augment Code su questo lo cattura bene quando definisce il risultato accumulato «il cassetto del ciarpame del contesto del tuo agente». Ogni istruzione dall'aria plausibile che ci butti dentro ha un costo, e quelle che non hai scritto tu, per una base di codice che non conoscono, di solito costano più di quanto rendano.
Non lo leggo come “i file di contesto fanno male” né come “i file di contesto fanno bene”. Sono esattamente le inquadrature tutto-o-niente che si sgretolano al contatto con i dati. La lettura più stretta è questa: il contesto è infrastruttura che progetti in modo deliberato, e un file che non hai scritto, per una codebase che non capisce, è un costo e non un regalo. Conta anche la riserva sull'ambito. Questo è ciò che l'articolo ha trovato per i modelli e gli agenti che ha testato, non una legge universale su ogni LLM. Ma punta con decisione in una direzione, ed è confermato dal lato del fornitore: il team di AI applicata di Anthropic ha segnalato lo spostamento verso il caricamento del contesto “just in time” tramite strumenti a runtime invece di precaricare tutto in anticipo, e descrive un approccio ibrido che recupera alcuni dati in anticipo ed esplora il resto a runtime. Quando l'azienda che pubblica CLAUDE.md tende a precaricare meno, l'istinto di incollare un file di contesto gigantesco merita un secondo sguardo.
In sintesi della sezione: la paternità del file è il segnale che predice se il contesto ripaga. Il costo in token è lo stesso in ogni caso; ciò che cambia il ritorno è se le istruzioni vengono da qualcuno che conosce davvero il codice.
Il contesto che svanisce: perché l'inizio della sessione non è tutta la storia
Il precaricamento fissa il vincolo. Non lo mantiene. Ciò contro cui gli sviluppatori continuano a sbattere è la seconda metà della storia: il contesto che hai sistemato con cura all'inizio della sessione si erode mentre la sessione va avanti, e lo fa in silenzio.
Un modo utile per immaginare questo viene dall'inquadramento del team di Mem0, secondo cui un la finestra di contesto è RAM, non archiviazione, effimera e limitata, non un luogo permanente in cui vivono le tue istruzioni. Carica qualcosa all'inizio ed è presente; vai avanti abbastanza a lungo senza usarlo e sbiadisce, come una variabile che smetti di referenziare e che prima o poi viene sovrascritta. È il meccanismo dietro un fenomeno che i ricercatori descrivono come decadimento delle istruzioni. Uno studio del 2026 di Gamage e colleghi ha rilevato che i vincoli di omissione sono particolarmente fragili: in un contesto testato, il rispetto delle istruzioni è sceso dal 73% al turno 5 a circa il 33% al turno 16. È un risultato di laboratorio, non una costante universale, ma coincide con ciò che molti avvertono nelle sessioni lunghe.
Il confine della sessione è dove le cose diventano più nitide. Sviluppatori in una discussione su Hacker News segnalano che i subagent generati possono soffrire di problemi di passaggio del contesto, quindi il lavoro delegato a metà attività può arrivare con meno contesto della sessione principale di quanto immaginassi. E anche il tempo di inattività ha un suo costo: in un thread in cui Boris Cherny di Anthropic è intervenuto, la discussione racconta come una sessione inattiva possa innescare una grossa ricostruzione dopo un cache-miss, centinaia di migliaia di token, senza alcun avviso per te. Il filo conduttore che la community continua a segnalare è il silenzio: la compattazione parte, il ragionamento precedente viene tagliato, la qualità cala e sullo schermo nulla ti dice che è successo. Ti accorgi soltanto che l'output è peggiorato.
Il self-hosting ti dà più controllo?
Esegui tutto da solo (Ollama più Open WebUI, oppure un agente come Aider o Continue.dev puntato su un modello locale) e la risposta onesta a “ora ho più controllo?” è: ottieni più visibilità, non un maggiore controllo intrinseco. Quella distinzione è tutto il punto.
Ciò che l'auto-hosting ti dà davvero è la possibilità di ispezionare. Nessun dato delle conversazioni lascia la tua infrastruttura. Puoi leggere il system prompt per intero invece di accettarne uno proprietario sulla fiducia. Con uno strumento deterministico come Aider puoi verificare esattamente che cosa è finito in ogni chiamata al modello: la repo-map è un artefatto leggibile, non una scatola nera semantica come l'indice di embedding di Cursor. Per chi tiene alla verificabilità e alla riproducibilità, a poter rispondere alla domanda «che cosa ha visto davvero l'agente?», quella ispezionabilità è reale e non è affatto poco.
Ma all'inversione architetturale non importa dove gira il modello. Che tu stia usando un modello locale tramite Ollama, Claude Code su un'API cloud o Cursor in abbonamento, l'agente legge comunque il suo contesto pre-sessione prima che tu parli, e tocca comunque a te progettare quel contesto in modo deliberato. La disciplina è identica. Ospitare in proprio ti dà una finestra più limpida sul meccanismo; non ti dà un meccanismo diverso, e di sicuro non ti esonera dalla lezione di ETH Zurich su cosa succede quando carichi contesto che non hai scritto. Quindi l'unico spostamento che vale la pena portarsi via da tutto questo: smetti di trattare il file di contesto come un regalo che consegni all'agente e inizia a trattarlo come infrastruttura con un costo di esercizio. Scrivi quello che capisci davvero della codebase, carica meno anziché di più, e ricorda che l'agente ha letto te per primo, quindi la versione di te che ha letto dovrebbe essere una di cui vai fiero.
Domande frequenti
Gli agenti di codifica AI leggono i tuoi file prima che tu digiti qualcosa?
Sì. All'avvio della sessione, un agente di coding basato su IA carica il proprio prompt di sistema, le definizioni degli strumenti e i tuoi file di contesto (CLAUDE.md, .cursorrules o AGENTS.md), insieme a eventuali repo-map o file di memoria, il tutto prima del tuo primo messaggio. In Claude Code nello specifico, il CLAUDE.md viene consegnato come messaggio utente subito dopo il prompt di sistema, quindi la conversazione di fatto inizia con il tuo file e non con te.
I file di contesto come CLAUDE.md migliorano davvero le prestazioni dell'agente?
In parte, e meno di quanto la maggior parte delle persone supponga. Nel Valutazione di ETH Zurich dei file in stile AGENTS.md, l'abstract attuale afferma che i file di contesto in genere non migliorano la riuscita dei compiti e aumentano il costo di inferenza di oltre il 20% in media. I risultati dettagliati sono più utili a chi lavora sul campo: i file forniti dagli sviluppatori hanno migliorato le prestazioni di circa il 4% in media, ma hanno aumentato il costo fino al 19%, mentre i file generati da un LLM hanno ridotto le prestazioni di circa il 3% in media e alzato il costo di oltre il 20%. La lettura pratica: un file che hai scritto e che capisci può aiutare un po'; un file che non hai scritto può costarti in silenzio.
Quanto della finestra di contesto viene utilizzato prima che io invii un messaggio?
Una quota significativa. Il prompt di sistema, le definizioni degli strumenti e le istruzioni comportamentali si caricano prima di qualsiasi input dell'utente e insieme consumano una porzione rilevante della finestra di contesto effettiva. Il tuo budget di lavoro utilizzabile è più piccolo della finestra di contesto dichiarata dal modello proprio per questo costo fisso di avvio.
Il self-hosting di un modello AI ti dà più controllo sul contesto?
Più visibilità, non più controllo intrinseco. L'autogestione ti permette di ispezionare l'intero prompt di sistema, tiene i dati delle conversazioni sulla tua infrastruttura e (con uno strumento deterministico come Aider) ti consente di verificare esattamente cosa è finito in ogni chiamata. Ma l'architettura del contesto pre-sessione è la stessa degli strumenti cloud, e devi comunque progettare il tuo contesto in modo deliberato.
Cos'è AGENTS.md?
AGENTS.md è un formato aperto per dire agli agenti di coding come lavorare con una base di codice, la controparte rivolta all'agente di un README. È nato nell'ecosistema degli strumenti per agenti (OpenAI Codex, Amp, Jules di Google, Cursor e Factory) ed è ora curato dalla Agentic AI Foundation sotto la Linux Foundation, con adozione in oltre 60.000 repository: è lo standard tra strumenti che sta emergendo per il contesto dell'agente prima della sessione.
