SSD Nodes Learn Hosting plans →
Gidsen Matt ConnorDoor Matt Connor · Bijgewerkt 2026-10-26

Waarom negeren coding agents mijn instructies?

Coding agents negeren instructies vaak door context window beperkingen of tegenstrijdige code. Ontdek hoe u de oorzaak diagnosticeert voordat u uw prompt opnieuw herschrijft.

Waarom coding agents uw instructies negeren

Coding agents negeren uw instructies om vier redenen. Geen daarvan is dat u te beleefd was. De regel stond nooit in het contextvenster. De regel was te vaag om een actie aan de hand ervan te controleren. Iets anders in de context sprak de regel tegen, meestal de code die de agent zojuist had gelezen. Of de regel is nog steeds geladen, maar staat ver terug vóór de huidige beurt. De agent werkt dan met wat zich dichtbij bevindt.

Elke oorzaak heeft een eigen oplossing. De eerste stap is daarom om de oorzaken van elkaar te onderscheiden. Hoofdletters en het woord IMPORTANT vormen geen diagnose. In het onderstaande voorbeeld wordt Claude Code gebruikt, omdat het laad- en compactiongedrag daarvan in oktober 2026 gedetailleerd is gedocumenteerd. Andere tools verschillen in de details, maar werken in grote lijnen hetzelfde.

Eerst twee termen. Het contextvenster is het tekstblok dat het model tijdens een bepaalde beurt ziet: de systeemprompt, uw instructiebestanden, het gesprek en elk bestand dat de agent heeft gelezen. De harness is het programma rond het model. Dit programma leest bestanden van schijf en stelt dat tekstblok samen. Bijna elke klacht in dit bericht gaat in werkelijkheid over de harness, niet over het model.

Uw instructiebestand is een bericht, geen instelling

Een instructiebestand is geen configuratie. Niets in de runtime leest CLAUDE.md en dwingt dit af. De harness leest het bestand van de schijf en plakt de tekst in het gesprek. In Claude Code wordt die inhoud afgeleverd als een gebruikersbericht dat na de systeemprompt wordt geplaatst, wat betekent dat het model uw regels op dezelfde manier ziet als alles wat u zelf heeft getypt.

Dit heeft een ongemakkelijk gevolg. Uw regels concurreren op gelijke voet met elk ander stuk tekst in het venster. Een regel is een bewering. Het bestand dat de agent zojuist heeft geopend, is bewijsmateriaal. Wanneer de twee met elkaar in tegenspraak zijn, wint het bewijsmateriaal vaak, en er wordt geen foutmelding gegenereerd, omdat er vanuit het perspectief van het model niets mis is gegaan.

De officiële documentatie stelt dit duidelijk: instructiebestanden worden behandeld als context, niet als afgedwongen configuratie. Om een actie te blokkeren, ongeacht wat het model beslist, heeft u een hook nodig, geen zin. Houd die lijn vast. De meeste oplossingen aan het einde van dit bericht zijn die lijn toegepast op een specifiek geval.

Welke instructiebestanden worden geladen en wanneer

Claude Code doorloopt de mappenstructuur vanaf de map waarin u het programma heeft gestart. Elk CLAUDE.md- en CLAUDE.local.md-bestand vanaf de root van het bestandssysteem tot aan uw werkmap wordt bij het opstarten volledig geladen. Deze worden in die volgorde samengevoegd, waardoor het bestand dat zich het dichtst bij uw startlocatie bevindt als laatste wordt gelezen. Binnen één map wordt het .local-bestand na het hoofdbestand toegevoegd.

Bestanden in submappen onder uw werkmap gedragen zich anders. Deze worden niet bij het opstarten geladen. Ze worden geladen wanneer de agent een bestand in die map leest. Hetzelfde geldt voor regels met een pad-scope in .claude/rules/ die een paths:-frontmatterveld bevatten: deze worden aan de context toegevoegd wanneer een overeenkomstig bestand wordt gelezen, niet bij elke beurt. Sinds v2.1.309 hebben bestanden die op deze manier worden geladen ook een limiet per bestand (40.000 tekens bij een contextvenster van 200K). De agent ontvangt alleen het begin van een langer bestand, waardoor regels aan het einde van een groot genest bestand mogelijk nooit de context bereiken.

