कोडिंग एजेंट्स निर्देशों की अनदेखी क्यों करते हैं
कोडिंग एजेंट्स आपके निर्देशों को क्यों नजरअंदाज करते हैं? इसके पीछे के चार तकनीकी कारण और Claude Code जैसे टूल्स के लिए एक सटीक डायग्नोस्टिक टेस्ट यहाँ विस्तार से जानें।
कोडिंग एजेंट्स आपके निर्देशों की अनदेखी क्यों करते हैं
कोडिंग एजेंट्स आपके निर्देशों की अनदेखी चार कारणों से करते हैं, और इनमें से कोई भी कारण यह नहीं है कि आप बहुत विनम्र थे। नियम कभी context window में था ही नहीं। नियम इतना अस्पष्ट था कि किसी क्रिया की उससे तुलना नहीं की जा सकी। context में मौजूद किसी अन्य चीज़ ने इसका खंडन किया, आमतौर पर वह कोड जिसे एजेंट ने अभी-अभी पढ़ा था। या फिर नियम अभी भी लोड है लेकिन वर्तमान टर्न से काफी पीछे है, और एजेंट उसी पर काम कर रहा है जो उसके निकट है।
प्रत्येक कारण का अपना समाधान है, इसलिए पहला काम उन्हें अलग-अलग पहचानना है। बड़े अक्षर और IMPORTANT शब्द कोई निदान नहीं हैं। नीचे दी गई कार्यप्रणाली में उदाहरण के तौर पर Claude Code का उपयोग किया गया है, क्योंकि अक्टूबर 2026 तक इसका लोडिंग और कॉम्पेक्शन व्यवहार विस्तार से प्रलेखित है। अन्य टूल्स विवरण में भिन्न हो सकते हैं लेकिन रूपरेखा में समान व्यवहार करते हैं।
सबसे पहले दो शब्द। context window टेक्स्ट का वह ब्लॉक है जिसे मॉडल एक निश्चित टर्न पर देखता है: system prompt, आपकी instruction files, बातचीत, और वह हर फाइल जिसे एजेंट ने पढ़ा है। harness मॉडल के चारों ओर का प्रोग्राम है, वह चीज़ जो डिस्क से फाइलें पढ़ती है और उस ब्लॉक को असेंबल करती है। इस पोस्ट में लगभग हर शिकायत वास्तव में harness के बारे में है, न कि मॉडल के बारे में।
Instruction file एक संदेश है, न कि सेटिंग
Instruction file configuration नहीं होती है। Runtime में कोई भी चीज़ CLAUDE.md को नहीं पढ़ती है और न ही उसे लागू करती है। Harness डिस्क से फाइल को पढ़ता है और टेक्स्ट को conversation में पेस्ट कर देता है। Claude Code में वह सामग्री एक user message के रूप में डिलीवर की जाती है, जिसे system prompt के बाद रखा जाता है। इसका मतलब है कि model आपके नियमों को उसी तरह देखता है जैसे आपके द्वारा टाइप की गई किसी भी अन्य चीज़ को।
इसका एक असहज परिणाम यह होता है कि आपके नियम विंडो में मौजूद हर दूसरे टेक्स्ट के साथ समान स्तर पर प्रतिस्पर्धा करते हैं। एक नियम केवल एक दावा है। जिस फाइल को agent ने अभी खोला है, वह एक प्रमाण है। जब दोनों में असहमति होती है, तो अक्सर प्रमाण जीत जाता है, और कोई error नहीं आता है, क्योंकि model के दृष्टिकोण से कुछ भी गलत नहीं हुआ है।
आधिकारिक documentation इसे स्पष्ट रूप से कहता है: instruction files को context माना जाता है, न कि लागू की गई configuration। model के निर्णय की परवाह किए बिना किसी action को रोकने के लिए, आपको एक hook की आवश्यकता है, न कि एक वाक्य की। इस बात को ध्यान में रखें। इस पोस्ट के अंत में दिए गए अधिकांश समाधान किसी विशिष्ट मामले पर लागू की गई यही पंक्ति हैं।
कौन सी instruction files लोड होती हैं और कब
Claude Code उस directory से ऊपर की ओर directory tree में जाता है जहाँ से आपने इसे शुरू किया है। filesystem root से लेकर आपकी working directory तक की हर CLAUDE.md और CLAUDE.local.md लॉन्च के समय पूरी तरह लोड हो जाती है। उन्हें इसी क्रम में जोड़ा (concatenate) जाता है, इसलिए जहाँ से आपने इसे लॉन्च किया है उसके सबसे करीब वाली फाइल अंत में पढ़ी जाती है, और एक ही directory के भीतर .local फाइल को मुख्य फाइल के बाद जोड़ा जाता है।
आपकी working directory के नीचे मौजूद subdirectories की फाइलें अलग तरह से व्यवहार करती हैं। वे लॉन्च के समय लोड नहीं होतीं। वे तब लोड होती हैं जब agent उस directory में किसी फाइल को पढ़ता है। .claude/rules/ में path scoped rules के साथ भी ऐसा ही है जिनमें paths: frontmatter field होता है: वे हर टर्न पर नहीं, बल्कि तब context में आते हैं जब कोई matching फाइल पढ़ी जाती है। v2.1.309 के बाद से, इस तरह लोड होने वाली फाइलों पर प्रति-फाइल आकार की सीमा भी होती है (200K context window पर 40,000 characters), और agent को लंबी फाइल का केवल शुरुआती हिस्सा ही मिलता है, इसलिए किसी बड़ी nested फाइल के अंत में दिए गए rules शायद कभी context तक न पहुँचें।
यह एक अंतर रिपोर्ट की गई अधिकांश विफलताओं का कारण है। आप packages/api/CLAUDE.md में एक rule डालते हैं, आप API के बारे में कोई सवाल पूछते हैं, और agent packages/api/ के अंतर्गत कोई फाइल खोले बिना ही जवाब दे देता है। Rule को अनदेखा नहीं किया गया था। वह कभी मौजूद ही नहीं था। यदि आपका repository monorepo में प्रति पैकेज instruction files के माध्यम से मार्गदर्शन को विभाजित करता है, तो हर बार सबसे पहले इसी की जाँच करें।
एक और loading trap उन repositories को प्रभावित करता है जिन्होंने AGENTS.md को मानकीकृत किया है। v2.1.277 के बाद से, Claude Code डिफ़ॉल्ट रूप से AGENTS.md को आपकी project instructions के रूप में पढ़ता है, लेकिन केवल तब जब आपकी working directory या उससे ऊपर की किसी भी directory में CLAUDE.md, .claude/CLAUDE.md या CLAUDE.local.md मौजूद न हो (आपकी व्यक्तिगत ~/.claude/CLAUDE.md इसमें शामिल नहीं है)। इनमें से कोई भी एक फाइल जोड़ें, यहाँ तक कि व्यक्तिगत नोट्स के लिए एक CLAUDE.local.md भी, तो Claude Code इसके बजाय आपकी CLAUDE.md फाइलों को पढ़ता है और AGENTS.md को पूरी तरह छोड़ देता है। दोनों को लोड करने के लिए, /config में Project instructions को claude-md-and-agents-md पर सेट करें। v2.1.277 से पहले के वर्ज़न में, या जब आप CLAUDE.md रखना चाहते हैं, तो इसका समाधान एक CLAUDE.md है जिसकी पहली लाइन @AGENTS.md है, जो लॉन्च के समय फाइल को इम्पोर्ट करती है, और उसके नीचे Claude से संबंधित कोई भी नोट्स हो सकते हैं। जब आपके पास जोड़ने के लिए कुछ अतिरिक्त न हो तो एक symlink भी काम करता है। उस फाइल में क्या शामिल करना है, यह एक अलग प्रश्न है, जिसे मानवीय दस्तावेज़ीकरण से agent instructions को अलग करना में कवर किया गया है।
Rewrite करने से पहले पुष्टि करें कि फ़ाइल लोड हो गई है
जब तक आपके पास यह प्रमाण न हो कि एजेंट फ़ाइल को देख सकता है, तब तक शब्दों में कोई बदलाव न करें। इसके लिए दो जाँचें हैं, और पहली वाली सरल है।
सेशन के भीतर /context चलाएँ। यह वर्तमान विंडो को श्रेणियों के अनुसार विभाजित करके दिखाता है, और Memory files सूची में उन सभी instruction फ़ाइलों के नाम होते हैं जो लॉन्च के समय लोड हुई थीं। जो फ़ाइल उस सूची में नहीं है, वह लॉन्च के समय लोड नहीं हुई थी, इसलिए जब तक कोई उसे लोड नहीं करता, तब तक आप उसमें जो कुछ भी लिखेंगे उसका कोई महत्व नहीं होगा। सबडायरेक्टरी में मौजूद कोई नेस्टेड फ़ाइल वहाँ कभी दिखाई नहीं देती, क्योंकि वह आवश्यकता पड़ने पर (on demand) लोड होती है; जब वह लोड होती है, तो टर्मिनल में उसके पाथ के साथ एक Loaded लाइन दिखाई देती है। /memory फ़ाइल के स्थानों को सूचीबद्ध करता है और उन्हें संपादन के लिए खोलता है, जिसमें वे फ़ाइलें भी शामिल हैं जो अभी मौजूद नहीं हैं।
अधिक सटीक उत्तर के लिए, लोड को लॉग करें। InstructionsLoaded हुक इवेंट हर बार तब सक्रिय होता है जब कोई CLAUDE.md या रूल्स फ़ाइल कॉन्टेक्स्ट में प्रवेश करती है, और इसका मैचर आपको बताता है कि लोड क्यों हुआ: 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"
}
]
}
]
}
}हुक को अपना पेलोड स्टैंडर्ड इनपुट पर JSON के रूप में प्राप्त होता है, इसलिए cat पूरे रिकॉर्ड को अपेंड करता है। काम करते समय इसे tail -f /tmp/instructions-loaded.log के साथ देखें। इस इवेंट का एग्जिट स्टेटस अनदेखा कर दिया जाता है, इसलिए हुक केवल निरीक्षण कर सकता है, कभी ब्लॉक नहीं। यदि आपका नेस्टेड फ़ाइल उस सेशन के दौरान लॉग में कभी दिखाई नहीं देता जहाँ आपने इसकी अपेक्षा की थी, तो दोबारा लिखना बंद कर दें। समस्या प्लेसमेंट की है। एक अपवाद: एक AGENTS.md जिसे Claude Code सीधे पढ़ता है, वह इस इवेंट को सक्रिय नहीं करता है, इसलिए इसके पाथ को /memory में देखें। एक AGENTS.md जिसे CLAUDE.md से इम्पोर्ट किया गया है, वह हमेशा की तरह इसे सक्रिय करता है।
लंबे सेशन का आपके नियमों पर प्रभाव
यहाँ दो अलग-अलग प्रभाव लागू होते हैं, और उनके लिए अलग-अलग प्रतिक्रियाओं की आवश्यकता होती है।
दूरी (Distance)। जब तक compaction नहीं चलता, टर्न 1 पर दिया गया नियम टर्न 90 पर भी विंडो में रहता है, जहाँ अब यह 90 टर्न के उस टेक्स्ट के साथ प्रतिस्पर्धा करता है जो अधिक हालिया है और आपके वर्तमान कार्य के लिए अधिक विशिष्ट है। एक बार compaction चलने के बाद, केवल चैट में टाइप किया गया नियम शायद विंडो में बिल्कुल न रहे: Claude Code का अपना डॉक्यूमेंटेशन चेतावनी देता है कि बातचीत की शुरुआत के निर्देश खो सकते हैं, जो नीचे दिया गया दूसरा प्रभाव है। आप दूरी को कॉन्फ़िगर करके हटा नहीं सकते, लेकिन आप इसे माप सकते हैं। एक नए सेशन में वही कार्य चलाएँ। यदि नियम वहाँ काम करता है और एक लंबे सेशन में गहराई पर विफल हो जाता है, तो इसका कारण दूरी या compaction है।
Compaction। जब विंडो भर जाती है, तो हार्नेस अब तक की बातचीत का सारांश (summarise) तैयार करता है और उस सारांश से आगे बढ़ता है। जो बचता है वह वह है जिसे summariser ने महत्वपूर्ण माना, जो कि वह नहीं है जिसे आप महत्वपूर्ण मानते हैं। Claude Code प्रत्येक मैकेनिज्म के अनुसार परिणाम को डॉक्यूमेंट करता है, और अंतर काफी बड़े हैं। प्रोजेक्ट रूट CLAUDE.md और unscoped नियम compaction के बाद डिस्क से पुनः इंजेक्ट (re-inject) किए जाते हैं। ऑटो मेमोरी डिस्क से पुनः इंजेक्ट की जाती है। paths: फ्रंटमैटर वाले नियम तब तक खो जाते हैं जब तक कि कोई संबंधित फ़ाइल दोबारा न पढ़ी जाए। सबडायरेक्टरी में मौजूद नेस्टेड CLAUDE.md फ़ाइलें तब तक खो जाती हैं जब तक कि उस सबडायरेक्टरी की कोई फ़ाइल दोबारा न पढ़ी जाए।
अपने निर्देशों को उस तालिका के अनुसार रैंक करें और नाजुकता (fragility) का क्रम स्पष्ट हो जाएगा। केवल चैट में टाइप किया गया नियम सेशन में सबसे नाजुक चीज है: यह केवल तभी बना रहता है यदि सारांश ने इसे संयोग से सुरक्षित रखा हो। packages/api/CLAUDE.md में मौजूद नियम इसके बाद आता है, क्योंकि इसे एक बार लोड किया गया, सारांश में हटा दिया गया, और यह केवल उस डायरेक्टरी में अगली बार पढ़ने पर वापस आता है। प्रोजेक्ट रूट फ़ाइल में मौजूद नियम सबसे अधिक टिकाऊ है, क्योंकि इसे हर बार डिस्क से दोबारा पढ़ा जाता है।
इसलिए यदि किसी निर्देश को पूरे सेशन के दौरान लागू रहना है, तो उसे बिना किसी paths: फ्रंटमैटर के प्रोजेक्ट रूट फ़ाइल में होना चाहिए। बाकी सब कुछ एक ऐसा समझौता (tradeoff) है जिसे आपको सोच-समझकर करना चाहिए। कॉन्टेक्स्ट विंडो में क्या रहता है, इसे मैनेज करना /compact को फोकस आर्ग्युमेंट के साथ और /clear को असंबंधित कार्यों के बीच कवर करता है, जो दोनों ही यह बदलते हैं कि summariser को कितनी बार यह तय करना पड़ता है कि आपके नियम क्या थे।
क्यों आसपास का कोड नियम से बेहतर काम करता है
यह वह विफलता है जिसका वर्णन लोग सबसे अधिक करते हैं और निदान सबसे कम। आपकी फाइल कहती है कि डेटाबेस एक्सेस रिपॉजिटरी लेयर के माध्यम से होता है। एजेंट एक ऐसा हैंडलर लिखता है जो सीधे ORM (object relational mapper) को कॉल करता है। आपकी अनदेखी स्टाइल के आधार पर नहीं की गई थी। साक्ष्यों ने आपके तर्क को पीछे छोड़ दिया।
एक नियम केवल प्राथमिकता बताता है। कोड एक प्राथमिकता प्रदर्शित करता है। जब एजेंट उस मॉड्यूल में तीन फाइलें खोलता है जिसे वह एडिट करने वाला है और तीनों सीधे ORM को कॉल करती हैं, तो संदर्भ के एक तरफ एक अमूर्त वाक्य होता है और दूसरी तरफ तीन ठोस, हालिया और कार्य के अनुरूप उदाहरण होते हैं। स्थानीय पैटर्न की नकल करना आमतौर पर सही व्यवहार है। यह यहाँ केवल इसलिए गलत है क्योंकि आप वह जानते हैं जो संदर्भ नहीं जानता: वे फाइलें legacy हैं।
इसलिए इसे नियम में लिखें। जो नियम अपने स्वयं के विपरीत साक्ष्यों का उल्लेख करते हैं, वे वास्तविक रिपॉजिटरी के साथ तालमेल बिठा पाते हैं। जो नियम केवल एक कोरी प्राथमिकता बताते हैं, वे ऐसा नहीं कर पाते।
नया डेटाबेस एक्सेसapp/repositories/के माध्यम से होना चाहिए।app/legacy/के अंतर्गत आने वाली फाइलें अभी भी सीधे ORM को कॉल करती हैं। वह पुराना कोड है, पैटर्न नहीं। उसकी नकल न करें।
दूसरा वाक्य मुख्य काम करता है। यह एजेंट को बताता है कि वह क्या खोजने वाला है और उसे कैसे पढ़ना है, इससे पहले कि वह उसे खोजे। यही सुधार किसी भी ऐसे नियम पर लागू होता है जिसका आपका रिपॉजिटरी स्पष्ट रूप से खंडन करता है: एक कमिट स्टाइल जिसका आपका इतिहास पालन नहीं करता, एक टेस्ट लेआउट जिसे आपकी आधी सुइट अनदेखा करती है, या एक इम्पोर्ट कन्वेंशन जो केवल नए कोड में लागू होता है। जहाँ भी कोड फाइल से असहमत हो, उस असहमति का नाम फाइल में लिखें।
एक अस्पष्ट नियम की जाँच नहीं की जा सकती, इसलिए उसका पालन भी नहीं किया जा सकता
"साफ कोड लिखें।" "ओवर-इंजीनियरिंग न करें।" "इसे सरल रखें।" "माइग्रेशन के समय सावधान रहें।" इनमें से किसी भी नियम को किसी विशिष्ट क्रिया के विरुद्ध परखा नहीं जा सकता, न तो एजेंट द्वारा और न ही आपके द्वारा। जिस एजेंट को ऐसा नियम दिया जाता है जिसकी वह अपने आउटपुट के विरुद्ध जाँच नहीं कर सकता, वह केवल अनुमान लगा रहा होता है, और आप उस अनुमान को अपनी भावनाओं के आधार पर आंक रहे होते हैं।
अपनी फाइल की प्रत्येक पंक्ति पर लागू करने के लिए यह परीक्षण अपनाएं। वह शेल कमांड लिखें जो नियम टूटने पर non-zero exit status दे। यदि आप वह कमांड नहीं लिख सकते, तो नियम जाँचने योग्य नहीं है। इन जोड़ों की तुलना करें:
- जाँचने योग्य नहीं: "फंक्शन्स को छोटा रखें।" जाँचने योग्य: "60 लाइनों से अधिक लंबे फंक्शन के ऊपर एक टिप्पणी होनी चाहिए जिसमें कारण बताया गया हो।"
- जाँचने योग्य नहीं: "अपने बदलावों का परीक्षण करें।" जाँचने योग्य: "
npm testचलाएं और कार्य पूरा करने से पहले विफलता की संख्या (failure count) पेस्ट करें।" - जाँचने योग्य नहीं: "फाइलों को व्यवस्थित रखें।" जाँचने योग्य: "HTTP हैंडलर्स
src/api/handlers/में रहते हैं। उस निर्देशिका में और कुछ नहीं जाना चाहिए।" - जाँचने योग्य नहीं: "कोड को ठीक से फॉर्मेट करें।" जाँचने योग्य: "
.tsफाइलों में 2 स्पेस इंडेंटेशन का उपयोग करें।"
"ओवर-इंजीनियरिंग न करें" वह नियम है जिसे लोग सबसे पहले छोड़ देते हैं, क्योंकि इसका समाधान एक छोटा वाक्य नहीं बल्कि एक लंबा वाक्य है: सबसे छोटे कार्यशील बदलाव का वास्तव में क्या अर्थ है, इसे स्पष्ट करना एजेंट को ऐसे मानदंड देता है जिसके विरुद्ध वह अपने diff की तुलना कर सकता है।
आकार भी वही समस्या है, बस उसका रूप अलग है। Claude Code का मार्गदर्शन प्रति निर्देश फाइल 200 लाइनों से कम रखने का सुझाव देता है और स्पष्ट रूप से कहता है कि लंबी फाइलें अनुपालन (adherence) को कम करती हैं। 700 लाइनों की फाइल कोई अधिक ठोस निर्देश नहीं है। यह 700 लाइनों के दावे हैं जिनमें एक-दूसरे का खंडन करने की अधिक संभावना है, और यह हर मोड़ पर आपकी विंडो के विरुद्ध चार्ज किया जाता है, जो सीधे आपके टोकन उपयोग में दिखाई देता है। फाइल को इस तरह व्यवस्थित करना कि प्रत्येक नियम एक हेडिंग के नीचे हो जिसे पाठक स्कैन कर सके, एक ऐसे निर्देश फाइल को लिखने में शामिल है जिस पर एजेंट कार्य कर सके। इससे भी बेहतर, उन हिस्सों को हटा दें जो निर्देश देने के बजाय केवल वर्णन करते हैं: हैंडलर्स और मॉडल्स कहाँ स्थित हैं, इसका निर्देशिका विवरण वह संरचना है जिसे एजेंट रिपॉजिटरी के पार्स किए गए मैप से मांग पर देख सकता है, बजाय इसके कि उसे हर मोड़ पर विंडो में रखा जाए।
इसे दस मिनट में कैसे डायग्नोस करें
इन्हें क्रम से चलाएं। अंतिम चरण पर सीधे जाने के कारण ही लोग अंत में नियमों की एक लंबी सूची बना लेते हैं जो फिर भी काम नहीं करती।
- पुष्टि करें कि यह लोड हुआ है।
/contextचलाएं और Memory फाइलों की सूची पढ़ें, या नेस्टेड फाइल के लिए टर्मिनल में इसकीLoadedलाइन देखें। यदि फाइल वहां नहीं है, तो लोकेशन ठीक करें और रुक जाएं। इस सूची का कोई अन्य चरण अभी लागू नहीं होता है। - एक नए सेशन में इसे दोहराएं। एक नया सेशन शुरू करें और सबसे छोटा टास्क दें जो नियम को ट्रिगर करना चाहिए। यदि यहाँ काम कर रहा है लेकिन लंबे सेशन में विफल हो रहा है, तो इसका मतलब है कि समस्या दूरी या कॉम्पैक्शन (compaction) की है। यदि यहाँ भी विफल हो रहा है, तो इसका मतलब है कि समस्या स्वयं नियम में है।
- प्रतिस्पर्धा को हटाएं। उसी डायरेक्टरी में वही बदलाव करने के लिए कहें जिसका मौजूदा कोड पहले से ही नियम का पालन करता है। यदि अनुपालन (compliance) वापस आ जाता है, तो इसका मतलब है कि आसपास का कोड आपके निर्देश को ओवरराइड कर रहा था।
- संघर्ष (conflict) खोजें। एक ही व्यवहार के लिए दो अलग-अलग निर्देश देने वाली फाइलें एक ज्ञात विफलता है: मॉडल मनमाने ढंग से किसी एक को चुन सकता है, और वह आपको बताएगा भी नहीं।
- इसे जांचने योग्य बनाएं और पुनः परीक्षण करें। नियम को एक ठोस पाथ और शर्त के साथ फिर से लिखें। अनुपालन में बड़ी वृद्धि का मतलब है कि समस्या आपकी शब्दावली में थी।
चरण 4 केवल एक कमांड है। केवल उस फाइल को नहीं जिसे आप एडिट कर रहे थे, बल्कि निर्देश के हर स्रोत में उस विषय के लिए 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दो फाइलों में एक ही विषय पर अलग-अलग निर्देश मिलना ही आपका बग है। एक को हटा दें। उन्हें अधिक सख्त शब्दों के साथ रैंक करने का प्रयास न करें, क्योंकि अपील करने के लिए कोई रैंकिंग इंजन नहीं है। Claude Code v2.1.283 या उसके बाद के वर्ज़न पर, /doctor prompt-audit आपकी इंस्ट्रक्शन फाइलों, नियमों और स्किल्स में इस सर्च का एक व्यापक वर्ज़न चलाता है, और आपके द्वारा पूछे जाने तक बिना कुछ बदले प्रस्तावित एडिट्स के साथ विरोधाभासों की रिपोर्ट देता है।
सुधार के उपाय, प्रभाव के क्रम में
नीचे दिए गए प्रत्येक चरण का प्रभाव उससे ऊपर वाले चरण से अधिक है, और इसे सेटअप करने में लागत भी अधिक आती है। जब किसी नियम को फिर से लिखना सस्ता हो, तो ऊपर से शुरुआत करें। जैसे ही कोई नियम इतना महत्वपूर्ण हो जाए कि उसमें कभी-कभार होने वाली चूक भी स्वीकार्य न हो, तो नीचे की ओर बढ़ें।
- नियम को ठोस बनाएँ। किसी path, command या condition का नाम लें। repository में agent को मिलने वाले counter-evidence को जोड़ें, जैसा कि पहले दिखाया गया है। यह मुफ्त है और कई मामलों को आसानी से ठीक कर देता है।
- इसे उस चीज़ के करीब ले जाएँ जिसे यह नियंत्रित करता है। एक nested
CLAUDE.md,.claude/rules/में path scoped नियम, या स्वयं file के शीर्ष पर एक टिप्पणी। नियम तब उसी read में आता है जिसमें वह code आता है जिस पर यह लागू होता है। इस tradeoff को स्वीकार करें: इस तरह load की गई कोई भी चीज़ अगले compaction पर हट जाती है और अगली matching read पर वापस आ जाती है। - enforcement को एक hook में ले जाएँ। गद्य (prose) केवल अनुरोध करता है। एक hook निर्णय लेता है। hooks निश्चित lifecycle events पर code के रूप में चलते हैं और model के निष्कर्ष की परवाह किए बिना लागू होते हैं।
- नियम को एक deterministic tool को सौंपें और गद्य को हटा दें। Formatting, import order, line length, प्रतिबंधित imports, commit message का स्वरूप।
ruff format,prettier --write,eslint, एकpre-commithook। formatter हर बार सही होता है और इसमें शून्य tokens का खर्च आता है। वाक्य अधिकतर समय सही होता है और हर turn पर tokens खर्च करता है।
चरण 3 का पूर्ण विवरण। मान लें कि migration files को agent द्वारा कभी भी edit नहीं किया जाना चाहिए। इसे .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 शुरू करें और agent से migrations/ के अंतर्गत किसी file को edit करने के लिए कहें। edit करने से मना कर दिया जाएगा और आपका संदेश कारण के रूप में वापस आएगा। PreToolUse पर exit status 2 टूल कॉल को चलने से पहले ही रोक देता है, और आपका stderr text model को blocking संदेश के रूप में दिया जाता है। ${CLAUDE_PROJECT_DIR} project root पर resolve होता है, इसलिए यह hook तब भी काम करता है जब agent किसी भी directory में हो। agent को नियम से सहमत होने, नियम को याद रखने, या नियम को context में रखने की आवश्यकता नहीं है। edit नहीं होता है।
बिना किसी logic वाली सीधी मनाही के लिए, आपकी settings में permissions.deny वही काम करता है, जिसमें बनाए रखने के लिए कोई script नहीं होती, और permission modes तय करते हैं कि आपसे पूछे बिना क्या चलना चाहिए। यदि किसी निर्देश को वास्तव में user message के बजाय system prompt स्तर पर होना चाहिए, तो --append-system-prompt उसे वहाँ रख देता है, हालाँकि यह एक launch flag है जिसे हर नए session में फिर से पास करने की आवश्यकता होती है, जो interactive काम की तुलना में scripts के लिए अधिक उपयुक्त है।
वे निर्देश जिन्हें आप हटा नहीं सकते
स्पष्ट रहें कि इसमें से कौन सा हिस्सा आपका है। प्लेसमेंट, वाक्यांश, फाइलों के बीच टकराव और फाइल का आकार लेखक की समस्याएं हैं जिन्हें लेखक ही ठीक कर सकता है। बाकी मॉडल का व्यवहार है, और बेहतर शब्दों के प्रयोग से यह नहीं बदलेगा।
सहमति का अर्थ अनुपालन नहीं है। एक एजेंट किसी नियम को स्वीकार करेगा, उसे सही ढंग से दोहराएगा, और दो टूल कॉल के बाद उसे तोड़ देगा। स्वीकृति की कोई कीमत नहीं होती और यह कुछ भी अनुमानित नहीं करती। इसे समाधान के रूप में न पढ़ें, और इसे परीक्षण के रूप में न गिनें।
कुछ आदतें स्थायी होती हैं। टिप्पणियाँ जोड़ना, रक्षात्मक त्रुटि प्रबंधन (defensive error handling) जोड़ना, समापन सारांश लिखना, अगला स्पष्ट कमांड चलाना। ये आदतें उस नियम के बावजूद वापस आ जाती हैं जो उन्हें रोकता है, हालांकि उनकी आवृत्ति शून्य होने के बजाय कम हो जाती है। आप अपनी दर को माप सकते हैं: नए सत्रों में दस बार एक ही कार्य चलाएं और उल्लंघनों की गिनती करें। जहां उस संख्या का शून्य होना आवश्यक है, वहां नियम को प्रॉम्प्ट से हटाना होगा। किसी कार्य को अधूरा होने पर भी समाप्त घोषित करना उसी आदत का एक रूप है, और इसका सुधार मौखिक के बजाय संरचनात्मक है: the unlazy skill वाक्यों के स्थान पर एक Depth Tree का उपयोग करती है और उन gate files को अनिवार्य बनाती है जिन्हें एजेंट को कार्य पूरा घोषित करने से पहले क्लियर करना होता है।
आपका अपना सत्र एक उदाहरण बन जाता है। यदि एजेंट ने टर्न 12 पर नियम तोड़ा और आपने उसे जाने दिया, तो वह उल्लंघन अब संदर्भ (context) में एक प्रदर्शन के रूप में बैठ जाता है, और यह नियम की तुलना में बहुत अधिक हालिया है। उल्लंघन को देखते ही उसे सुधारें। एक बिना सुधारा गया उल्लंघन बाकी सत्र को गलत सीख देता है।
एक निर्देश फाइल सुरक्षा सीमा (security boundary) नहीं है। यह व्यवहार को आकार देती है लेकिन उसे लागू नहीं करती। कोई भी ऐसी चीज जहां चूक महंगी हो, जैसे क्रेडेंशियल्स या विनाशकारी कमांड, वह अनुमतियों (permissions) या हुक के अंतर्गत आनी चाहिए। एजेंट की पहुंच से रहस्यों को दूर रखना डेटा पर भी यही सिद्धांत लागू करता है: एजेंट से किसी फाइल को न पढ़ने के लिए न कहें, बल्कि ऐसी व्यवस्था करें कि फाइल पढ़ने योग्य ही न हो।
संक्षेप में। यह साबित करें कि फाइल लोड हो गई है, नियम को जांचने योग्य बनाएं, इसे उस चीज के पास रखें जिसे यह नियंत्रित करता है, और जब चूक की दर मायने रखती हो, तो इसे गद्य (prose) से बाहर निकालें। वह नियम जिसे एजेंट अनदेखा नहीं कर सकता, वह नियम है जिसे एजेंट से कभी पूछा ही नहीं गया था।
FAQ
Claude Code मेरी CLAUDE.md को अनदेखा क्यों करता है?
यह मान लेने से पहले कि इसे अनदेखा किया गया है, जाँचें कि क्या यह लोड हुआ था। /context चलाएँ और Memory files सूची देखें; जो फ़ाइल वहाँ नामंकित नहीं है, वह लॉन्च के समय लोड नहीं हुई थी। निर्देश फ़ाइलें सिस्टम प्रॉम्प्ट के बाद एक user message के रूप में भेजी जाती हैं और इन्हें enforced configuration के बजाय context के रूप में माना जाता है, इसलिए अनुपालन की कोई सख्त गारंटी नहीं है। अधिकांश वास्तविक मामले इन चार कारणों में से एक होते हैं: फ़ाइल ऐसी subdirectory में है जिसे agent ने कभी नहीं पढ़ा, दो फ़ाइलें आपस में असहमत हैं और model ने मनमाने ढंग से एक को चुन लिया, नियम इतना अस्पष्ट है कि किसी action के विरुद्ध उसकी जाँच नहीं की जा सकती, या आसपास का कोड नियम के विपरीत व्यवहार प्रदर्शित करता है।
क्या session के बीच में निर्देश फ़ाइल को edit करने से कुछ बदलता है?
conversation में पहले से मौजूद कॉपी के लिए नहीं। आपके working directory के ऊपर की फ़ाइलें लॉन्च के समय पूरी तरह लोड हो जाती हैं, इसलिए model के पास जो text है वह लॉन्च के समय वाला ही है। edit को लागू करने के लिए, नया session शुरू करें, या agent को अपने सामान्य file tools के साथ फ़ाइल पढ़ने के लिए कहें, जो वर्तमान version को एक नए message के रूप में conversation में डाल देता है। compaction के बाद project root फ़ाइल को disk से फिर से पढ़ा जाता है, इसलिए उस समय नया version भी आ जाता है।
जब root CLAUDE.md और nested CLAUDE.md असहमत हों तो कौन सी फ़ाइल प्रभावी होती है?
कोई भी नहीं, निश्चित रूप से। खोजी गई फ़ाइलें एक-दूसरे को override करने के बजाय context में जोड़ दी जाती हैं, जिन्हें filesystem root से लेकर आपकी working directory तक क्रमबद्ध किया जाता है, इसलिए सबसे नज़दीकी फ़ाइल को अंत में पढ़ा जाता है। विरोधाभासों को हल करने के लिए कोई precedence engine नहीं है, और Claude Code का documentation बताता है कि विरोधाभासी नियमों को मनमाने ढंग से हल किया जा सकता है। nested फ़ाइलों को ऐसे additions के रूप में लिखें जो उस path का नाम बताएं जिसे वे नियंत्रित करती हैं, और उन्हें outrank करने की कोशिश करने के बजाय विरोधाभास को हटा दें।
क्या मेरे निर्देश /compact के बाद बने रहते हैं?
यह इस पर निर्भर करता है कि वे कैसे लोड हुए थे। project root CLAUDE.md, unscoped नियम और auto memory को compaction के बाद disk से फिर से inject किया जाता है। paths: frontmatter वाले नियम और subdirectories में मौजूद CLAUDE.md फ़ाइलें तब तक खो जाती हैं जब तक कि कोई matching फ़ाइल फिर से न पढ़ी जाए। जो कुछ भी आपने केवल chat में टाइप किया है, वह तभी बना रहता है यदि summariser ने उसे संयोगवश सुरक्षित रखा हो। यदि किसी नियम को पूरे session के दौरान लागू रहना है, तो उसे बिना किसी paths: frontmatter के project root फ़ाइल में रखें।
किसी नियम को prose के बजाय hook कब बनाना चाहिए?
जब जाँच deterministic हो और चूकने की लागत एक छोटा script लिखने की लागत से अधिक हो। फ़ाइल path प्रतिबंध, commit से पहले आवश्यक commands, और निषिद्ध tool calls सभी इसके अंतर्गत आते हैं। एक PreToolUse hook जो status 2 के साथ exit होता है, वह tool call को पूरी तरह से block कर देता है और आपके stderr text को कारण के रूप में वापस model को सौंप देता है, इसलिए यह बना रहता है चाहे नियम context में कहीं भी हो या न हो। जो कुछ भी एक formatter या linter तय कर सकता है, उसे उस tool के अधीन होना चाहिए और निर्देश फ़ाइल से पूरी तरह हटा दिया जाना चाहिए।