AI Agents आपके .md rules को क्यों नज़रअंदाज़ करते हैं — CLAUDE.md, Cursor Rules और AGENTS.md को सच में काम करवाने का तरीक़ा

आप Claude Code से पूछते हैं, "क्या तुमने CLAUDE.md पढ़ी?" वो ख़ुशी-ख़ुशी जवाब देता है, "हाँ, पढ़ ली।" कुछ टर्न बाद, उस फ़ाइल का एक भी rule actually फ़ॉलो नहीं हो रहा होता — आपके project-specific commands, commit message conventions, deploy steps। सब चुपचाप ग़ायब हो जाते हैं।

यह सिर्फ़ Claude Code की समस्या नहीं है। वही drift Cursor के .cursor/rules, GitHub Copilot के .github/copilot-instructions.md, और Codex CLI के AGENTS.md में भी दिखता है — काफ़ी देर इस्तेमाल करने के बाद।

यह लेख समझाता है कि AI agents आपकी .md rule फ़ाइलों को क्यों नज़रअंदाज़ करते हैं — 5 मूल कारण, फिर बताता है quick rewrite तकनीकें और Hooks और sub-agents के साथ लंबा सिस्टमाइज़ेशन — सब ठोस उदाहरणों के साथ।

1. AI आपके rules को क्यों नज़रअंदाज़ करता है — 5 मूल कारण

1. Context window की structural सीमाएँ

LLM अपने input के हर token पर बराबर ध्यान नहीं देता। लंबे document के बीच में दबे instructions खो जाते हैं — यही famous "lost in the middle" effect है। जैसे ही आपकी CLAUDE.md ~200 लाइन पार करती है, बीच की चीज़ें practically ग़ायब हो जाती हैं।

2. लंबे sessions में Auto-compact

Claude Code में /compact feature है जो conversation history को compress करता है। जब यह automatically trigger होता है, तब system-prompt-level instructions तो बच जाते हैं, लेकिन CLAUDE.md की operational details summarize होकर गायब हो जाती हैं या पूरी तरह छूट जाती हैं। इसीलिए लंबे sessions के पिछले हिस्से में rule violations जमा होते हैं।

3. User के सीधे instructions को प्राथमिकता मिलती है

AI के लिए, "user ने अभी-अभी जो कहा" उस पर भारी पड़ता है "जो rule उसने 300 turns पहले पढ़ा था।" जिस पल user कहता है "बस कर दो" या "commit कर दो," उस पल आपका CLAUDE.md वाला "commit से पहले हमेशा confirm करो" rule कुचला जाता है।

4. अस्पष्ट या विरोधाभासी rules

"विनम्रता से लिखो" या "ठीक से handle करो" जैसे subjective निर्देश AI को अपनी मर्ज़ी से interpret करने पर छोड़ देते हैं, और नतीजा वो शायद ही होता है जो आप चाहते थे। इन्हें verifiable constraints के रूप में फिर से लिखें: "responses 3 लाइन के अंदर रखो," "Slack API के लिए chat.postMessage का इस्तेमाल करो," वगैरह।

5. फूली हुई, बिखरी हुई rule फ़ाइलें

CLAUDE.md, साथ में SPEC.md, साथ में README.md, और ऊपर से ढेर सारी अन्य .md फ़ाइलें — एक बार ये फैल जाएँ और हर एक लंबी हो जाए, तो AI इन्हें बराबर weight से नहीं पढ़ता। जब वही rule कई फ़ाइलों में हल्के अंतर के साथ होता है, AI सबसे "safe दिखने वाला" version चुन लेता है।

2. आपके rules सच में फ़ॉलो हो रहे हैं या नहीं — कैसे पता करें

पहले मौजूदा हालत check करें। नीचे के सवाल AI पर फेंकें और जवाब देखें:

AI का "मैंने पढ़ ली" या "मैं समझ गया" कहना कुछ नहीं बताता। क्या वह actually rules apply कर रहा है, यह अलग सवाल है — judge उसके दावों से नहीं, post-execution behavior से करें।

