Coding agents మీ సూచనలను ఎందుకు పట్టించుకోవు?
Instruction file లో stop అని ఉన్నా agent కొనసాగిస్తే, కారణం context లోకి రాకపోవడం, అస్పష్టత, విరుద్ధమైన code లేదా పాత context కావచ్చు. మళ్లీ rule రాయడానికి ముందు ఈ diagnosis చేయండి.
కోడింగ్ agents మీ సూచనలను ఎందుకు పట్టించుకోవు
కోడింగ్ agents మీ సూచనలను పట్టించుకోకపోవడానికి నాలుగు కారణాలు ఉన్నాయి. వాటిలో మీరు చాలా మర్యాదగా వ్యవహరించారనేది ఒక్కటైనా కాదు. ఆ నియమం context window లో ఎప్పుడూ ఉండకపోవచ్చు. లేదా ఒక చర్యతో పోల్చి పరిశీలించడానికి ఆ నియమం చాలా అస్పష్టంగా ఉండవచ్చు. Context లోని మరేదైనా విషయం దానికి విరుద్ధంగా ఉండవచ్చు. సాధారణంగా agent ఇప్పుడే చదివిన code ఇందుకు కారణమవుతుంది. లేదా ఆ నియమం ఇంకా లోడ్ అయి ఉండొచ్చు, కానీ ప్రస్తుత turn కు చాలా వెనుక ఉండొచ్చు. అప్పుడు agent సమీపంలో ఉన్న విషయాల ఆధారంగా పని చేస్తుంది.
ప్రతి కారణానికి ప్రత్యేక పరిష్కారం ఉంటుంది. అందువల్ల వాటిని వేరు చేయడం మొదటి పని. CAPITAL LETTERS మరియు IMPORTANT అనే పదం ఉపయోగించడం diagnosis కాదు. క్రింద వివరించిన విధానంలో Claude Code ను ఉదాహరణగా ఉపయోగిస్తున్నాం. ఎందుకంటే October 2026 నాటికి దాని loading మరియు compaction ప్రవర్తన గురించి సమగ్ర documentation ఉంది. ఇతర tools లో వివరాలు మారవచ్చు. అయితే విస్తృతంగా వాటి ప్రవర్తన ఇదే విధంగా ఉంటుంది.
ముందుగా రెండు terms. context window అంటే ఒక turn లో model చూసే text block. ఇందులో system prompt, మీ instruction files, conversation మరియు agent చదివిన ప్రతి file ఉంటాయి. harness అంటే model చుట్టూ పనిచేసే program. ఇది disk నుంచి files చదివి ఆ block ను assemble చేస్తుంది. ఈ post లోని దాదాపు ప్రతి ఫిర్యాదు వాస్తవానికి model గురించి కాదు, harness గురించి ఉంటుంది.
మీ instruction file ఒక message, setting కాదు
Instruction file configuration కాదు. Runtime లో ఏదీ CLAUDE.md ను చదివి అమలు చేయదు. Harness disk నుంచి ఆ file ను చదివి, దాని text ను conversation లో paste చేస్తుంది. Claude Code లో ఆ content system prompt తర్వాత ఉంచిన user message గా పంపబడుతుంది. అందువల్ల model మీరు టైప్ చేసిన ఇతర విషయాలను చూసినట్టే మీ rules ను కూడా చూస్తుంది.
దీనికి ఒక అసౌకర్యకరమైన పరిణామం ఉంది. Window లోని ప్రతి ఇతర text తో మీ rules సమాన స్థాయిలో పోటీ పడతాయి. Rule అనేది ఒక claim. Agent ఇప్పుడే తెరిచిన file evidence. ఈ రెండింటి మధ్య విభేదం వచ్చినప్పుడు evidence తరచుగా గెలుస్తుంది. Model దృష్టిలో ఏ తప్పూ జరగలేదు కాబట్టి ఎటువంటి error కూడా కనిపించదు.
Official documentation దీన్ని స్పష్టంగా చెబుతుంది: instruction files ను enforced configuration గా కాకుండా context గా పరిగణిస్తారు. Model ఏ నిర్ణయం తీసుకున్నా ఒక action ను నిరోధించాలంటే sentence కాదు, hook అవసరం. ఆ పంక్తిని గుర్తుంచుకోండి. ఈ post చివరలో ఉన్న చాలా fixes, నిర్దిష్ట సందర్భానికి వర్తింపజేసిన అదే పంక్తి.
ఏ instruction files లోడ్ అవుతాయి, ఎప్పుడు
Claude Code మీరు దాన్ని ప్రారంభించిన directory నుంచి directory tree లో పైకి వెళ్తుంది. Filesystem root నుంచి మీ working directory వరకు ఉన్న ప్రతి CLAUDE.md మరియు CLAUDE.local.md launch సమయంలో పూర్తిగా లోడ్ అవుతుంది. అవి అదే క్రమంలో concatenate అవుతాయి. అందువల్ల మీరు Claude Code ను ప్రారంభించిన స్థానానికి అత్యంత సమీపంలోని file చివరగా చదవబడుతుంది. ఒకే directory లో .local file ప్రధాన file తర్వాత జతచేయబడుతుంది.
మీ working directory కి క్రింద ఉన్న subdirectories లోని files భిన్నంగా పనిచేస్తాయి. అవి launch సమయంలో లోడ్ కావు. Agent ఆ directory లోని file ను చదివినప్పుడు అవి లోడ్ అవుతాయి. .claude/rules/ లోని path scoped rules కు paths: frontmatter field ఉన్నా ఇదే విధంగా ఉంటుంది. Matching file చదివినప్పుడు అవి context లోకి వస్తాయి; ప్రతి turn లో కాదు. v2.1.309 నుంచి ఈ విధంగా లోడ్ అయ్యే files కు ఒక్కో file పరిమాణ పరిమితి కూడా ఉంది. 200K context window లో ఇది 40,000 characters. పొడవైన file ఉంటే agent దాని ప్రారంభ భాగాన్ని మాత్రమే పొందుతుంది. అందువల్ల పెద్ద nested file చివరలో ఉన్న rules context కు చేరకపోవచ్చు.
Reported failures లో పెద్ద భాగానికి ఈ ఒక్క తేడానే కారణం. మీరు ఒక rule ను packages/api/CLAUDE.md లో ఉంచి, API గురించి ప్రశ్న అడిగితే, agent packages/api/ కింద ఉన్న file ను ఎప్పుడూ తెరవకుండానే సమాధానం ఇవ్వవచ్చు. ఆ rule ను అది విస్మరించలేదు. ఆ rule అసలు context లోకి రాలేదు. మీ repository లో guidance ను monorepo లో package వారీ instruction files మధ్య విభజించి ఉంటే, ప్రతిసారీ ముందుగా పరిశీలించాల్సిన విషయం ఇదే.
AGENTS.md పై standardize చేసిన repositories ను మరో loading trap ప్రభావితం చేస్తుంది. v2.1.277 నుంచి మీ working directory లో లేదా దాని పైన ఉన్న ఏ directory లోనూ CLAUDE.md, .claude/CLAUDE.md లేదా CLAUDE.local.md లేనప్పుడు మాత్రమే Claude Code AGENTS.md ను project instructions గా default గా చదువుతుంది. మీ వ్యక్తిగత ~/.claude/CLAUDE.md ఇందులో పరిగణించబడదు. వీటిలో ఏదైనా ఒకదాన్ని జోడించినా, personal notes కోసం CLAUDE.local.md జోడించినా, Claude Code బదులుగా మీ CLAUDE.md files ను చదువుతుంది. AGENTS.md పూర్తిగా పక్కనపెట్టబడుతుంది. రెండింటినీ లోడ్ చేయాలంటే /config లో Project instructions ను claude-md-and-agents-md కు సెట్ చేయండి. v2.1.277 కంటే ముందు versions లో, లేదా మీరు CLAUDE.md ను ఉంచాలనుకున్నప్పుడు, bridge గా CLAUDE.md ను ఉపయోగించవచ్చు. దాని మొదటి line @AGENTS.md గా ఉండాలి. ఇది launch సమయంలో ఆ file ను import చేస్తుంది; దాని కింద Claude-specific notes ను ఉంచవచ్చు. అదనంగా ఏమీ జోడించాల్సిన అవసరం లేకపోతే symlink కూడా పనిచేస్తుంది. ఆ file లో మొదటగా ఏ విషయాలు ఉండాలో నిర్ణయించడం వేరే ప్రశ్న. అది agent instructions ను human documentation నుంచి వేరు చేయడం లో వివరించబడింది.
ఫైల్ను తిరిగి రాయడానికి ముందు అది load అయిందని నిర్ధారించండి
Agent కు ఫైల్ కనిపిస్తోందని నిర్ధారించే ఆధారం లభించే వరకు wording ను మార్చవద్దు. దీనికి రెండు తనిఖీలు ఉన్నాయి. ముందుగా సులభమైన తనిఖీ చేయండి.
Session లో /context అమలు చేయండి. ఇది ప్రస్తుత window ను categoryల వారీగా చూపిస్తుంది. Launch సమయంలో load అయిన ప్రతి instruction file పేరును Memory files జాబితా చూపిస్తుంది. ఆ జాబితాలో ఫైల్ కనిపించకపోతే, అది launch సమయంలో load కాలేదు. కాబట్టి ఏదైనా దాన్ని load చేసే వరకు, అందులో మీరు రాసేది ఏదీ ప్రభావం చూపదు. Subdirectory లోని nested file ఆ జాబితాలో కనిపించదు, ఎందుకంటే అది అవసరమైనప్పుడు load అవుతుంది. అది load అయినప్పుడు, దాని path తో కూడిన Loaded line terminal లో కనిపిస్తుంది. /memory ఫైల్ స్థానాలను జాబితా చేసి, ఇంకా ఉనికిలో లేని ఫైళ్లను కూడా editing కోసం తెరుస్తుంది.
మరింత ఖచ్చితమైన నిర్ధారణ కోసం loads ను log చేయండి. ప్రతి సారి CLAUDE.md లేదా rules file context లోకి వచ్చినప్పుడు InstructionsLoaded hook event పనిచేస్తుంది. Load ఎందుకు జరిగిందో దాని matcher చూపిస్తుంది: session_start, nested_traversal, path_glob_match, include లేదా compact. దీన్ని .claude/settings.json లో ఉంచండి:
{
"hooks": {
"InstructionsLoaded": [
{
"matcher": "nested_traversal",
"hooks": [
{
"type": "command",
"command": "cat >> /tmp/instructions-loaded.log"
}
]
}
]
}
}Hook తన payload ను standard input పై JSONగా స్వీకరిస్తుంది. అందువల్ల cat మొత్తం record ను append చేస్తుంది. మీరు పని చేస్తున్నప్పుడు tail -f /tmp/instructions-loaded.log తో దాన్ని monitor చేయండి. ఈ event యొక్క exit status ను పరిగణనలోకి తీసుకోరు. కాబట్టి hook కేవలం పరిశీలించగలదు, అడ్డుకోలదు. Nested file కనిపించాల్సిన session సమయంలో ఆ log లో కనిపించకపోతే, wording మార్చడం ఆపండి. సమస్య file placement లో ఉంది. ఒక మినహాయింపు ఉంది: Claude Code నేరుగా చదివే AGENTS.md ఈ event ను trigger చేయదు. అందువల్ల దాని path కోసం /memory లో చూడండి. CLAUDE.md నుంచి imported అయిన AGENTS.md మాత్రం సాధారణంగానే ఈ event ను trigger చేస్తుంది.
దీర్ఘమైన session మీ నియమాలను ఎలా ప్రభావితం చేస్తుంది
ఇక్కడ రెండు వేర్వేరు ప్రభావాలు ఉన్నాయి. వాటికి వేర్వేరు పరిష్కారాలు అవసరం.
దూరం. Compaction జరిగే వరకు, turn 1లో పేర్కొన్న నియమం turn 90లో కూడా context windowలో ఉంటుంది. అయితే అప్పటికి అది, మీరు ప్రస్తుతం చేస్తున్న పనికి మరింత ఇటీవలి మరియు నిర్దిష్టమైన 90 turns వచనంతో పోటీ పడుతుంది. Compaction జరిగిన తర్వాత, మీరు chatలో మాత్రమే టైప్ చేసిన నియమం windowలో అసలు ఉండకపోవచ్చు. Claude Code documentation ప్రకారం, conversation ప్రారంభంలో ఇచ్చిన instructions కోల్పోవచ్చు. ఇదే కింద వివరించే రెండవ ప్రభావం. దూరాన్ని configuration ద్వారా తొలగించలేరు, కానీ దాన్ని కొలవవచ్చు. అదే task ను కొత్త sessionలో అమలు చేయండి. అక్కడ నియమం పనిచేసి, దీర్ఘమైన sessionలో చాలా లోతుగా వెళ్లిన తర్వాత విఫలమైతే, కారణం distance లేదా compaction అని అర్థం.
Compaction. Window నిండినప్పుడు, harness అప్పటివరకు జరిగిన conversation ను summarise చేసి, ఆ summary నుంచి కొనసాగుతుంది. Summaryలో మిగిలేది summariser ముఖ్యమని భావించిన అంశాలు. మీరు ముఖ్యమని భావించిన అంశాలతో అవి తప్పనిసరిగా ఒకేలా ఉండవు. Claude Code ప్రతి mechanism కు సంబంధించిన ఫలితాన్ని documentationలో వివరిస్తుంది. వాటి మధ్య తేడాలు గణనీయంగా ఉంటాయి. Project root CLAUDE.md మరియు unscoped rules compaction తర్వాత disk నుంచి మళ్లీ inject అవుతాయి. Auto memory disk నుంచి మళ్లీ inject అవుతుంది. paths: frontmatter ఉన్న rules, matching file మళ్లీ చదివే వరకు కోల్పోతాయి. Subdirectoriesలోని nested CLAUDE.md files, ఆ subdirectoryలోని file మళ్లీ చదివే వరకు కోల్పోతాయి.
ఆ పట్టిక ఆధారంగా మీ instructions కు ప్రాధాన్యత క్రమాన్ని నిర్ణయిస్తే fragility క్రమం స్పష్టమవుతుంది. మీరు chatలో మాత్రమే టైప్ చేసిన rule sessionలో అత్యంత సున్నితమైనది. Summary దాన్ని ఉంచితే మాత్రమే అది కొనసాగుతుంది. packages/api/CLAUDE.md లోని rule తరువాతి స్థాయిలో ఉంటుంది. అది ఒకసారి load అవుతుంది, summaryలో తొలగిపోవచ్చు, ఆ directoryలో తదుపరి read జరిగినప్పుడు మాత్రమే తిరిగి వస్తుంది. Project root fileలోని rule అత్యంత స్థిరమైనది, ఎందుకంటే అది ప్రతి సారి disk నుంచి మళ్లీ చదవబడుతుంది.
కాబట్టి ఒక instruction మొత్తం sessionలో తప్పనిసరిగా అమలులో ఉండాలంటే, అది paths: frontmatter లేకుండా project root fileలో ఉండాలి. మిగతావి మీరు ఉద్దేశపూర్వకంగా ఎంచుకోవాల్సిన tradeoffలు. context windowలో ఏవి నిలిచి ఉండాలో నిర్వహించడం అనే విభాగంలో focus argumentతో /compact, అలాగే సంబంధంలేని tasks మధ్య /clear గురించి వివరిస్తుంది. ఇవి రెండూ summariser మీ rules ఏమిటో నిర్ణయించే అవకాశాన్ని ఎంత తరచుగా పొందుతుందో మార్చుతాయి.
పరిసర కోడ్ నియమాన్ని మించేది ఎందుకు
ఇది చాలామంది తరచుగా వివరించే, కానీ చాలా అరుదుగా సరిగ్గా నిర్ధారించే వైఫల్యం. మీ ఫైల్ ప్రకారం database access repository layer ద్వారా జరగాలి. కానీ agent ORM (object relational mapper) ను నేరుగా పిలిచే handler ను రాస్తుంది. ఇది style కారణంగా మీ సూచనను విస్మరించడం కాదు. ఆధారాల పరంగా మీ సూచనకు మద్దతు లేకపోవడం వల్ల agent వేరే నిర్ణయం తీసుకుంది.
ఒక rule ఒక ప్రాధాన్యతను వివరిస్తుంది. కోడ్ ఒక అమలైన ఉదాహరణను చూపిస్తుంది. Agent మార్చబోయే module లోని మూడు ఫైళ్లను తెరిచినప్పుడు, ఆ మూడింటిలోనూ ORM ను నేరుగా పిలుస్తూ ఉంటే, context లో ఒక వైపు ఒక abstract వాక్యం, మరో వైపు మూడు concrete, ఇటీవలి, ప్రస్తుత task కు సరిపోయే ఉదాహరణలు ఉంటాయి. స్థానిక pattern ను అనుసరించడం సాధారణంగా సరైన ప్రవర్తనే. అయితే ఇక్కడ అది తప్పు, ఎందుకంటే context కు తెలియని విషయం మీకు తెలుసు: ఆ ఫైళ్లు legacy code.
కాబట్టి ఆ విషయాన్ని rule లోనే రాయండి. తమకు విరుద్ధంగా కనిపించే ఆధారాలను స్వయంగా పేర్కొనే rules నిజమైన repository లోనూ సమర్థంగా పనిచేస్తాయి. కేవలం ఒక preference ను పేర్కొనే rules అలా పనిచేయవు.
New database access goes throughapp/repositories/. Files underapp/legacy/still call the ORM directly. That is old code, not the pattern. Do not copy it.
రెండవ వాక్యమే ప్రధాన పని చేస్తుంది. Agent ఆ కోడ్ను చూసే ముందే, తాను ఏమి చూడబోతోందో మరియు దాన్ని ఎలా అర్థం చేసుకోవాలో ఆ వాక్యం చెబుతుంది. Repository స్పష్టంగా విరుద్ధంగా చూపించే ఏ rule కైనా ఇదే సవరణ వర్తిస్తుంది: మీ history అనుసరించని commit style, మీ test suite లో సగం పాటించని test layout, కొత్త code లో మాత్రమే కనిపించే import convention. Code మరియు file ఒకదానితో ఒకటి విభేదించే ప్రతి చోట, ఆ విభేదాన్ని file లోనే పేర్కొనండి.
అస్పష్టమైన నియమాన్ని తనిఖీ చేయలేము. కాబట్టి దాన్ని అనుసరించలేము
"శుభ్రమైన కోడ్ రాయండి." "అవసరానికి మించి రూపకల్పన చేయవద్దు." "సరళంగా ఉంచండి." "Migrations విషయంలో జాగ్రత్తగా ఉండండి." వీటిలో ఏదీ agent లేదా మీరు ఒక నిర్దిష్ట చర్యతో పోల్చి పరీక్షించలేరు. తన స్వంత output తో పోల్చి తనిఖీ చేయలేని నియమాన్ని agent కు ఇస్తే, అది కేవలం ఊహిస్తుంది. మీరు కూడా ఆ ఊహను స్పష్టమైన ప్రమాణం లేకుండా అంచనా వేస్తారు.
మీ ఫైల్లోని ప్రతి పంక్తికి ఈ పరీక్షను వర్తింపజేయండి. ఆ నియమం ఉల్లంఘించినప్పుడు non-zero తో ముగిసే shell command ను రాయండి. ఆ command ను రాయలేకపోతే, ఆ నియమాన్ని తనిఖీ చేయలేరు. ఈ జంటలను పోల్చండి:
- తనిఖీ చేయలేనిది: "Functions ను చిన్నగా ఉంచండి." తనిఖీ చేయగలిగేది: "60 lines కంటే ఎక్కువ ఉన్న function పైన, అది ఎందుకు అవసరమో వివరించే comment ఉండాలి."
- తనిఖీ చేయలేనిది: "మీ మార్పులను test చేయండి." తనిఖీ చేయగలిగేది: "
npm testను run చేసి, task పూర్తయిందని చెప్పే ముందు failure count ను paste చేయండి." - తనిఖీ చేయలేనిది: "Files ను క్రమబద్ధంగా ఉంచండి." తనిఖీ చేయగలిగేది: "HTTP handlers
src/api/handlers/లో ఉండాలి. ఆ directory లోకి మరేదీ వెళ్లకూడదు." - తనిఖీ చేయలేనిది: "Code ను సరిగ్గా format చేయండి." తనిఖీ చేయగలిగేది: "
.tsfiles లో 2 space indentation ఉపయోగించండి."
"అవసరానికి మించి రూపకల్పన చేయవద్దు" అనే నియమాన్ని ప్రజలు మొదట వదిలేస్తారు. కారణం, దాని పరిష్కారం చిన్న వాక్యం కాదు; పొడవైన వాక్యం. పనిచేసే అతి చిన్న మార్పు అంటే నిజంగా ఏమిటో స్పష్టంగా రాయడం ద్వారా agent తన diff ను పోల్చుకోగల ప్రమాణాలను పొందుతుంది.
వేరే రూపంలో కనిపించే ఇదే సమస్య size విషయంలోనూ ఉంటుంది. Claude Code మార్గదర్శకాలు ప్రతి instruction file ను 200 lines కంటే తక్కువగా ఉంచాలని సూచిస్తాయి. పొడవైన files లో నియమాలను అనుసరించే స్థాయి తగ్గుతుందని అవి నేరుగా చెబుతాయి. 700 line file మరింత బలమైన instruction కాదు. అది పరస్పరం విరుద్ధంగా ఉండే అవకాశాలు ఎక్కువగా ఉన్న 700 claims. ప్రతి turn లో అది మీ window కు లెక్కించబడుతుంది. అందువల్ల అది మీ token usage లో నేరుగా కనిపిస్తుంది. ప్రతి rule ను reader సులభంగా scan చేయగల heading కింద ఉంచేలా file ను నిర్మించడం గురించి agent అమలు చేయగల instruction file రాయడం లో వివరించారు. అంతకన్నా మంచిది, instruction ఇవ్వకుండా కేవలం వివరణ ఇచ్చే భాగాలను తొలగించడం. Handlers మరియు models ఎక్కడ ఉన్నాయో చెప్పే directory tour ను agent అవసరమైనప్పుడు repository యొక్క parsed map నుంచి చూసుకోవచ్చు. దాన్ని ప్రతి turn లో window లో ఉంచాల్సిన అవసరం ఉండదు.
పది నిమిషాల్లో సమస్యను ఎలా నిర్ధారించాలి
వీటిని ఇచ్చిన క్రమంలో అమలు చేయండి. చివరి దశకు నేరుగా వెళ్లడం వల్ల, గట్టిగా చెప్పిన నియమాలతో నిండిన పొడవైన ఫైల్ ఉన్నప్పటికీ అది పనిచేయని పరిస్థితి ఏర్పడుతుంది.
- అది లోడ్ అయిందో నిర్ధారించండి.
/contextను అమలు చేసి Memory files జాబితాను చదవండి. లేదా nested file కోసం terminal లో దానిLoadedలైన్ను చూడండి. ఫైల్ కనిపించకపోతే location ను సరిచేసి ఆపండి. ఈ జాబితాలోని మిగతా అంశాలు ఇంకా వర్తించవు. - కొత్త session లో మళ్లీ పరీక్షించండి. కొత్త session ప్రారంభించి, rule అమలయ్యేలా చేయాల్సిన అతి చిన్న task ఇవ్వండి. ఇక్కడ rule అమలై, దీర్ఘమైన session లో విఫలమైతే distance లేదా compaction కారణం కావచ్చు. ఇక్కడ కూడా విఫలమైతే సమస్య rule లోనే ఉంది.
- పోటీ సూచనలను తొలగించండి. ప్రస్తుతం ఉన్న code ఇప్పటికే ఆ rule ను అనుసరిస్తున్న directory లో అదే మార్పును అడగండి. compliance తిరిగి వస్తే, చుట్టుపక్కల code మీ వాక్యాన్ని మించిపోయింది.
- విరుద్ధ సూచన కోసం శోధించండి. ఒకే behaviour కోసం రెండు files వేర్వేరు guidance ఇస్తే, అది documented failure. Model వాటిలో ఒకదాన్ని యాదృచ్ఛికంగా ఎంచుకోవచ్చు. అలా ఎంచుకున్నట్లు అది మీకు చెప్పదు.
- దాన్ని తనిఖీ చేయగలిగేలా చేసి మళ్లీ పరీక్షించండి. Concrete path మరియు condition తో rule ను తిరిగి రాయండి. compliance గణనీయంగా పెరిగితే, కారణం phrasing లోనే ఉంది.
Step 4 కోసం ఒక command చాలు. మీరు మార్చుతున్న file మాత్రమే కాకుండా, topic కు సంబంధించిన ప్రతి instruction source లో Grep చేయండి:
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వేర్వేరు విషయాలు చెప్పే రెండు files లో hit కనిపిస్తే, అదే మీ bug. ఒకదాన్ని తొలగించండి. వాటిని మరింత బలమైన wording తో rank చేయడానికి ప్రయత్నించవద్దు, ఎందుకంటే దీనికి ఆధారపడగల ranking engine లేదు. Claude Code v2.1.283 లేదా తదుపరి version లో, /doctor prompt-audit మీ instruction files, rules మరియు skills అంతటా ఈ search యొక్క విస్తృత రూపాన్ని అమలు చేస్తుంది. ఏ మార్పూ చేయకుండా, proposed edits తో contradictions ను report చేస్తుంది; మీరు అడిగే వరకు అది ఏదీ మార్చదు.
నియమాలను అమలు చేసే ప్రభావ క్రమం
క్రింద ఉన్న ప్రతి దశ, దాని పైన ఉన్న దశకంటే ఎక్కువ ప్రభావాన్ని ఇస్తుంది మరియు అమలు చేయడానికి ఎక్కువ సమయం పడుతుంది. నియమాన్ని మార్చి రాయడం సులభంగా ఉన్నప్పుడు పై దశ నుంచే ప్రారంభించండి. అప్పుడప్పుడు నియమం తప్పిపోవడం ఆమోదయోగ్యం కానంత ముఖ్యమైనదిగా మారిన వెంటనే క్రింది దశకు వెళ్లండి.
- నియమాన్ని స్పష్టంగా చేయండి. ఒక path, command లేదా condition ను పేర్కొనండి. ముందుగా చూపిన విధంగా, agent repository లో కనుగొనే విరుద్ధ ఆధారాలను కూడా జోడించండి. దీనికి అదనపు వ్యయం లేదు మరియు ఆశ్చర్యకరంగా చాలా సందర్భాలను పరిష్కరిస్తుంది.
- నియమం నియంత్రించే అంశానికి దాన్ని మరింత దగ్గరగా ఉంచండి. Nested
CLAUDE.md,.claude/rules/లో path-scoped rule లేదా file పైభాగంలో ఉన్న comment ఉపయోగించండి. అప్పుడు నియమం, అది వర్తించే code చదివే సమయంలోనే అందుబాటులోకి వస్తుంది. అయితే ఈ పరిమితిని అంగీకరించండి: ఆ విధంగా లోడ్ చేసినది తదుపరి compaction సమయంలో తొలగిపోతుంది మరియు తదుపరి సరిపోలే read సమయంలో మళ్లీ వస్తుంది. - అమలును hook లోకి మార్చండి. Prose కేవలం అభ్యర్థిస్తుంది. Hook నిర్ణయం తీసుకుంటుంది. Hooks నిర్దిష్ట lifecycle events సమయంలో code గా అమలవుతాయి. Model ఏ నిర్ణయానికి వచ్చినా అవి వర్తిస్తాయి.
- నియమాన్ని deterministic tool కు అప్పగించి, prose ను తొలగించండి. Formatting, import order, line length, నిషేధిత imports, commit message రూపం.
ruff format,prettier --write,eslint, ఒకpre-commithook. Formatter ప్రతి సారి సరైన ఫలితాన్ని ఇస్తుంది మరియు tokens ఖర్చు చేయదు. Sentence ఎక్కువసార్లు సరైనదే అయినా, ప్రతి turn లో tokens ఖర్చు చేస్తుంది.
దశ 3 ను పూర్తిగా చూద్దాం. Migration files ను agent ఎప్పుడూ సవరించకూడదని అనుకుందాం. దీన్ని .claude/settings.json లో ఉంచండి:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Edit|Write",
"hooks": [
{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-migrations.sh"
}
]
}
]
}
}మరియు దీన్ని .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 0chmod +x .claude/hooks/guard-migrations.sh ను అమలు చేసి, కొత్త session ప్రారంభించండి. తరువాత migrations/ కింద ఉన్న file ను సవరించమని agent ను అడగండి. Edit తిరస్కరించబడుతుంది మరియు కారణంగా మీ message తిరిగి వస్తుంది. PreToolUse పై exit status 2, tool call అమలు కాకముందే దాన్ని block చేస్తుంది. మీ stderr text ను blocking message గా model కు అందిస్తుంది. ${CLAUDE_PROJECT_DIR} project root కు resolve అవుతుంది కాబట్టి agent ఏ directory లో ఉన్నా hook పనిచేస్తుంది. Agent ఈ నియమాన్ని అంగీకరించాల్సిన అవసరం లేదు. నియమాన్ని గుర్తుంచుకోవాల్సిన అవసరం లేదు. ఆ నియమం ఇంకా context లో ఉండాల్సిన అవసరం లేదు. Edit జరగదు.
ఎటువంటి logic లేని flat prohibition కోసం, మీ settings లోని permissions.deny script నిర్వహించాల్సిన అవసరం లేకుండా ఇదే పని చేస్తుంది. మీ అనుమతి లేకుండా ఏది అమలవుతుందో permission modes నిర్ణయిస్తాయి. ఒక instruction తప్పనిసరిగా user message లో కాకుండా system prompt స్థాయిలో ఉండాల్సి వస్తే, --append-system-prompt దాన్ని అక్కడ ఉంచుతుంది. అయితే ఇది launch flag కాబట్టి ప్రతి కొత్త session కు మళ్లీ pass చేయాలి. అందువల్ల ఇది interactive work కంటే scripts కు అనుకూలంగా ఉంటుంది.
మీరు ఆదేశాలతో మార్చలేని విషయాలు
ఇందులో ఏ సగం మీ పరిధిలో ఉందో స్పష్టంగా తెలుసుకోండి. Placement, phrasing, files మధ్య conflicts, file size వంటివి author సమస్యలు; వాటికి author స్థాయిలో పరిష్కారాలు ఉన్నాయి. మిగిలినవి model behaviour కు సంబంధించినవి. మెరుగైన wording వాటిని తొలగించదు.
Agreement compliance కాదు. Agent ఒక rule ను అంగీకరించినట్లు చెప్పవచ్చు, దాన్ని మీకు సరిగ్గా మళ్లీ చెప్పవచ్చు, కానీ రెండు tool calls తర్వాత అదే rule ను ఉల్లంఘించవచ్చు. ఆ acknowledgement కు ఎలాంటి ఖర్చు ఉండదు; దాని ఆధారంగా భవిష్యత్ ప్రవర్తనను అంచనా వేయలేరు. దాన్ని fix గా పరిగణించవద్దు. దాన్ని test గా కూడా లెక్కించవద్దు.
కొన్ని అలవాట్లు persistent గా ఉంటాయి. Comments జోడించడం, defensive error handling జోడించడం, closing summary రాయడం, తదుపరి స్పష్టమైన command ను అమలు చేయడం వంటివి rule నిషేధించినా తిరిగి కనిపిస్తాయి. వాటి రేటు zero కాకుండా తగ్గుతుంది. మీ స్వంత rate ను కొలవచ్చు: అదే task ను fresh sessions లో పది సార్లు run చేసి violations ను లెక్కించండి. ఆ సంఖ్య zero కావాల్సి ఉంటే, rule ను prompt నుంచి తీసివేయాలి. పని ఇంకా కొంత మిగిలి ఉండగానే పూర్తయిందని చెప్పడం కూడా ఇదే తరహా అలవాటు. దానికి పరిష్కారం verbal కాదు, structural: unlazy skill sentence స్థానంలో Depth Tree ను ఉంచుతుంది; పూర్తయిందని చెప్పే ముందు agent clear చేయాల్సిన gate files ను కూడా అందిస్తుంది.
మీ స్వంత session ఒక ఉదాహరణగా మారుతుంది. Agent turn 12 వద్ద rule ను ఉల్లంఘించినప్పుడు మీరు దాన్ని పట్టించుకోకపోతే, ఆ violation context లో demonstration గా నిలుస్తుంది. అది rule కంటే చాలా recent గా ఉంటుంది. Violation కనిపించిన వెంటనే దాన్ని సరిచేయండి. సరిచేయని violation session లోని మిగిలిన భాగానికి బోధనగా మారుతుంది.
Instruction file security boundary కాదు. అది behaviour ను ప్రభావితం చేస్తుంది కానీ దాన్ని enforce చేయదు. Miss వల్ల ఖర్చు ఎక్కువయ్యే విషయాలు, ముఖ్యంగా credentials లేదా destructive commands, permissions లేదా hook పరిధిలో ఉండాలి. agent కు secrets అందకుండా ఉంచడం data విషయంలో ఇదే సూత్రాన్ని వర్తింపజేస్తుంది: agent ఒక file ను చదవకూడదని అడగవద్దు; ఆ file readable కాకుండా ఏర్పాటు చేయండి.
సంక్షిప్తంగా: file load అయిందని నిరూపించండి, rule ను check చేయగలిగేలా చేయండి, అది నియంత్రించే అంశం పక్కనే ఉంచండి. Miss rate ఇంకా ముఖ్యంగా ఉంటే, దాన్ని prose నుంచి తీసివేయండి. Agent ignore చేయలేని rule అనేది agent ను ఎప్పుడూ అడగని rule.
FAQ
Claude Code నా CLAUDE.md ను ఎందుకు పట్టించుకోదు?
దాన్ని పట్టించుకోలేదని అనుకునే ముందు, అది load అయిందో లేదో తనిఖీ చేయండి. /context ను run చేసి Memory files జాబితాను చూడండి; అక్కడ పేరు లేని file launch సమయంలో load కాలేదు. Instruction files system prompt తర్వాత user message గా పంపబడతాయి. అవి తప్పనిసరిగా అమలు చేయాల్సిన configuration గా కాకుండా context గా పరిగణించబడతాయి. అందువల్ల కచ్చితమైన compliance కు హామీ ఉండదు. వాస్తవ సందర్భాల్లో సాధారణంగా నాలుగు కారణాల్లో ఒకటి ఉంటుంది: file agent ఎప్పుడూ చదవని subdirectory లో ఉంటుంది, రెండు files పరస్పరం విరుద్ధంగా ఉండటంతో model ఒకదాన్ని యాదృచ్ఛికంగా ఎంచుకుంటుంది, rule చాలా అస్పష్టంగా ఉండటంతో దాని ఆధారంగా action ను తనిఖీ చేయలేరు, లేదా చుట్టుపక్కల code ఆ rule కు విరుద్ధమైన విధానాన్ని చూపిస్తుంది.
Session మధ్యలో instruction file ను edit చేస్తే ఏమైనా మారుతుందా?
ఇప్పటికే conversation లో ఉన్న copy విషయంలో మారదు. మీ working directory పైభాగంలో ఉన్న files launch సమయంలో పూర్తిగా load అవుతాయి. అందువల్ల model వద్ద ఉన్న text launch సమయానికి ఉన్నదే. Edit ను load చేయాలంటే కొత్త session ప్రారంభించండి. లేదా agent ను దాని సాధారణ file tools తో file చదవమని అడగండి. అప్పుడు ప్రస్తుత version conversation లోకి కొత్త message గా వస్తుంది. Compaction తర్వాత project root file disk నుంచి మళ్లీ read చేయబడుతుంది. అందువల్ల ఆ సమయంలో కొత్త version కూడా చేరుతుంది.
Root CLAUDE.md మరియు nested file మధ్య విభేదం ఉంటే ఏ file కు ప్రాధాన్యం ఉంటుంది?
ఏదికీ విశ్వసనీయంగా ప్రాధాన్యం ఉండదు. కనుగొన్న files ను ఒకదానిపై మరొకటి override చేయకుండా context లో కలిపి ఉంచుతారు. వాటి క్రమం filesystem root నుంచి working directory వరకు ఉంటుంది. అందువల్ల దగ్గరలోని file చివరిగా చదవబడుతుంది. విరుద్ధతలను పరిష్కరించే precedence engine లేదు. Claude Code documentation ప్రకారం, విరుద్ధమైన rules యాదృచ్ఛికంగా పరిష్కరించబడవచ్చు. Nested files ను అవి వర్తించే path ను పేర్కొనే additions గా రాయండి. మరొక rule పై ప్రాధాన్యం సాధించడానికి ప్రయత్నించకుండా, విరుద్ధమైన rule ను తొలగించండి.
/compact తర్వాత నా instructions కొనసాగుతాయా?
అవి ఎలా load అయ్యాయనే దానిపై ఆధారపడి ఉంటుంది. Project root CLAUDE.md, unscoped rules మరియు auto memory compaction తర్వాత disk నుంచి మళ్లీ inject చేయబడతాయి. paths: frontmatter ఉన్న rules మరియు subdirectories లోని nested CLAUDE.md files, సరిపోలే file ను మళ్లీ చదివే వరకు కోల్పోతాయి. మీరు chat లో మాత్రమే type చేసిన విషయం summariser దాన్ని ఉంచి ఉంటేనే కొనసాగుతుంది. మొత్తం session లో ఒక rule తప్పనిసరిగా అమలులో ఉండాలంటే, దాన్ని paths: frontmatter లేకుండా project root file లో ఉంచండి.
Prose బదులుగా rule ను hook గా ఎప్పుడు మార్చాలి?
తనిఖీ నిర్ణయాత్మకంగా ఉండి, తప్పిపోయిన తనిఖీ ఖర్చు చిన్న script రాయడం కంటే ఎక్కువగా ఉన్నప్పుడు మార్చాలి. File path restrictions, commit కు ముందు అవసరమైన commands మరియు నిషేధిత tool calls ఈ వర్గంలోకి వస్తాయి. Status 2 తో exit అయ్యే PreToolUse hook tool call ను పూర్తిగా block చేస్తుంది. అలాగే stderr text ను కారణంగా model కు తిరిగి అందిస్తుంది. అందువల్ల ఆ rule context లో ఇంకా ఉన్నా లేకపోయినా అమలవుతుంది. Formatter లేదా linter నిర్ణయించగల విషయాలను ఆ tool ఆధీనంలోనే ఉంచండి. వాటిని instruction file నుంచి పూర్తిగా తొలగించండి.