Dat ene verschil verklaart een groot deel van de gerapporteerde fouten. U plaatst een regel in packages/api/CLAUDE.md, u stelt een vraag over de API, en de agent antwoordt zonder ooit een bestand onder packages/api/ te openen. De regel werd niet genegeerd. Hij was simpelweg nooit aanwezig. Als uw repository richtlijnen verdeelt over instructiebestanden per pakket in een monorepo, is dit het eerste wat u altijd moet controleren.

Nog een valkuil bij het laden treft repositories die zijn gestandaardiseerd op AGENTS.md. Sinds v2.1.277 leest Claude Code standaard AGENTS.md als uw projectinstructies, maar alleen wanneer er geen CLAUDE.md, .claude/CLAUDE.md of CLAUDE.local.md in uw werkmap of een bovenliggende map staat (uw persoonlijke ~/.claude/CLAUDE.md telt hierbij niet mee). Voegt u een van deze toe, zelfs een CLAUDE.local.md voor persoonlijke notities, dan leest Claude Code in plaats daarvan uw CLAUDE.md-bestanden en wordt AGENTS.md volledig overgeslagen. Om beide te laden, stelt u Project instructions in op claude-md-and-agents-md in /config. Bij versies van vóór v2.1.277, of wanneer u een CLAUDE.md wilt behouden, is de oplossing een CLAUDE.md waarvan de eerste regel @AGENTS.md is. Dit importeert het bestand bij het opstarten, met eventuele Claude-specifieke notities eronder. Een symlink werkt ook als u niets extra's toe te voegen heeft. De beslissing wat in dat bestand thuishoort is een aparte kwestie, die wordt behandeld in het scheiden van agent-instructies van menselijke documentatie.

Controleer of het bestand is geladen voordat u het herschrijft

Pas de tekst niet aan voordat u zeker weet dat de agent het bestand kan zien. Er zijn twee controles. Voer eerst de eenvoudige controle uit.

Voer /context uit binnen de sessie. De opdracht toont het huidige venster, uitgesplitst per categorie. De lijst Memory files bevat de namen van alle instructiebestanden die bij het starten zijn geladen. Een bestand dat niet in deze lijst staat, is bij het starten niet geladen. Alles wat u erin schrijft, heeft dan geen effect totdat iets het bestand laadt. Een genest bestand in een subdirectory wordt daar nooit weergegeven, omdat het op aanvraag wordt geladen. Zodra dat gebeurt, verschijnt in de terminal een regel Loaded met het pad naar het bestand. Met /memory geeft u de bestandslocaties weer en opent u deze voor bewerking, ook als ze nog niet bestaan.

Gebruik logging voor een grondiger controle. De hook-gebeurtenis InstructionsLoaded wordt geactiveerd telkens wanneer een CLAUDE.md of een regelsbestand aan de context wordt toegevoegd. De matcher geeft aan waarom het bestand is geladen: session_start, nested_traversal, path_glob_match, include of compact. Plaats het volgende in .claude/settings.json:

{
  "hooks": {
    "InstructionsLoaded": [
      {
        "matcher": "nested_traversal",
        "hooks": [
          {
            "type": "command",
            "command": "cat >> /tmp/instructions-loaded.log"
          }
        ]
      }
    ]
  }
}