3. 5 मिनट में लागू होने वाले Quick fix

1. Rule फ़ाइल को 150 लाइन के अंदर compress करें

व्यवहार में, Claude Code लगभग 100 से 150 लाइन की CLAUDE.md को भरोसेमंदी से फ़ॉलो करता है। उससे ज़्यादा हो तो बाँट दें:

• Non-negotiable rules (10 से 20 लाइन) — CLAUDE.md के सबसे ऊपर
• Service-specific specs — SPEC-xxx.md में अलग करें
• History और background — docs/ directory में डाल दें

CLAUDE.md में सिर्फ़ "जो भूले तो आपदा" वाली चीज़ें रखें। बाक़ी detail linked फ़ाइलों में रह सकती है।

2. साफ़ priority markers जोड़ें

AI का ध्यान खींचने के लिए loud priority keywords का इस्तेमाल करें:

• CRITICAL — violation से production incident
• MUST — हमेशा फ़ॉलो करें
• SHOULD — डिफ़ॉल्ट पर फ़ॉलो करें
• NICE TO HAVE — गुंजाइश हो तो ही

एक लाइन जैसे "CRITICAL: production DB पर destructive queries के लिए explicit approval ज़रूरी है" लंबी फ़ाइल में दबी होने पर भी नज़रअंदाज़ करना मुश्किल होता है।

3. Chat में ही फिर से ज़ोर दें

Session की शुरुआत में एक one-liner डाल दें जैसे "शुरू करने से पहले, CLAUDE.md के 3 सबसे ज़रूरी rules बताओ।" इससे वे rules recent context में आ जाते हैं और बाक़ी session टिके रहते हैं।

4. Dangerous operations को TodoWrite में लॉग करें

AI agent के TodoWrite tool (या आपके tool में equivalent task-tracking feature) का उपयोग करके "rule check" को explicit step के रूप में शामिल करें। दिखाई देगा तो "भूल गया" बहुत कम होगा।

4. लंबे-समय का सिस्टमाइज़ेशन — Hooks, sub-agents, slash commands

केवल prose-based rules से इतनी ही दूर जाया जा सकता है। "AI से rules फ़ॉलो करवाने" से हटकर "environment से ही उन्हें ज़बरदस्ती लागू करवाने" पर शिफ़्ट होना कहीं ज़्यादा भरोसेमंद है।

1. Claude Code Hooks से mechanical enforcement

Claude Code का Hooks feature आपको specific tool calls से पहले या बाद में arbitrary scripts चलाने देता है। आप ऐसा setup बना सकते हैं जहाँ AI ख़ुद rule भूल जाए तब भी system उसे रोक दे।

उदाहरण के लिए, PreToolUse hook से:

• Bash चलने से पहले dangerous commands (rm -rf, git push --force) detect करके ब्लॉक करें
• Edit से किसी target फ़ाइल को छूने से पहले file permissions या lock state check करें
• Commit से पहले project-specific tests चलाएँ और fail पर abort करें

विनम्रता से prose में पूछना Hooks की mechanical enforcement के सामने कोई मुक़ाबला नहीं है।

2. Sub-agents से concerns अलग करें

Claude Agent SDK या Cursor के sub-agent capabilities से एक dedicated "rule-audit agent" बनाएँ। दो-stage flow — main agent code लिखे, audit agent review करे — main agent भूल जाए तब भी rule violations पकड़ लेता है।

Sub-agent को सिर्फ़ एक छोटा audit-focused prompt चाहिए, इसलिए उसकी rule-recognition rate ऊँची रहती है। यही असली कुंजी है।

3. Routines को custom slash commands में codify करें

"हर commit से पहले ये 3 checks चलाओ" जैसे बार-बार के workflows slash command (/precommit, वग़ैरह) के लिए perfect हैं। User /precommit लिखता है, और AI एक तय sequence चलाता है। हर बार rule फ़ाइल फिर से पढ़ने की ज़रूरत नहीं।

4. Automated scripts से violations detect करें

