Hvordan AI-kodningsagenter forudindlæser din kontekst, og hvornår det skyder bagud

Du åbner din editor og starter en session. Før du taster noget som helst, før markøren overhovedet falder til ro i inputfeltet, har agenten allerede læst en hel del. Den har taget sin systemprompt ind, definitionerne på hvert eneste værktøj den kan kalde, sine adfærdsinstruktioner, dit projekts CLAUDE.md (eller .cursorrules eller AGENTS.md), alle stiafgrænsede regler der gælder, og alt hvad der ligger i dens hukommelsesfil. Når du siger dit første ord, har agenten allerede en model af dig, dit projekt og hvordan den skal opføre sig.

Den naive mentale model er: du skriver, agenten svarer. Den rigtige rækkefølge er: agenten læser din kontekst, du skriver, agenten svarer. Netop i det tavse første skridt, hvor agenten læser dig, før du siger noget, afgøres en overraskende stor del af dit resultat. Og beviserne for, om den kontekst, du fodrer den med, rent faktisk hjælper, er mere ubehagelige, end de fleste af os går ud fra.

Den korte version

• AI-kodeagenter indlæser forudskrevet kontekst før din første besked: systemprompter, værktøjsdefinitioner og værktøjsspecifikke instruktionsfiler som CLAUDE.md, Cursor-regler, GitHub Copilot-instruktioner eller AGENTS.md, hvor det understøttes eller importeres. Det er ikke dig, der indleder samtalen; det gør agentens læsning.
• Den forudindlæsning æder en stor del af det brugbare kontekstvindue, før du har tastet et eneste tegn, så dit reelle arbejdsbudget er mindre, end modellens annoncerede vindue antyder.
• Det empiriske fund er den kontraintuitive del: kontekstfiler skrevet af udviklere hjælper en smule (omkring +4 % opgavesucces) til en reel pris (omkring +19 % inferensomkostning), mens kontekstfiler genereret af en LLM eller kopieret ind faktisk kan gøre resultaterne en smule værre.
• At selv-hoste din model ændrer, hvad du kan se, ikke hvad du skal do. Forudsessionsarkitekturen er den samme overalt; lokale værktøjer lader dig bare inspicere og revidere den. Disciplinen med at skrive kontekst, du virkelig forstår, forsvinder ikke.

Den naive model er forkert: Agenten læser først

Forestil dig det præcise øjeblik, hvor en Claude Code-session starter. Systemprompten går ind. Værktøjsdefinitionerne går ind. Derefter, før du har sagt noget som helst, leveres din CLAUDE.md, og den mekaniske detalje betyder noget her. Anthropics egen dokumentation siger eksplicit, at CLAUDE.md-indhold er ”leveret som en brugerbesked efter systemprompt’en,“ indlæst „i begyndelsen af hver samtale.“ Så det allerførste brugertur i transskriptet er ikke dig. Det er din fil, der taler på dine vegne, og fastsætter betingelserne, inden du ankommer.

Det, der reelt loades i det åbningsøjeblik, er en hel stak: systemprompten, værktøjsdefinitionerne, adfærdsinstruktionerne, dine projekt- og brugerkontekstfiler, alle stiafgrænsede regler der matcher de filer, der er i spil, og en hukommelsesfil, som agenten selv vedligeholder. I Claude Code løses kontekstfilerne gennem et hierarki i fire niveauer (administreret politik, dernæst bruger (~/.claude/CLAUDE.md), dernæst projekt (./CLAUDE.md), dernæst lokal (./CLAUDE.local.md)), sammenkædet i netop den rækkefølge. Automatisk hukommelse lægger sin egen del oveni: de første 200 linjer (eller 25KB) af en MEMORY.md, som agenten selv skriver og læser, loades hver eneste session.

Intet af det er gratis. Infrastrukturomkostningen (systemprompt, værktøjsdefinitioner, adfærdsinstruktioner) bruger en betydelig del af det effektive kontekstvindue, før din første besked overhovedet lander. Det er den skat, du betaler for, at agenten ved, hvordan man er en agent, og den er usynlig, medmindre du går på jagt efter den.