De hook ontvangt de gegevens als JSON via standard input. Met cat voegt u de volledige record toe. Controleer het logbestand tijdens het werk met tail -f /tmp/instructions-loaded.log. De exitstatus van deze gebeurtenis wordt genegeerd. De hook kan dus alleen waarnemen en niets blokkeren. Verschijnt uw geneste bestand niet in dit log tijdens een sessie waarin u verwacht dat het wordt geladen, stop dan met het herschrijven van de tekst. Het probleem is de plaatsing. Er is één uitzondering: een AGENTS.md die Claude Code rechtstreeks leest, activeert deze gebeurtenis niet. Zoek het pad in plaats daarvan met /memory. Een AGENTS.md dat vanuit een CLAUDE.md wordt geïmporteerd, activeert de gebeurtenis wel zoals gebruikelijk.

Wat een lange sessie doet met uw regels

Er zijn hier twee afzonderlijke effecten van toepassing, die elk een andere aanpak vereisen.

Afstand. Totdat er een compressie (compaction) plaatsvindt, staat een regel die in beurt 1 is opgegeven nog steeds in het venster bij beurt 90. Deze concurreert nu met 90 beurten aan tekst die recenter is en specifieker voor wat u op dit moment doet. Zodra een compressie heeft plaatsgevonden, staat een regel die u alleen in de chat hebt getypt mogelijk helemaal niet meer in het venster. De documentatie van Claude Code waarschuwt dat instructies van vroeg in het gesprek verloren kunnen gaan; dit is het tweede effect hieronder. U kunt afstand niet configureren, maar u kunt het wel meten. Voer dezelfde taak uit in een nieuwe sessie. Als de regel daar wel standhoudt maar faalt diep in een lange sessie, dan zijn afstand of compressie de oorzaak.

Compressie. Wanneer het venster vol raakt, vat de harness het gesprek tot dan toe samen en gaat verder vanaf die samenvatting. Wat overblijft is wat de samenvatter belangrijk vond, wat niet hetzelfde is als wat u belangrijk vindt. Claude Code documenteert de uitkomst per mechanisme, en de verschillen zijn groot. Project root CLAUDE.md en niet-gescoped regels worden na een compressie opnieuw vanaf de schijf ingeladen. Auto memory wordt opnieuw vanaf de schijf ingeladen. Regels met paths: frontmatter gaan verloren totdat een overeenkomstig bestand opnieuw wordt gelezen. Geneste CLAUDE.md bestanden in submappen gaan verloren totdat een bestand in die submap opnieuw wordt gelezen.

Rangschik uw instructies op basis van die tabel en de volgorde van kwetsbaarheid wordt duidelijk. Een regel die u alleen in de chat hebt getypt, is het meest kwetsbaar in de sessie: deze blijft alleen behouden als de samenvatting deze toevallig heeft bewaard. Een regel in packages/api/CLAUDE.md is de volgende in de rij, omdat deze één keer werd geladen, werd weggefilterd door de samenvatting en pas terugkeert bij de volgende leesactie in die map. Een regel in het project root-bestand is het meest duurzaam, omdat deze elke keer opnieuw vanaf de schijf wordt gelezen.

Dus als een instructie voor een hele sessie moet gelden, hoort deze in het project root-bestand thuis zonder paths: frontmatter. Al het andere is een afweging die u bewust moet maken. Beheren wat in het contextvenster blijft behandelt /compact met een focus-argument en /clear tussen niet-gerelateerde taken; beide veranderen hoe vaak de samenvatter mag beslissen wat uw regels waren.

Waarom de omliggende code de regel overtreft

Dit is de fout die mensen het vaakst beschrijven en het minst vaak diagnosticeren. Uw bestand stelt dat databasetoegang via de repository-laag verloopt. De agent schrijft een handler die de ORM (object relational mapper) direct aanroept. U werd niet genegeerd op basis van stijl. U werd overstemd door bewijslast.

Een regel beschrijft een voorkeur. De code demonstreert er een. Wanneer de agent drie bestanden opent in de module die hij gaat bewerken en alle drie de ORM direct aanroepen, bevat de context aan de ene kant één abstracte zin en aan de andere kant drie concrete, recente, taakgerelateerde voorbeelden. Het kopiëren van het lokale patroon is meestal correct gedrag. Het is hier alleen fout omdat u iets weet wat de context niet weet: die bestanden zijn legacy.