CI में या pre-commit hook के रूप में forbidden patterns की grep-आधारित detection चलाएँ। उदाहरण:

• Production code में बचे हुए console.log
• Hard-coded API keys
• ग़ायब copyright headers

AI पर भरोसा मत करो — मशीनों को ढूँढने दो। यह आपकी आख़िरी defense line है।

5. हर tool के लिए best practices

Universal rule है "छोटा, ठोस, प्राथमिकता वाला।" Filenames और locations tool के साथ बदलते हैं, पर लिखने के सिद्धांत वही हैं।

6. Rule-design के तीन anti-patterns

1. "Best practices फ़ॉलो करो।"

किसकी best practices? AI default में अपने training data के औसत पर जाता है, मतलब आपको सबसे common denominator मिलता है। Project-specific quirks कभी shamil नहीं होते। ठोस do's और don'ts लिखें।

2. एक ही rule कई फ़ाइलों में duplicate

अगर आपके "commit conventions" CLAUDE.md, SPEC.md और README.md में हैं, तीनों copies हल्के-हल्के अलग हो जाएँगे और AI को confuse करेंगे। एक source of truth चुनें और बाक़ी सब जगह से उसी को link करें।

3. हर चीज़ पर "ABSOLUTELY MUST" ठप्पा

अगर सब कुछ "absolute" है, तो AI prioritize करने की क्षमता खो देता है। "CRITICAL" को सिर्फ़ सच में catastrophic चीज़ों के लिए बचाएँ; बाक़ी को सामान्य prose में रहने दें। ज़ोर देने की inflation होती है — इसे कम ही रखें।

सारांश

जब AI agents आपके .md rules को नज़रअंदाज़ करते हैं, तो लगभग हमेशा वजह structural constraints और rule-design की समस्याएँ होती हैं, AI का आलस नहीं। ज़्यादातर मामले quick fixes से सुलझ जाते हैं — 150 लाइन के अंदर compress करें, priority markers जोड़ें, chat में फिर से ज़ोर दें। बाक़ी जो सच में critical rules बचें, उन्हें mechanical enforcement पर शिफ़्ट करें: Hooks, sub-agents, slash commands और automated detection scripts।

"अगर rules फ़ॉलो नहीं हो रहे, तो ऐसा system बनाओ जो उन्हें ज़बरदस्ती लागू करे" — AI agents चलाने का नया common sense।

FAQ

Q1. CLAUDE.md की ideal लंबाई क्या है?

व्यवहार में, 100 से 150 लाइन। 200 के पार जाएँ तो SPEC-xxx.md वग़ैरह में बाँट दें। बिल्कुल ऊपर "top 5 critical rules" का summary रखना भूलने के ख़िलाफ़ अच्छी insurance है।

Q2. Cursor में .cursorrules इस्तेमाल करूँ या .cursor/rules/*.mdc?

नए setup के लिए .cursor/rules/*.mdc। एक rule प्रति फ़ाइल, glob patterns से scope करें कि कौन-सा rule कहाँ apply होता है। Legacy single-file .cursorrules समय के साथ फूलने लगता है।

Q3. क्या लंबे rules से AI ज़्यादा strict होता है?

उल्टा। फ़ाइल जितनी लंबी, बीच का हिस्सा उतना ही dilute। छोटे, essential rules अगर prominently (सबसे ऊपर) रखे जाएँ, तो higher rate पर फ़ॉलो होते हैं।

Q4. एक ही project पर कई AI tools (Claude Code + Cursor) इस्तेमाल करूँ तो?

Pragmatic जवाब: हर tool की config फ़ाइल में वही summary डालें और details एक shared SPEC.md में centralize करें। पूरी तरह unified solution अभी नहीं है (मई 2026 तक)।

Q5. AI जब "मैंने पढ़ ली" कहता है, क्या वो सच में नहीं पढ़ रहा?

"मैंने पढ़ ली" का दावा और actual runtime behavior अलग चीज़ें हैं। Section 2 की diagnostic methods से execution-level recognition verify करें।