Der er ved at dannes et navn om disciplinen med at styre alt dette. Anthropics applied AI-team kalder det kontekstengineering: »sættet af strategier til at kuratere og vedligeholde det optimale sæt tokens (information) under LLM-inferens«. Det er et nyttigt begreb, fordi det omdefinerer filen, du skriver, fra en seddel til robotten til en arkitekturbeslutning om, hvad der optager en knap og dyr ressource.

Fire agenter, fire måder at læse dig på først

Agenterne læser dig ikke alle på samme måde. De opdeles langs to akser, der er værd at nævne: hvad indlæses ved sessionsstart (et udvalgt filhierarki, versus altid-aktive regler, versus en fuld repo-scanning), og hvor meget af det du kan inspicere, altså om mekanismen er et deterministisk artefakt, du kan revidere, eller et semantisk indeks, du bare må tro på. Det er på de to akser, at Claude Code, Cursor, GitHub Copilot og Aider for alvor skiller sig fra hinanden.

Cursors opdeling er den mest lærerige. Dens regler lever i læsbare filer, du kontrollerer, men det bygger også en semantisk indeks over hele din kodebase, vektorindlejringer der driver @codebase-søgning, og som du ikke rigtig kan inspicere. Aider sidder i den anden ende: det læser hele dit git-repository og bygger en repo-map, deterministisk og helt uden embeddings. Du kan revidere præcis, hvad der blev sendt til modellen. Samme arkitektoniske omvending, men et helt andet indblik i den. Den dybere sammenligning værktøj for værktøj har vi lavet i vores showdown mellem agentiske kodnings-CLI'er og gik direkte imod hinanden i OpenCode mod Claude Code andetsteds.

Under de værktøjsspecifikke formater er en fælles standard ved at sætte sig. AGENTS.md opstod på tværs af økosystemet af agentværktøjer (OpenAI Codex, Amp, Jules fra Google, Cursor og Factory) og bliver nu forvaltet af Agentic AI Foundation under Linux Foundation, taget i brug i over 60.000 repositories. Dermed forfremmes præ-session-kontekstfilen fra en værktøjsspecifik bekvemmelighed til et fuldgyldigt, portabelt artefakt: branchen er enig om, at »det, agenten læser, før du siger noget«, fortjener sin egen standard.

Hvad evidensen siger om, hvorvidt noget af dette hjælper

Her bryder den behagelige fortælling sammen. Et hold ved ETH Zurich (Gloaguen, Mündler, Müller, Raychev og Vechev) gennemførte en kontrolleret evaluering, “Evaluering af AGENTS.md,” af, om disse kontekstfiler på repository-niveau reelt forbedrer kodeagenternes ydeevne. På tværs af de agenter og modeller, de undersøgte, var resultatet hverken “kontekstfiler virker” eller “kontekstfiler fejler”. Det nuværende abstract siger, at kontekstfiler generelt ikke forbedrer opgaveløsningen og hæver inferensomkostningerne med over 20% i gennemsnit. I artiklens detaljerede resultater var filer skrevet af udviklere undtagelsen: de forbedrede ydeevnen med omkring 4% i gennemsnit, men øgede omkostningerne med op til 19%. Filer genereret af en LLM gik den forkerte vej og sænkede ydeevnen med omkring 3% i gennemsnit, mens omkostningerne steg med mere end 20%. Et tredje fund skærper det: agenter kalder et værktøj 1,6 til 2,5 gange oftere, når værktøjet er nævnt i en kontekstfil, hvilket hjælper eller skader helt afhængigt af, om de ekstra kald var berettigede.

Bliv lidt ved linjen om LLM-genererede filer, for det er den bærende. En fil, du ikke selv har skrevet, uanset om den er genereret af en model eller hentet fra en community-pakke med »de bedste CLAUDE.md-konfigurationer« og smidt ind i dit repo, læses af agenten som instruktioner fra en, der ikke rigtig kender din kodebase. I studiets modeller var det samlet set et minus: du betalte flere tokens for lidt dårligere resultater. Den gennemgang af Augment Code om dette rammer det godt, når det kalder det ophobede resultat »din agents kontekst er en rodeskuffe«. Hver plausibelt udseende instruktion, du skovler ind, koster noget, og dem, du ikke selv har skrevet, til en kodebase de ikke forstår, koster typisk mere, end de giver igen.