Schrijf dat dus in de regel. Regels die hun eigen tegenbewijs benoemen, overleven contact met een echte repository. Regels die slechts een kale voorkeur uitspreken, doen dat niet.

Nieuwe databasetoegang verloopt via app/repositories/. Bestanden onder app/legacy/ roepen de ORM nog steeds direct aan. Dat is oude code, niet het patroon. Kopieer dit niet.

De tweede zin doet het werk. Deze vertelt de agent wat hij gaat tegenkomen en hoe hij dit moet interpreteren, nog voordat hij het vindt. Dezelfde correctie is van toepassing op elke regel die uw repository zichtbaar tegenspreekt: een commit-stijl die uw geschiedenis niet volgt, een teststructuur die de helft van uw suite negeert, een importconventie die alleen in nieuwe code standhoudt. Waar de code het oneens is met het bestand, benoem het meningsverschil in het bestand.

Een vage regel kan niet worden gecontroleerd en kan dus niet worden nageleefd

"Schrijf schone code." "Voorkom over-engineering." "Houd het simpel." "Wees voorzichtig met migraties." Geen van deze regels kan worden getoetst aan een specifieke actie, noch door de agent, noch door u. Een agent die een regel krijgt die hij niet aan zijn eigen output kan toetsen, is aan het gokken, en u beoordeelt die gok op gevoel.

Pas de volgende test toe op elke regel in uw bestand. Schrijf het shell-commando dat een non-zero exitcode zou geven wanneer de regel wordt overtreden. Als u dat commando niet kunt schrijven, is de regel niet controleerbaar. Vergelijk deze paren:

  • Niet controleerbaar: "Houd functies klein." Controleerbaar: "Een functie langer dan 60 regels moet voorzien zijn van een commentaar erboven waarin wordt uitgelegd waarom."
  • Niet controleerbaar: "Test uw wijzigingen." Controleerbaar: "Voer npm test uit en plak het aantal fouten voordat u een taak als voltooid markeert."
  • Niet controleerbaar: "Houd bestanden georganiseerd." Controleerbaar: "HTTP-handlers staan in src/api/handlers/. Niets anders mag in die map staan."
  • Niet controleerbaar: "Formatteer code correct." Controleerbaar: "Gebruik 2 spaties inspringing in .ts-bestanden."

"Voorkom over-engineering" is de regel waar mensen het snelst opgeven, omdat de oplossing geen kortere zin is, maar een langere: het expliciet benoemen wat de kleinst werkende wijziging daadwerkelijk inhoudt geeft de agent criteria waaraan hij zijn eigen diff kan toetsen.

Omvang is hetzelfde probleem in een ander jasje. De richtlijnen voor Claude Code mikken op minder dan 200 regels per instructiebestand en stellen direct dat langere bestanden de naleving verminderen. Een bestand van 700 regels is geen krachtigere instructie. Het zijn 700 regels aan beweringen met meer kans op onderlinge tegenstrijdigheden, en het wordt bij elke beurt in rekening gebracht in uw contextvenster, wat direct zichtbaar is in uw tokenverbruik. Het structureren van het bestand zodat elke regel onder een kop staat die een lezer kan scannen, wordt behandeld in het schrijven van een instructiebestand waar een agent op kan acteren. Beter nog: schrap de delen die beschrijven in plaats van instrueren. Een rondleiding door de mappenstructuur waar de handlers en modellen staan, is informatie die de agent op verzoek kan opzoeken via een geparseerde kaart van de repository, in plaats van deze bij elke beurt in het venster mee te dragen.

Diagnose in tien minuten

