Bakit Binabalewala ng Coding Agent ang Instructions
May instruction file ka bang nagsasabing huminto pero nagpapatuloy ang agent? Alamin ang 4 na sanhi at diagnosis bago mo muling baguhin ang rule.
Bakit binabalewala ng coding agents ang iyong mga instruction
Binabalewala ng coding agents ang iyong mga instruction dahil sa apat na dahilan, at hindi kasama rito ang pagiging masyado mong magalang. Maaaring hindi kailanman napunta sa context window ang rule. Maaaring masyadong malabo ang rule para maikumpara rito ang isang action. Maaaring may ibang bahagi ng context na sumalungat dito, kadalasan ang code na kababasa pa lamang ng agent. O maaaring naka-load pa rin ang rule ngunit malayo na ito sa kasalukuyang turn, kaya ang pinagbabatayan ng agent ay ang mga bahaging malapit dito.
May sariling fix ang bawat sanhi, kaya ang unang hakbang ay paghiwalayin ang mga ito. Hindi diagnosis ang paggamit ng malalaking titik at ng salitang IMPORTANT. Gagamitin sa mga sumusunod na paliwanag ang Claude Code bilang halimbawa, dahil detalyado ang dokumentasyon nito tungkol sa loading at compaction behavior noong October 2026. Nagkakaiba ang ibang tool sa mga detalye, ngunit pareho ang pangkalahatang behavior.
Dalawang termino muna. Ang context window ay ang bloke ng text na nakikita ng model sa isang partikular na turn: system prompt, mga instruction file mo, conversation, at bawat file na nabasa ng agent. Ang harness ay ang program na nakapaligid sa model, ang program na bumabasa ng mga file mula sa disk at nagtitipon ng blokeng iyon. Halos lahat ng reklamo sa post na ito ay talagang reklamo tungkol sa harness, hindi sa model.
Ang instruction file ay mensahe, hindi setting
Ang instruction file ay hindi configuration. Walang binabasa sa runtime na CLAUDE.md at nagpapatupad nito. Binabasa ng harness ang file mula sa disk at ipinapaste ang text nito sa conversation. Sa Claude Code, ipinapadala ang content bilang user message pagkatapos ng system prompt. Ibig sabihin, nakikita ng model ang mga rule mo sa parehong paraan ng pagkakita nito sa iba pang text na tina-type mo.
May hindi komportableng resulta ito. Nakikipagkompetensiya ang mga rule mo sa bawat iba pang text sa window at pantay ang katayuan ng mga ito. Ang isang rule ay claim. Ang file na kakabukas lang ng agent ay ebidensiya. Kapag hindi nagtutugma ang dalawa, madalas na nananalo ang ebidensiya. Walang naglalabas ng error dahil sa pananaw ng model, walang naging problema.
Malinaw itong sinasabi sa official documentation: itinuturing ang instruction files bilang context, hindi bilang configuration na awtomatikong ipinapatupad. Para harangan ang isang action anuman ang desisyon ng model, hook ang kailangan, hindi isang sentence. Tandaan ang linyang iyon. Karamihan sa mga fix sa dulo ng post na ito ay aplikasyon ng linyang iyon sa isang partikular na kaso.
Anong instruction files ang nilo-load, at kailan
Umakyat si Claude Code sa directory tree mula sa directory kung saan mo ito sinimulan. Nilo-load nang buo sa pagsisimula ang bawat CLAUDE.md at CLAUDE.local.md mula sa filesystem root hanggang sa working directory mo. Pinagdudugtong ang mga ito ayon sa pagkakasunod-sunod, kaya huling binabasa ang file na pinakamalapit sa directory kung saan mo ito sinimulan. Sa loob ng isang directory, idinadagdag ang .local file pagkatapos ng pangunahing file.
Iba ang behavior ng mga file sa mga subdirectory na nasa ibaba ng working directory mo. Hindi sila nilo-load sa pagsisimula. Nilo-load sila kapag nagbasa ang agent ng file sa directory na iyon. Ganito rin ang path-scoped rules sa .claude/rules/ na may paths: frontmatter field: ipinapasok ang mga ito sa context kapag nagbasa ng tumutugmang file, hindi sa bawat turn. Simula v2.1.309, may per-file size limit din ang mga file na ganito ang pag-load (40,000 characters sa 200K context window). Start lamang ng mas mahabang file ang natatanggap ng agent, kaya maaaring hindi makarating sa context ang mga rule na nasa bandang dulo ng malaking nested file.
Ipinapaliwanag ng pagkakaibang ito ang malaking bahagi ng mga naiulat na failure. Naglagay ka ng rule sa packages/api/CLAUDE.md, nagtanong ka tungkol sa API, at sumagot ang agent nang hindi kailanman nagbukas ng file sa ilalim ng packages/api/. Hindi binalewala ang rule. Hindi ito kailanman naging bahagi ng context. Kung hinahati ng repository mo ang guidance sa mga instruction file para sa bawat package sa isang monorepo, ito ang unang dapat suriin sa bawat pagkakataon.
May isa pang loading trap sa mga repository na nag-standardize sa AGENTS.md. Simula v2.1.277, binabasa ni Claude Code ang AGENTS.md bilang project instructions bilang default, pero ginagawa lamang ito kapag walang CLAUDE.md, .claude/CLAUDE.md, o CLAUDE.local.md sa working directory mo o sa alinmang directory na nasa itaas nito (hindi kasama rito ang personal mong ~/.claude/CLAUDE.md). Magdagdag ng alinman sa mga iyon, kahit CLAUDE.local.md lamang para sa personal na notes, at sa halip ay babasahin ni Claude Code ang iyong CLAUDE.md files at tuluyang hindi isasama ang AGENTS.md. Para ma-load ang dalawa, itakda ang Project instructions sa claude-md-and-agents-md sa /config. Sa mga version bago ang v2.1.277, o kapag gusto mong panatilihin ang isang CLAUDE.md, ang tulay ay isang CLAUDE.md na ang unang linya ay @AGENTS.md. Ini-import nito ang file sa pagsisimula, at maaaring ilagay sa ilalim nito ang anumang Claude-specific notes. Gumagana rin ang symlink kapag wala ka nang kailangang idagdag. Ang pagpapasya kung ano ang dapat ilagay sa file na iyon ay hiwalay na usapin, at tinatalakay sa paghihiwalay ng agent instructions sa human documentation.
Kumpirmahin na na-load ang file bago ito muling isulat
Huwag baguhin ang wording hangga't wala kang patunay na nakikita ng agent ang file. May dalawang check, at unahin ang mas mabilis.
Patakbuhin ang /context sa loob ng session. Ipinapakita nito ang kasalukuyang window ayon sa kategorya, at inililista ng Memory files ang bawat instruction file na na-load sa pagsisimula. Kung wala ang isang file sa listahang iyon, hindi ito na-load sa pagsisimula. Kaya walang anumang isusulat mo rito ang magkakaroon ng epekto hangga't hindi ito nalo-load. Hindi lumilitaw roon ang nested file sa isang subdirectory dahil on demand itong nalo-load; kapag na-load ito, may lilitaw na Loaded line kasama ang path nito sa terminal. Inililista ng /memory ang mga lokasyon ng file at binubuksan ang mga ito para sa pag-edit, kabilang ang mga file na hindi pa umiiral.
Para sa mas tiyak na sagot, i-log ang mga load. Ang InstructionsLoaded hook event ay tumatakbo sa bawat pagpasok ng CLAUDE.md o rules file sa context, at ipinapakita ng matcher nito kung bakit naganap ang load: session_start, nested_traversal, path_glob_match, include, o compact. Ilagay ito sa .claude/settings.json:
{
"hooks": {
"InstructionsLoaded": [
{
"matcher": "nested_traversal",
"hooks": [
{
"type": "command",
"command": "cat >> /tmp/instructions-loaded.log"
}
]
}
]
}
}Tinatanggap ng hook ang payload bilang JSON sa standard input, kaya idinadagdag ng cat ang buong record. I-monitor ito gamit ang tail -f /tmp/instructions-loaded.log habang nagtatrabaho ka. Hindi pinapansin ang exit status ng event na ito, kaya maaari lamang mag-observe ang hook at hindi nito maaaring i-block ang proseso. Kung hindi kailanman lumilitaw ang nested file mo sa log sa isang session kung kailan mo inaasahang ma-load ito, itigil ang muling pagsusulat ng wording. Placement ang problema. May isang exception: hindi nagti-trigger ng event na ito ang AGENTS.md na direktang binabasa ng Claude Code, kaya hanapin na lang ang path nito sa /memory. Ang AGENTS.md na imported mula sa isang CLAUDE.md ay nagti-trigger nito gaya ng dati.
Ano ang nangyayari sa iyong mga rule kapag mahaba na ang session
Dalawang magkahiwalay na epekto ang nalalapat dito, at magkaiba ang kinakailangang tugon sa bawat isa.
Distance. Hangga’t walang nagaganap na compaction, nasa window pa rin sa turn 90 ang rule na sinabi sa turn 1. Nakikipagkumpitensya na ito sa 90 turn ng text na mas bago at mas tiyak sa kasalukuyan mong ginagawa. Kapag naganap na ang compaction, maaaring wala na sa window ang rule na itinype mo lang sa chat. Nagbabala ang sariling documentation ng Claude Code na maaaring mawala ang mga instruction mula sa unang bahagi ng conversation. Iyan ang ikalawang epekto sa ibaba. Hindi mo maiaalis ang distance sa pamamagitan ng configuration, pero masusukat mo ito. Patakbuhin ang parehong task sa bagong session. Kung nasusunod doon ang rule pero hindi na sa bandang huli ng mahabang session, distance o compaction ang sanhi.
Compaction. Kapag napuno ang window, ibinubuod ng harness ang conversation hanggang sa puntong iyon at nagpapatuloy mula sa summary na iyon. Ang nananatili ay ang itinuring na mahalaga ng summariser, na maaaring iba sa itinuturing mong mahalaga. Inilalarawan ng Claude Code ang resulta para sa bawat mechanism, at malaki ang pagkakaiba ng mga ito. Muling ini-inject mula sa disk pagkatapos ng compaction ang project root CLAUDE.md at mga unscoped rule. Muling ini-inject mula sa disk ang auto memory. Nawawala ang mga rule na may paths: frontmatter hanggang sa muling mabasa ang katugmang file. Nawawala ang nested CLAUDE.md file sa mga subdirectory hanggang sa muling mabasa ang isang file sa subdirectory na iyon.
I-rank ang iyong mga instruction ayon sa table na iyon, at lilitaw ang pagkakasunod-sunod ng kanilang fragility. Ang rule na itinype mo lang sa chat ang pinaka-fragile sa session. Mananatili lang ito kung naisama ito ng summary. Kasunod nito ang rule sa packages/api/CLAUDE.md, dahil isang beses itong na-load, naisama sa summary, at babalik lang kapag binasa muli ang file sa directory na iyon. Ang rule sa project root file ang pinakamatibay, dahil binabasa itong muli mula sa disk sa bawat pagkakataon.
Kaya kung kailangang manatili ang isang instruction sa buong session, ilagay ito sa project root file nang walang paths: frontmatter. Ang lahat ng iba pa ay tradeoff na dapat mong piliing sinasadya. Saklaw ng Pamamahala sa nananatili sa context window ang /compact gamit ang focus argument at ang /clear sa pagitan ng magkahiwalay na task. Binabago ng parehong ito kung gaano kadalas nakapagpapasya ang summariser kung ano ang mga rule mo.
Kung bakit mas nangingibabaw ang nakapaligid na code kaysa sa rule
Ito ang failure na pinakamadalas ilarawan ng mga tao at pinakamadalas ding hindi ma-diagnose. Sinasabi ng file mo na dapat dumaan sa repository layer ang database access. Sumulat ang agent ng handler na direktang tumatawag sa ORM (object relational mapper). Hindi ka binale-wala dahil sa style. Nadaig ng ebidensya ang rule mo.
Inilalarawan ng rule ang isang preference. Ipinapakita ito ng code. Kapag nagbukas ang agent ng tatlong file sa module na ie-edit nito at direktang tumatawag sa ORM ang lahat ng iyon, may isang abstract na pangungusap sa isang panig at tatlong kongkreto, bago, at angkop sa task na halimbawa sa kabilang panig. Karaniwang tamang gawi ang pagkopya sa lokal na pattern. Mali lamang ito rito dahil may alam ka na wala sa context: legacy ang mga file na iyon.
Kaya ilagay mo iyon sa rule. Nakalalampas sa aktuwal na repository ang mga rule na binabanggit ang sarili nitong counter-evidence. Hindi sapat ang mga rule na nagsasaad lamang ng isang payak na preference.
Ang bagong database access ay dapat dumaan saapp/repositories/. Direktang tumatawag sa ORM ang mga file sa ilalim ngapp/legacy/. Lumang code iyon, hindi ang pattern. Huwag itong kopyahin.
Ang ikalawang pangungusap ang gumagawa ng mahalagang trabaho. Sinasabi nito sa agent kung ano ang malapit na nitong makita at kung paano ito dapat basahin, bago pa man nito makita. Ganoon din ang dapat gawin sa anumang rule na hayagang sinasalungat ng repository: isang commit style na hindi sinusunod ng history mo, isang test layout na hindi ginagamit ng kalahati ng test suite, o isang import convention na umiiral lamang sa bagong code. Kapag hindi nagtutugma ang code at ang file, tukuyin ang hindi pagkakatugmang iyon sa file.
Hindi nasusuri ang malabong rule, kaya hindi ito masusunod
Hindi masusuri ang mga sumusunod laban sa isang partikular na action, ng agent o ng iyong sarili: “Sumulat ng malinis na code.” “Huwag mag-overengineer.” “Panatilihing simple.” “Mag-ingat sa migrations.” Kapag binigyan ang agent ng rule na hindi nito ma-check laban sa sarili nitong output, nanghuhula ito, at hinuhusgahan mo ang hula batay sa pakiramdam.
Ito ang test na dapat ilapat sa bawat linya sa file mo. Isulat ang shell command na mag-e-exit na non-zero kapag nalabag ang rule. Kung hindi mo maisulat ang command na iyon, hindi checkable ang rule. Ihambing ang mga pares na ito:
- Hindi checkable: “Panatilihing maliit ang mga function.” Checkable: “Ang function na lalampas sa 60 lines ay nangangailangan ng comment sa itaas nito na nagpapaliwanag kung bakit.”
- Hindi checkable: “I-test ang mga pagbabago mo.” Checkable: “Patakbuhin ang
npm testat i-paste ang failure count bago markahang tapos ang task.” - Hindi checkable: “Panatilihing organisado ang mga file.” Checkable: “Nasa
src/api/handlers/ang mga HTTP handler. Walang ibang inilalagay sa directory na iyon.” - Hindi checkable: “I-format nang maayos ang code.” Checkable: “Gumamit ng 2 space indentation sa mga
.tsfile.”
Ang “Huwag mag-overengineer” ang unang rule na karaniwang isinusuko ng mga tao, dahil ang tamang pag-aayos dito ay hindi mas maikling sentence kundi mas mahabang paliwanag: ang malinaw na pagtukoy sa pinakamaliit na gumaganang pagbabago ay nagbibigay sa agent ng criteria na maihahambing nito sa sarili nitong diff.
Pareho rin ang problema sa laki ng file, ngunit iba ang anyo nito. Tinutukoy ng guidance ng Claude Code ang mas mababa sa 200 lines bawat instruction file at tuwirang sinasabi na binabawasan ng mas mahahabang file ang adherence. Ang 700 line na file ay hindi mas matibay na instruction. Binubuo ito ng 700 claims na mas maraming pagkakataong magkasalungat, at ibinabawas ito sa window mo sa bawat turn, na direktang lumalabas sa paggamit mo ng token. Ang pag-istruktura ng file upang nasa ilalim ng heading na madaling i-scan ng reader ang bawat rule ay saklaw ng pagsulat ng instruction file na kayang isagawa ng agent. Mas mabuti pa, alisin ang mga bahaging naglalarawan sa halip na nag-uutos: ang directory tour na nagpapakita kung nasaan ang mga handler at model ay impormasyong maaaring hanapin ng agent kapag kailangan mula sa parsed map ng repository, sa halip na dalhin ito sa window sa bawat turn.
Paano ito i-diagnose sa loob ng sampung minuto
Patakbuhin ang mga ito ayon sa pagkakasunod-sunod. Kapag dumiretso sa huling hakbang, karaniwang nauuwi ito sa mahabang file ng mga mariing rule na hindi pa rin gumagana.
- Kumpirmahing na-load ito. Patakbuhin ang
/contextat basahin ang listahan ng Memory files, o kung nested file ito, hanapin ang linya nitongLoadedsa terminal. Kung wala ang file roon, ayusin ang lokasyon at huminto. Wala pang ibang naaangkop sa listahang ito. - Ulitin sa bagong session. Magsimula ng bagong session at ibigay ang pinakamaliit na task na dapat mag-trigger sa rule. Kung gumagana rito pero pumapalya sa mahabang session, malamang na distance o compaction ang sanhi. Kung pumapalya rin dito, ang rule mismo ang problema.
- Alisin ang nakikipag-agawan. Hilingin ang parehong pagbabago sa isang directory na ang kasalukuyang code ay sumusunod na sa rule. Kung bumalik ang compliance, natatalo ng nakapaligid na code ang iyong sentence.
- Maghanap ng conflict. Ang dalawang file na nagbibigay ng magkaibang instruction para sa parehong behaviour ay isang documented failure: maaaring pumili ang model ng isa nang arbitraryo, at hindi nito sasabihin sa iyo na ginawa nito iyon.
- Gawing nasusuri at magsagawa muli ng test. Isulat muli ang rule gamit ang konkretong path at condition. Kung malaki ang itinaas ng compliance, ang phrasing ang naging sanhi.
Isang command ang Step 4. I-grep ang bawat instruction source para sa topic, hindi lang ang file na ine-edit mo:
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/nullAng hit sa dalawang file na magkaiba ang sinasabi ay ang bug mo. Burahin ang isa. Huwag subukang ayusin ang ranggo ng mga ito gamit ang mas matibay na wording, dahil walang ranking engine na maaaring pag-apelan. Sa Claude Code v2.1.283 o mas bago, pinapatakbo ng /doctor prompt-audit ang mas malawak na bersyon ng search na ito sa iyong instruction files, rules at skills, at nag-uulat ng mga contradiction kasama ang mga iminumungkahing edit nang walang binabago hanggang sa hilingin mo.
Mga pag-aayos, ayon sa leverage
Mas malaki ang leverage ng bawat hakbang sa ibaba kaysa sa nauna rito, at mas malaki rin ang gastos sa pag-set up. Magsimula sa itaas kapag madaling baguhin ang pagkakasulat ng isang rule. Bumaba sa susunod na antas kapag sapat nang mahalaga ang rule na hindi na katanggap-tanggap ang paminsan-minsang pagkaligta rito.
- Gawing konkreto ang rule. Tukuyin ang path, command, o condition. Idagdag ang counter-evidence na makikita ng agent sa repository, gaya ng ipinakita kanina. Wala itong dagdag na gastos at nalulutas nito ang nakakagulat na dami ng kaso.
- Ilapit ito sa saklaw nito. Maaaring gumamit ng nested
CLAUDE.md, path-scoped rule sa.claude/rules/, o comment sa itaas mismo ng file. Sa ganitong paraan, nababasa ang rule kasabay ng code na saklaw nito. Tanggapin ang kapalit: anumang na-load sa ganitong paraan ay nawawala sa susunod na compaction at bumabalik sa susunod na matching read. - Ilipat ang enforcement sa isang hook. Humihiling ang prose. Nagpapasya ang hook. Tumatakbo ang mga hook bilang code sa mga nakatakdang lifecycle event at inilalapat ang mga ito anuman ang maging konklusyon ng model.
- Ipagkatiwala ang rule sa deterministic tool at burahin ang prose. Formatting, import order, line length, banned imports, at hugis ng commit message.
ruff format,prettier --write,eslint, at isangpre-commithook. Laging tama ang formatter at wala itong kinokonsumong token. Kadalasang tama ang pangungusap, pero kumokonsumo ito ng token sa bawat turn.
Buong paliwanag para sa Step 3. Ipagpalagay na hindi kailanman dapat mag-edit ang agent ng mga migration file. Ilagay ito sa .claude/settings.json:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-migrations.sh"
}
]
}
]
}
}At ilagay ito sa .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 0Patakbuhin ang chmod +x .claude/hooks/guard-migrations.sh, pagkatapos ay magsimula ng bagong session at hilingin sa agent na mag-edit ng file sa ilalim ng migrations/. Tatanggihan ang edit at ibabalik sa iyo ang mensahe bilang dahilan. Hinaharangan ng exit status 2 sa PreToolUse ang tool call bago ito tumakbo, at ipinapasa sa model ang iyong stderr text bilang blocking message. Nagre-resolve ang ${CLAUDE_PROJECT_DIR} sa project root, kaya gumagana ang hook saanmang directory naroon ang agent. Hindi kailangang sumang-ayon ng agent sa rule, tandaan ang rule, o mayroon pa ring rule sa context nito. Hindi maisasagawa ang edit.
Para sa simpleng pagbabawal na walang logic, ganoon din ang ginagawa ng permissions.deny sa iyong settings nang walang script na kailangang panatilihin, at tinutukoy ng permission modes kung ano ang tatakbo nang hindi muna nagtatanong sa iyo. Kung kailangang nasa system prompt level talaga ang isang instruction sa halip na nasa user message, inilalagay ito roon ng --append-system-prompt. Gayunman, launch flag ito na kailangang ipasa muli sa bawat bagong session, kaya mas angkop ito sa mga script kaysa sa interactive na paggamit.
Hindi mo maituturo sa prompt
Maging malinaw kung aling bahagi nito ang sakop mo. Problema ng author, at may katumbas na pag-aayos mula sa author, ang placement, phrasing, mga conflict sa pagitan ng files, at laki ng file. Model behaviour ang iba pa, at hindi ito mawawala sa mas maayos na wording.
Hindi compliance ang agreement. Maaaring kilalanin ng agent ang isang rule, ulitin ito nang tama, at labagin ito pagkalipas lamang ng dalawang tool call. Walang kapalit ang acknowledgement, at wala rin itong kakayahang hulaan ang susunod na behaviour. Huwag itong ituring na fix, at huwag itong bilangin bilang test.
May ilang persistent na habit. Kabilang dito ang pagdaragdag ng comments, pagdaragdag ng defensive error handling, pagsusulat ng closing summary, at pagpapatakbo ng halatang susunod na command. Bumabalik ang mga ito kapag may rule na nagbabawal sa kanila, ngunit mas mababa ang dalas kaysa sa zero. Maaari mong sukatin ang sarili mong rate: patakbuhin ang parehong task nang sampung beses sa magkakahiwalay na fresh session at bilangin ang mga violation. Kung kailangang zero ang bilang na iyon, kailangang alisin sa prompt ang rule. Kapag tinawag na tapos ang isang job kahit may bahagi pa itong hindi nagagawa, kapareho ito ng habit na iyon. Structural, hindi verbal, ang kailangan sa pag-aayos: pinapalitan ng unlazy skill ang pangungusap ng Depth Tree at mga gate file na kailangang ma-clear ng agent bago nito ma-claim na tapos na.
Nagiging halimbawa ang sarili mong session. Kung nilabag ng agent ang rule sa turn 12 at pinalampas mo ito, nasa context na ngayon ang violation bilang demonstration, at mas bago ito kaysa sa rule. Itama agad ang violation kapag nakita mo ito. Ang hindi naitama na violation ay nagtuturo sa natitirang bahagi ng session.
Hindi security boundary ang isang instruction file. Hinuhubog nito ang behaviour ngunit hindi nito ito ipinapatupad. Anumang mahalaga kapag hindi naisagawa, gaya ng credentials o destructive commands, ay dapat mapailalim sa permissions o hook. Ang pag-iwas na maabot ng agent ang secrets ay gumagamit ng parehong prinsipyo sa data: huwag hilingin sa agent na huwag basahin ang isang file; ayusin para hindi nito mabasa ang file.
Ito ang maikling bersyon. Patunayang na-load ang file, gawing mache-check ang rule, ilipat ito sa tabi ng bagay na pinamamahalaan nito, at kapag mahalaga pa rin ang miss rate, alisin ito sa prose. Ang rule na hindi maaaring i-ignore ng agent ay rule na hindi kailanman hiningi sa agent.
FAQ
Bakit hindi pinapansin ng Claude Code ang aking CLAUDE.md?
Tiyaking na-load muna ito bago ipalagay na hindi ito pinansin. Patakbuhin ang /context at tingnan ang listahan ng Memory files; kung wala roon ang pangalan ng file, hindi ito na-load sa pagsisimula. Ipinapadala ang mga instruction file bilang user message pagkatapos ng system prompt, at itinuturing ang mga ito bilang context sa halip na enforced configuration. Kaya walang mahigpit na garantiya ng pagsunod. Sa karamihan ng aktuwal na kaso, isa sa apat ang dahilan: nasa subdirectory ang file na hindi binasa ng agent, may dalawang file na hindi nagtutugma at arbitraryong pinili ng model ang isa, masyadong malabo ang rule para maikumpara sa isang action, o ipinapakita ng nakapaligid na code ang kabaligtaran ng sinasabi ng rule.
May nagbabago ba kapag in-edit ko ang instruction file habang nasa session?
Hindi sa kopyang nasa conversation na. Ang mga file sa itaas ng iyong working directory ay buong bina-load sa pagsisimula, kaya ang tekstong hawak ng model ay ang bersyon noong nagsimula ang session. Para makuha ang edit, magsimula ng bagong session o hilingin sa agent na basahin ang file gamit ang karaniwang file tools nito. Sa ganitong paraan, napupunta ang kasalukuyang bersyon sa conversation bilang bagong message. Pagkatapos ng compaction, muling binabasa mula sa disk ang file sa project root, kaya dumarating din ang bagong bersyon sa puntong iyon.
Aling file ang mananaig kapag hindi nagtutugma ang root CLAUDE.md at nested na file?
Wala sa mga ito ang mapagkakatiwalaang mananaig. Pinagsasama-sama sa context ang mga natuklasang file sa halip na mag-override sa isa’t isa. Inaayos ang mga ito mula sa filesystem root pababa hanggang sa iyong working directory, kaya huling binabasa ang pinakamalapit na file. Walang precedence engine na lumulutas sa mga contradiction, at sinasabi sa dokumentasyon ng Claude Code na maaaring arbitraryong lutasin ang magkakasalungat na rule. Isulat ang nested na mga file bilang mga dagdag na rule na tumutukoy sa path na saklaw ng mga ito, at burahin ang contradiction sa halip na subukang talunin ito sa precedence.
Nananatili ba ang aking mga instruction pagkatapos ng /compact?
Depende ito sa paraan ng pag-load sa mga ito. Muling ini-inject mula sa disk pagkatapos ng compaction ang project root CLAUDE.md, mga unscoped rule, at auto memory. Nawawala ang mga rule na may paths: frontmatter at ang nested na CLAUDE.md files sa mga subdirectory hanggang sa muling mabasa ang katugmang file. Nananatili lamang ang anumang itinype mo sa chat kung isinama ito ng summariser. Kung kailangang manatili ang isang rule sa buong session, ilagay ito sa project root file nang walang paths: frontmatter.
Kailan dapat maging hook ang isang rule sa halip na prose?
Kapag deterministic ang check at mas mataas ang cost ng hindi pagtukoy sa problema kaysa sa cost ng pagsulat ng maliit na script. Kasama rito ang mga restriction sa file path, mga command na kailangang patakbuhin bago ang isang commit, at mga ipinagbabawal na tool call. Ang PreToolUse hook na lumalabas na may status 2 ay tahasang nagba-block sa tool call at ipinapasa ang stderr text nito sa model bilang dahilan. Kaya gumagana ang rule kahit wala na ito sa context. Anumang kayang pagpasiyahan ng formatter o linter ay dapat ipagawa sa tool na iyon, at dapat tuluyang alisin sa instruction file.