Jeg læser ikke dette som “kontekstfiler er dårlige” og heller ikke som “kontekstfiler er gode”. Det er præcis den slags alt-eller-intet-rammer, der falder fra hinanden ved berøring med data. Den snævrere læsning er denne: kontekst er infrastruktur, du designer bevidst, og en fil, du ikke selv har skrevet, til en kodebase den ikke forstår, er en omkostning frem for en gave. Forbeholdet om rækkevidde tæller også. Det her er, hvad artiklen fandt for de modeller og agenter, den testede, ikke en universel lov om ethvert LLM. Men det peger kraftigt i én retning, og det bakkes op fra leverandørsiden: Anthropics eget applied AI-team har noteret sig bevægelsen mod at indlæse kontekst “just in time” via værktøjer ved kørsel i stedet for at forudindlæse alt på forhånd, og beskriver en hybrid tilgang, der henter nogle data på forhånd og udforsker resten ved kørsel. Når den virksomhed, der udgiver CLAUDE.md, hælder mod at forudindlæse mindre, fortjener instinktet om at kopiere en kæmpe kontekstfil ind et ekstra eftersyn.

Afsnitskonklusion: forfatterskabet er det signal, der forudsiger, om kontekst betaler sig. Token-omkostningen er den samme uanset hvad; det, der ændrer udbyttet, er, om instruktionerne kom fra en, der rent faktisk kender kodebasen.

Den kontekst der fader ud: Hvorfor sessionsstarten ikke er hele historien

Forudindlæsning sætter begrænsningen. Den fastholder den ikke. Det, udviklere igen og igen løber ind i, er anden halvdel af historien: den kontekst, du omhyggeligt lagde til rette ved sessionens start, eroderer, mens sessionen kører, og det sker lydløst.

En nyttig måde at forestille sig dette på kommer fra Mem0-teamets rammesætning om, at en kontekstvinduet er RAM, ikke lager, flygtig og afgrænset, ikke et blivende sted, hvor dine instruktioner bor. Læg noget ind i starten, og det er der; kør længe nok uden at bruge det, og det falmer, ligesom en variabel, du holder op med at referere til, til sidst bliver overskrevet. Det er mekanismen bag et mønster, forskere beskriver som instruktionsforfald. En undersøgelse fra 2026 af Gamage og kolleger fandt, at udeladelseskrav er særligt skrøbelige: i én testet opsætning faldt efterlevelsen fra 73 % ved tur 5 til omkring 33 % ved tur 16. Det er et laboratoriefund, ikke en universel konstant, men det matcher, hvad mange oplever i lange sessioner.

Sessionsgrænsen er der, hvor det bliver skarpere. Udviklere i en Hacker News-diskussion rapporterer, at spawnede subagenter kan lide under problemer med kontekstoverlevering, så arbejde, der overdrages midt i en opgave, kan ankomme med mindre af forældresessionens kontekst, end du gik ud fra. Og inaktiv tid har sin egen pris: i en tråd hvor Anthropics Boris Cherny blandede sig, diskussionen handler om, hvordan en inaktiv session kan udløse en stor genopbygning efter cache-miss, hundredtusindvis af tokens, uden nogen advarsel til dig. Den røde tråd, fællesskabet bliver ved med at rapportere, er tavshed: komprimeringen kører, tidligere ræsonnement bliver beskåret, kvaliteten glider, og intet på skærmen fortæller dig, at det skete. Du bemærker bare, at outputtet blev dårligere.

Giver selv-hosting dig mere kontrol?

Kør det hele selv (Ollama plus Open WebUI, eller en agent som Aider eller Continue.dev rettet mod en lokal model), og det ærlige svar på “får jeg mere kontrol nu?” er: du får mere synlighed, ikke mere iboende kontrol. Den forskel er hele pointen.