Voer deze stappen in volgorde uit. Het overslaan naar de laatste stap is de reden dat men eindigt met een lang bestand vol afgedwongen regels die alsnog niet werken.

  1. Bevestig het laden. Voer /context uit en lees de lijst met Memory-bestanden, of zoek voor een genest bestand naar de Loaded-regel in de terminal. Als het bestand niet aanwezig is, corrigeer dan de locatie en stop. De rest van deze lijst is dan nog niet van toepassing.
  2. Reproduceer in een nieuwe sessie. Start een nieuwe sessie en voer de kleinst mogelijke taak uit die de regel zou moeten activeren. Werkt het hier wel, maar niet in een lange sessie? Dan wijst dit op afstand of compactie. Werkt het hier ook niet? Dan is de regel zelf het probleem.
  3. Verwijder de concurrentie. Vraag om dezelfde wijziging in een map waarvan de bestaande code de regel al volgt. Als de naleving terugkeert, werd uw instructie overstemd door de omliggende code.
  4. Zoek naar een conflict. Twee bestanden die verschillende richtlijnen geven voor hetzelfde gedrag is een gedocumenteerd defect: het model kan er willekeurig een kiezen en zal u niet melden dat dit gebeurt.
  5. Maak het controleerbaar en test opnieuw. Herschrijf de regel met een concreet pad en een voorwaarde. Een grote sprong in naleving betekent dat de formulering de oorzaak was.

Stap 4 is één commando. Doorzoek elke instructiebron op het onderwerp, niet alleen het bestand dat u aan het bewerken was:

grep -rni "migration" --include="CLAUDE.md" --include="CLAUDE.local.md" --include="AGENTS.md" .
grep -rni "migration" .claude/rules/ ~/.claude/CLAUDE.md ~/.claude/rules/ 2>/dev/null

Een treffer in twee bestanden die verschillende dingen beweren, is uw bug. Verwijder er één. Probeer ze niet te rangschikken met krachtiger bewoordingen, want er is geen rangschikkingsmechanisme om op terug te vallen. Op Claude Code v2.1.283 of later voert /doctor prompt-audit een bredere versie van deze zoekopdracht uit in uw instructiebestanden, regels en vaardigheden, en rapporteert tegenstrijdigheden met voorgestelde wijzigingen zonder iets aan te passen totdat u daarom vraagt.

De oplossingen, gerangschikt naar effectiviteit

Elke onderstaande stap heeft meer effect dan de voorgaande, maar vereist ook meer configuratie. Begin bovenaan wanneer een regel eenvoudig te herformuleren is. Ga naar beneden zodra een regel zo belangrijk is dat incidentele fouten onacceptabel zijn.

  1. Maak de regel concreet. Benoem een pad, een commando of een voorwaarde. Voeg het tegenbewijs toe dat de agent in de repository zal vinden, zoals eerder getoond. Dit kost niets en lost een verrassend groot deel van de gevallen op.
  2. Plaats de regel dichter bij wat hij beheert. Een geneste CLAUDE.md, een regel met een padbereik in .claude/rules/, of een opmerking bovenaan het bestand zelf. De regel wordt dan gelezen op hetzelfde moment als de code waarop deze van toepassing is. Accepteer de afweging: alles wat op die manier wordt geladen, vervalt bij de volgende compactie en keert terug bij de volgende overeenkomstige leesactie.
  3. Verplaats handhaving naar een hook. Tekst vraagt. Een hook beslist. Hooks draaien als code tijdens vaste lifecycle-events en worden toegepast ongeacht wat het model concludeert.
  4. Geef de regel aan een deterministische tool en verwijder de tekst. Formattering, importvolgorde, regelbreedte, verboden imports, de structuur van commit-berichten. ruff format, prettier --write, eslint, een pre-commit hook. De formatter heeft altijd gelijk en kost nul tokens. De zin heeft meestal gelijk en kost bij elke beurt tokens.

Stap 3 in detail. Stel dat migratiebestanden nooit door de agent mogen worden bewerkt. Plaats dit in .claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-migrations.sh"
          }
        ]
      }
    ]
  }
}