Det, self-hosting reelt giver dig, er indsigt. Ingen samtaledata forlader din infrastruktur. Du kan læse hele systemprompten i stedet for at tage en proprietær på tro. Med et deterministisk værktøj som Aider kan du revidere præcis, hvad der gik ind i hvert modelkald: repo-map er et læsbart artefakt, ikke en semantisk black box som Cursors embedding-indeks. For enhver, der går op i reviderbarhed og reproducerbarhed, i at kunne svare på »hvad så agenten egentlig?«, er den indsigt reel, og det er ikke ingenting.

Men den arkitektoniske omvending er ligeglad med, hvor modellen kører. Uanset om du bruger en lokal model via Ollama, Claude Code mod et cloud-API eller Cursor på abonnement, læser agenten stadig sin kontekst før sessionen, inden du siger noget, og du skal stadig designe den kontekst bevidst. Disciplinen er den samme. Selv at hoste giver dig et klarere vindue ind til mekanismen; det giver dig ikke en anden mekanisme, og det fritager dig bestemt ikke fra lektionen fra ETH Zurich om, hvad der sker, når du indlæser kontekst, du ikke selv har skrevet. Så den ene forskydning, der er værd at tage med fra alt dette: hold op med at betragte kontekstfilen som en gave, du rækker agenten, og begynd at betragte den som infrastruktur med en løbende omkostning. Skriv det, du faktisk forstår om kodebasen, indlæs hellere mindre end mere, og husk, at agenten læste dig først, så den version af dig, den læste, bør være en, du kan stå inde for.

Ofte stillede spørgsmål

Læser AI-kodningsagenter dine filer, inden du skriver noget?

Ja. Ved sessionens start indlæser en AI-kodeagent sin systemprompt, sine værktøjsdefinitioner og dine kontekstfiler (CLAUDE.md, .cursorrules eller AGENTS.md) sammen med et eventuelt repo-map eller en hukommelsesfil, alt sammen før din første besked. Specifikt i Claude Code leveres CLAUDE.md som en brugerbesked lige efter systemprompten, så samtalen reelt begynder med din fil frem for med dig.

Forbedrer kontekstfiler som CLAUDE.md agentens ydeevne i virkeligheden?

Delvist, og mindre end de fleste antager. I ETH Zurichs evaluering af AGENTS.md-stilfiler, siger det nuværende abstract, at kontekstfiler generelt ikke forbedrer opgaveløsningen og øger inferensomkostningerne med over 20 % i gennemsnit. De detaljerede resultater er mere brugbare i praksis: filer skrevet af udviklere forbedrede ydelsen med omkring 4 % i gennemsnit, men øgede omkostningerne med op til 19 %, mens LLM-genererede filer sænkede ydelsen med omkring 3 % i gennemsnit og hævede omkostningerne med mere end 20 %. Den praktiske læsning: en fil, du selv har skrevet og forstår, kan hjælpe en smule; en fil, du ikke har skrevet, kan stille og roligt koste dig.

Hvor meget af kontekstvinduet bruges, inden jeg sender en besked?

En betydelig andel. Systemprompten, værktøjsdefinitionerne og adfærdsinstruktionerne indlæses før noget brugerinput, og tilsammen bruger de en mærkbar del af det effektive kontekstvindue. Dit brugbare arbejdsbudget er mindre end modellens annoncerede kontekstvindue på grund af denne faste opstartsomkostning.

Giver self-hosting af en AI-model dig mere kontrol over konteksten?

Mere indsigt, ikke mere iboende kontrol. Selv-hosting lader dig inspicere hele systemprompten, holder samtaledata på din egen infrastruktur og lader dig (med et deterministisk værktøj som Aider) revidere præcis, hvad der gik ind i hvert kald. Men arkitekturen for kontekst før sessionen er den samme som i cloud-værktøjer, og du skal stadig designe din kontekst bevidst.

Hvad er AGENTS.md?

AGENTS.md er et åbent format, der fortæller kodeagenter, hvordan de skal arbejde med en kodebase, agentens modstykke til en README. Det opstod på tværs af økosystemet af agentværktøjer (OpenAI Codex, Amp, Jules fra Google, Cursor og Factory) og varetages nu af Agentic AI Foundation under Linux Foundation. Med udbredelse i over 60.000 repositories er det ved at blive den fælles standard på tværs af værktøjer for agentkontekst før sessionen.