En dit in .claude/hooks/guard-migrations.sh:

#!/usr/bin/env bash
set -euo pipefail

path=$(jq -r '.tool_input.file_path // empty')

case "$path" in
  */migrations/*)
    echo "Files under migrations/ are written by hand. Stop and ask first." >&2
    exit 2
    ;;
esac

exit 0

Voer chmod +x .claude/hooks/guard-migrations.sh uit, start daarna een nieuwe sessie en vraag de agent om een bestand onder migrations/ te bewerken. De bewerking wordt geweigerd en uw bericht komt terug als de reden. Exit status 2 in PreToolUse blokkeert de tool-aanroep voordat deze wordt uitgevoerd, en uw stderr-tekst wordt aan het model doorgegeven als het blokkerende bericht. ${CLAUDE_PROJECT_DIR} verwijst naar de project root, waardoor de hook werkt ongeacht in welke directory de agent zich bevindt. De agent hoeft het niet eens te zijn met de regel, de regel niet te onthouden en de regel niet in de context te hebben. De bewerking vindt niet plaats.

Voor een absoluut verbod zonder logica doet permissions.deny in uw instellingen hetzelfde werk zonder dat er een script onderhouden hoeft te worden, en de permissiemodi bepalen wat wordt uitgevoerd zonder het eerst aan u te vragen. Als een instructie echt op het niveau van de system prompt moet staan in plaats van in een gebruikersbericht, plaatst --append-system-prompt deze daar. Dit is echter een opstart-vlag die bij elke nieuwe sessie opnieuw moet worden meegegeven, wat beter geschikt is voor scripts dan voor interactief werk.

Wat u niet kunt afdwingen met instructies

Wees duidelijk over welk deel hiervan uw verantwoordelijkheid is. Plaatsing, formulering, conflicten tussen bestanden en bestandsgrootte zijn problemen van de auteur die door de auteur moeten worden opgelost. De rest is modelgedrag; betere bewoordingen zullen dit niet wegnemen.

Instemming is geen naleving. Een agent zal een regel erkennen, deze correct aan u herhalen en deze twee tool-aanroepen later alsnog schenden. De erkenning kost niets en voorspelt niets. Zie dit niet als een oplossing en tel het niet als een test.

Sommige gewoonten zijn hardnekkig. Het toevoegen van commentaar, het toevoegen van defensieve foutafhandeling, het schrijven van een afsluitende samenvatting, het uitvoeren van het voor de hand liggende volgende commando. Deze keren terug onder een regel die ze verbiedt, zij het in mindere mate in plaats van volledig. U kunt uw eigen foutmarge meten: voer dezelfde taak tien keer uit in nieuwe sessies en tel de overtredingen. Waar dat aantal nul moet zijn, moet de regel uit de prompt worden verwijderd. Een taak als voltooid markeren terwijl een deel nog ongedaan is, is een vergelijkbare gewoonte, en de oplossing is structureel in plaats van verbaal: de vaardigheid om niet lui te zijn vervangt de zin door een Depth Tree en gate-bestanden die de agent moet wissen voordat hij mag claimen dat het werk klaar is.

Uw eigen sessie wordt een voorbeeld. Als de agent de regel in beurt 12 schond en u liet het passeren, dan staat die overtreding nu in de context als een demonstratie, en deze is veel recenter dan de regel zelf. Corrigeer een overtreding op het moment dat u deze ziet. Een ongecorrigeerde overtreding vormt de rest van de sessie.

Een instructiebestand is geen beveiligingsgrens. Het vormt gedrag, maar dwingt het niet af. Alles waarbij een fout kostbaar is, zoals inloggegevens of destructieve commando's, hoort thuis in permissies of een hook. Geheimen buiten bereik van een agent houden past hetzelfde principe toe op data: vraag een agent niet om een bestand niet te lezen, zorg ervoor dat het bestand niet leesbaar is.

De korte versie. Bewijs dat het bestand is geladen, maak de regel controleerbaar, plaats deze naast het object waarvoor hij geldt, en wanneer het foutpercentage nog steeds van belang is, haal het dan uit de tekst. Een regel die een agent niet kan negeren, is een regel die nooit aan de agent is gevraagd.

FAQ

Waarom negeert Claude Code mijn CLAUDE.md?

Controleer eerst of het bestand is geladen voordat u ervan uitgaat dat het is genegeerd. Voer /context uit en bekijk de lijst Memory files. Een bestand dat daar niet wordt vermeld, is bij het starten niet geladen. Instructiebestanden worden na de systeemprompt als een gebruikersbericht toegevoegd. Ze worden daarom als context behandeld en niet als afgedwongen configuratie. Er is dus geen garantie op strikte naleving. In de meeste gevallen is een van vier oorzaken van toepassing: het bestand staat in een subdirectory waaruit de agent nooit heeft gelezen, twee bestanden spreken elkaar tegen en het model kiest er willekeurig één, de regel is te vaag om een actie aan te toetsen, of de omliggende code laat het tegenovergestelde van de regel zien.

Verandert het bewerken van het instructiebestand tijdens een sessie iets?

Niet voor de kopie die al in het gesprek staat. Bestanden boven uw werkdirectory worden bij het starten volledig geladen. De tekst die het model gebruikt, is dus de tekst van dat moment. Start een nieuwe sessie om een bewerking te laden. U kunt de agent ook vragen het bestand met de normale bestandsfuncties te lezen. Daarmee wordt de actuele versie als een nieuw bericht aan het gesprek toegevoegd. Na een compaction wordt het bestand in de projectroot opnieuw van schijf gelezen. Ook dan wordt de nieuwe versie geladen.

Welk bestand heeft voorrang als een CLAUDE.md in de root en een genest bestand elkaar tegenspreken?

Geen van beide, althans niet betrouwbaar. Gevonden bestanden worden samengevoegd in de context. Ze worden geordend vanaf de root van het bestandssysteem naar uw werkdirectory. Het bestand dat het dichtst bij uw werkdirectory staat, wordt dus alleen als laatste gelezen. Er is geen mechanisme voor prioriteit dat tegenstrijdigheden oplost. In de documentatie van Claude Code staat dat tegenstrijdige regels willekeurig kunnen worden opgelost. Schrijf geneste bestanden als aanvullingen en vermeld daarin het pad waarop ze van toepassing zijn. Verwijder de tegenstrijdigheid in plaats van te proberen de andere regel te overtreffen.

Overleven mijn instructies /compact?

Dat hangt ervan af hoe ze zijn geladen. De projectroot CLAUDE.md, regels zonder scope en automatisch geheugen worden na een compaction opnieuw van schijf ingevoegd. Regels met paths: frontmatter en geneste CLAUDE.md bestanden in subdirectories gaan verloren totdat een overeenkomend bestand opnieuw wordt gelezen. Alles wat u alleen in de chat hebt getypt, blijft alleen behouden als de samenvatting het toevallig heeft meegenomen. Als een regel gedurende een volledige sessie moet blijven gelden, plaatst u deze in het bestand in de projectroot, zonder paths: frontmatter.

Wanneer moet een regel een hook worden in plaats van proza?

Wanneer de controle deterministisch is en de kosten van een gemiste controle hoger zijn dan de kosten van een klein script. Beperkingen voor bestandspaden, verplichte opdrachten vóór een commit en verboden toolaanroepen vallen hieronder. Een PreToolUse hook die afsluit met status 2 blokkeert de toolaanroep direct. De hook geeft de tekst uit stderr als reden aan het model door. De regel blijft daardoor van kracht, ongeacht of deze nog ergens in de context staat. Alles wat een formatter of linter kan bepalen, moet door die tool worden beheerd. Verwijder dergelijke regels volledig uit het instructiebestand.

Was dit artikel nuttig?