SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor · अपडेटेड 2026-10-26

coding agents तुमच्या सूचना का पाळत नाहीत?

Instruction file मध्ये stop लिहिले असूनही agent पुढे का जातो? context window, अस्पष्ट नियम, विरोधी code आणि compaction तपासण्याची निदानपद्धत जाणून घ्या.

कोडिंग agents तुमच्या सूचना का दुर्लक्षित करतात

कोडिंग agents तुमच्या सूचना चार कारणांमुळे दुर्लक्षित करतात. त्यापैकी कोणतेही कारण तुम्ही खूप नम्र होता हे नाही. नियम context window मध्ये कधीच आला नव्हता. एखाद्या कृतीच्या संदर्भात तपासता येईल इतका नियम अस्पष्ट होता. Context मधील दुसऱ्या मजकुराने त्या नियमाचा विरोध केला होता; बहुतेकदा agent ने नुकताच वाचलेला code त्याला विरोध करत होता. किंवा नियम अजूनही loaded आहे, पण सध्याच्या turn पासून खूप मागे आहे. त्यामुळे agent जवळ असलेल्या मजकुरावरून काम करत आहे.

प्रत्येक कारणासाठी वेगळा उपाय आहे. त्यामुळे पहिले काम म्हणजे ही कारणे वेगळी ओळखणे. Capital letters आणि IMPORTANT हा शब्द निदान ठरत नाहीत. खालील स्पष्टीकरणात Claude Code चे उदाहरण घेतले आहे, कारण October 2026 पर्यंत त्याचे loading आणि compaction behaviour सविस्तर documented आहे. इतर tools मधील तपशील वेगळे असू शकतात, पण एकूण वर्तन सारखेच असते.

आधी दोन terms समजून घेऊ. context window म्हणजे एखाद्या turn मध्ये model ला दिसणारा मजकुराचा block. यात system prompt, तुमच्या instruction files, conversation आणि agent ने वाचलेली प्रत्येक file यांचा समावेश होतो. harness म्हणजे model भोवतीचे program. ते disk वरील files वाचते आणि तो block तयार करते. या post मधील जवळजवळ प्रत्येक तक्रार प्रत्यक्षात model बद्दल नसून harness बद्दल आहे.

तुमची instruction file ही message आहे, setting नाही

Instruction file ही configuration नसते. Runtime मधील कोणताही घटक CLAUDE.md वाचून त्याची अंमलबजावणी करत नाही. Harness ही file disk वरून वाचतो आणि तिचा मजकूर conversation मध्ये paste करतो. Claude Code मध्ये हा मजकूर system prompt नंतर ठेवलेल्या user message म्हणून दिला जातो. त्यामुळे model तुमचे नियम तुम्ही टाइप केलेल्या इतर कोणत्याही मजकुराप्रमाणेच पाहतो.

याचा एक अस्वस्थ करणारा परिणाम होतो. Window मधील इतर प्रत्येक मजकुराशी तुमचे नियम समान पातळीवर स्पर्धा करतात. एखादा नियम हा एक दावा असतो. Agent ने नुकतीच उघडलेली file हा पुरावा असतो. दोन्हीमध्ये विसंगती असल्यास पुरावा अनेकदा प्रभावी ठरतो. कोणताही error निर्माण होत नाही, कारण model च्या दृष्टीने काहीही चुकीचे घडलेले नसते.

अधिकृत documentation हे स्पष्टपणे सांगते: instruction files ना enforced configuration म्हणून नव्हे, तर context म्हणून हाताळले जाते. Model ने काहीही ठरवले तरी एखादी action रोखायची असल्यास sentence नव्हे, तर hook आवश्यक असतो. ही ओळ लक्षात ठेवा. या post च्या शेवटी दिलेल्या बहुतेक उपायांमध्ये हीच ओळ विशिष्ट परिस्थितीला लागू केली आहे.

कोणत्या instruction files लोड होतात आणि कधी

Claude Code तुम्ही तो सुरू केलेल्या directory पासून directory tree मध्ये वरच्या दिशेने जाते. Filesystem root पासून तुमच्या working directory पर्यंतच्या प्रत्येक CLAUDE.md आणि CLAUDE.local.md फाइलचा संपूर्ण मजकूर launch वेळी लोड होतो. त्या क्रमाने एकत्र केल्या जातात. त्यामुळे तुम्ही Claude Code सुरू केलेल्या directoryच्या सर्वात जवळची फाइल शेवटी वाचली जाते. तसेच, प्रत्येक directoryमध्ये .local फाइल मुख्य फाइलनंतर जोडली जाते.

तुमच्या working directoryच्या खालील subdirectoriesमधील files वेगळ्या पद्धतीने लोड होतात. त्या launch वेळी लोड होत नाहीत. Agent त्या directoryमधील file वाचतो तेव्हा त्या लोड होतात. .claude/rules/ मधील paths: frontmatter field असलेल्या path-scoped rules साठीही हेच लागू होते. Matching file वाचली जाते तेव्हा ते contextमध्ये येतात; प्रत्येक turnला नाहीत. v2.1.309 पासून अशा प्रकारे लोड होणाऱ्या files साठी प्रति-file आकाराची मर्यादा देखील आहे. 200K context windowमध्ये ही मर्यादा 40,000 characters आहे. मोठी file असल्यास agentला तिचा फक्त सुरुवातीचा भाग मिळतो. त्यामुळे मोठ्या nested fileच्या शेवटी असलेले rules contextमध्ये कदाचित पोहोचणार नाहीत.

नोंदवलेल्या failuresपैकी मोठा भाग या एका फरकामुळे स्पष्ट होतो. तुम्ही packages/api/CLAUDE.md मध्ये rule ठेवता, APIबद्दल प्रश्न विचारता आणि agent packages/api/ अंतर्गत कोणतीही file न उघडताच उत्तर देतो. Rule दुर्लक्षित केलेला नसतो. तो contextमध्ये कधी आला नसतो. तुमच्या repositoryमध्ये monorepoमधील प्रति-package instruction files द्वारे guidance विभागलेले असल्यास, प्रत्येक वेळी सर्वप्रथम हे तपासा.

AGENTS.md वर standardise केलेल्या repositoriesवर आणखी एक loading trap लागू होतो. v2.1.277 पासून Claude Code AGENTS.md ला defaultने project instructions म्हणून वाचतो. मात्र तुमच्या working directoryमध्ये किंवा तिच्या वरील कोणत्याही directoryमध्ये CLAUDE.md, .claude/CLAUDE.md किंवा CLAUDE.local.md नसतील तरच हे घडते. तुमची वैयक्तिक ~/.claude/CLAUDE.md यासाठी ग्राह्य धरली जात नाही. यापैकी कोणतीही एक file जोडा, अगदी वैयक्तिक notesसाठीची CLAUDE.local.md असली तरी, Claude Code त्याऐवजी तुमच्या CLAUDE.md files वाचतो आणि AGENTS.md पूर्णपणे वगळतो. दोन्ही files लोड करण्यासाठी /config मध्ये Project instructions म्हणून claude-md-and-agents-md सेट करा. v2.1.277 पूर्वीच्या versionsमध्ये किंवा CLAUDE.md ठेवायची असल्यास, bridge म्हणून CLAUDE.md वापरा. त्याच्या पहिल्या ओळीत @AGENTS.md असते. यामुळे launch वेळी file import होते आणि त्याखाली Claude-specific notes ठेवता येतात. अतिरिक्त मजकूर जोडायचा नसल्यास symlink देखील चालतो. त्या fileमध्ये सुरुवातीपासून नेमके काय ठेवायचे हा वेगळा प्रश्न आहे. त्याची माहिती agent instructions आणि human documentation वेगवेगळे करण्याबद्दल दिली आहे.

फाइल पुन्हा लिहिण्यापूर्वी ती लोड झाली आहे याची खात्री करा

Agent ला फाइल दिसत आहे याचा पुरावा मिळेपर्यंत मजकुरात बदल करू नका. यासाठी दोन तपासण्या आहेत. त्यापैकी सोपी तपासणी आधी करा.

Session मध्ये /context चालवा. हे सध्याच्या window ची category नुसार माहिती दाखवते. Launch वेळी लोड झालेल्या प्रत्येक instruction file चे नाव Memory files यादीत दिसते. ही यादीत नसलेली फाइल launch वेळी लोड झालेली नव्हती. त्यामुळे एखादी प्रक्रिया ती फाइल लोड करेपर्यंत तिच्यात लिहिलेल्या कोणत्याही मजकुराचा परिणाम होणार नाही. Subdirectory मधील nested file या यादीत दिसत नाही, कारण ती मागणीनुसार लोड होते. ती लोड झाल्यावर तिच्या path सह Loaded ओळ terminal मध्ये दिसते. /memory फाइलची स्थाने दाखवते आणि त्या फाइल्स editing साठी उघडते. त्यात अद्याप अस्तित्वात नसलेल्या फाइल्सचाही समावेश असतो.

अधिक निश्चित माहिती हवी असल्यास loads चे logging करा. प्रत्येक वेळी CLAUDE.md किंवा rules file context मध्ये आली की InstructionsLoaded hook event सुरू होतो. त्याचा matcher load का झाला ते दाखवतो: 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 जोडते. काम करताना tail -f /tmp/instructions-loaded.log वापरून त्यावर लक्ष ठेवा. या event चा exit status दुर्लक्षित केला जातो. त्यामुळे hook फक्त निरीक्षण करू शकतो; तो प्रक्रिया थांबवू शकत नाही. ज्या session मध्ये nested file लोड होणे अपेक्षित होते, त्या session च्या log मध्ये ती फाइल दिसली नाही तर मजकूर पुन्हा लिहिणे थांबवा. समस्या file placement मध्ये आहे. एक अपवाद आहे: Claude Code ने थेट वाचलेले AGENTS.md हे event सुरू करत नाही. त्यामुळे त्याचा path /memory मध्ये शोधा. CLAUDE.md मधून import केलेले AGENTS.md मात्र नेहमीप्रमाणे हे event सुरू करते.

दीर्घ सत्राचा तुमच्या नियमांवर होणारा परिणाम

येथे दोन स्वतंत्र परिणाम लागू होतात आणि त्यांच्यासाठी वेगवेगळे उपाय आवश्यक असतात.

अंतर. Compaction होईपर्यंत, turn 1 वर नमूद केलेला नियम turn 90 वरही context window मध्ये असतो. मात्र त्या वेळी तुमच्या सध्याच्या कामाशी अधिक संबंधित आणि अधिक अलीकडच्या 90 turns मधील मजकुराशी तो स्पर्धा करत असतो. Compaction झाल्यानंतर, तुम्ही chat मध्ये टाइप केलेला एखादा नियम context window मध्ये अजिबात नसू शकतो. Claude Code च्या स्वतःच्या documentation नुसार, संभाषणाच्या सुरुवातीतील सूचना हरवू शकतात. हा खालील दुसरा परिणाम आहे. Distance configure करून काढून टाकता येत नाही; परंतु ते मोजता येते. तेच काम नवीन session मध्ये चालवा. नवीन session मध्ये नियम लागू राहतो आणि दीर्घ session मध्ये बराच पुढे गेल्यावर लागू होत नसेल, तर कारण distance किंवा compaction असण्याची शक्यता आहे.

Compaction. Context window भरल्यावर harness आतापर्यंतच्या संभाषणाचा सारांश तयार करते आणि त्या सारांशापासून पुढे सुरू ठेवते. काय टिकून राहते हे summariser ने महत्त्वाचे ठरवलेल्या बाबींवर अवलंबून असते. तुम्हाला महत्त्वाच्या वाटणाऱ्या बाबी आणि summariser ला महत्त्वाच्या वाटणाऱ्या बाबी समान असतीलच असे नाही. Claude Code प्रत्येक mechanism नुसार याचा परिणाम स्पष्ट करते आणि त्यांतील फरक मोठे आहेत. Project root CLAUDE.md आणि unscoped rules compaction नंतर disk वरून पुन्हा inject केले जातात. Auto memory disk वरून पुन्हा inject केली जाते. paths: frontmatter असलेले नियम matching file पुन्हा वाचली जाईपर्यंत हरवतात. Subdirectories मधील nested CLAUDE.md files त्या subdirectory मधील एखादी file पुन्हा वाचली जाईपर्यंत हरवतात.

त्या तक्त्यानुसार तुमच्या सूचनांना क्रम द्या; त्यावरून fragility चा क्रम स्पष्ट होतो. तुम्ही फक्त chat मध्ये टाइप केलेला नियम session मधील सर्वात नाजूक घटक असतो. Summary मध्ये तो राहिला तरच तो टिकतो. packages/api/CLAUDE.md मधील नियम त्यानंतर येतो. तो एकदा load होतो, summary मध्ये हरवतो आणि त्या directory मधील पुढील read वेळीच परत येतो. Project root file मधील नियम सर्वाधिक टिकाऊ असतो, कारण तो प्रत्येक वेळी disk वरून पुन्हा वाचला जातो.

म्हणून एखादी सूचना संपूर्ण session मध्ये लागू राहणे आवश्यक असेल, तर ती project root file मध्ये, paths: frontmatter शिवाय, ठेवावी. उर्वरित सर्व बाबी जाणीवपूर्वक निवडलेला tradeoff असतात. Context window मध्ये काय टिकून राहते याचे व्यवस्थापन यामध्ये /compact साठी focus argument आणि असंबंधित tasks मधील /clear यांवर भर दिला आहे. या दोन्ही गोष्टींमुळे summariser ला तुमचे नियम कोणते होते हे ठरवण्याची वारंवारता बदलते.

सभोवतालचा कोड नियमावर मात का करतो

ही अशी चूक आहे जिचे वर्णन लोक सर्वाधिक करतात, पण निदान सर्वात कमी वेळा करतात. तुमच्या फाइलमध्ये database access repository layer मधून होतो असे नमूद आहे. Agent असा handler लिहितो जो ORM (object relational mapper) ला थेट call करतो. Style च्या कारणास्तव तुमच्याकडे दुर्लक्ष झालेले नसते. उपलब्ध पुराव्याने तुमच्या नियमाला मागे टाकलेले असते.

नियम एखादे प्राधान्य सांगतो. कोड त्याचे एक उदाहरण दाखवतो. Agent ज्या module मध्ये बदल करणार आहे त्यातील तीन फाइल्स उघडतो आणि तिन्ही फाइल्स ORM ला थेट call करत असतील, तर context मध्ये एका बाजूला एक abstract वाक्य आणि दुसऱ्या बाजूला अलीकडची, task शी जुळणारी तीन ठोस उदाहरणे असतात. स्थानिक pattern ची नक्कल करणे हे सहसा योग्य behaviour असते. येथे ते चुकीचे ठरते, कारण context ला माहीत नसलेली एक गोष्ट तुम्हाला माहीत असते: त्या फाइल्स legacy आहेत.

म्हणून ती माहिती नियमात लिहा. स्वतःच्या counter-evidence चा उल्लेख करणारे नियम वास्तविक repository मध्ये टिकतात. केवळ preference सांगणारे नियम टिकत नाहीत.

नवीन database access app/repositories/ मधून करा. app/legacy/ अंतर्गत असलेल्या फाइल्स अजूनही ORM ला थेट call करतात. तो जुना code आहे; तो pattern नाही. त्याची नक्कल करू नका.

हे काम दुसरे वाक्य करते. Agent ला ते code सापडण्यापूर्वीच, त्याला काय सापडणार आहे आणि ते कसे समजून घ्यायचे हे ते सांगते. तुमच्या repository मध्ये स्पष्टपणे विरोधाभास दाखवणाऱ्या कोणत्याही नियमासाठी हीच दुरुस्ती लागू होते: तुमच्या history मध्ये न पाळली जाणारी commit style, तुमच्या suite पैकी निम्म्याने दुर्लक्षित केलेली test layout किंवा केवळ नवीन code मध्ये लागू असलेली import convention. जिथे code आणि फाइलमध्ये विसंगती असेल, तिथे ती विसंगती फाइलमध्ये स्पष्टपणे नमूद करा.

अस्पष्ट नियम तपासता येत नाही, त्यामुळे त्याचे पालनही करता येत नाही

"स्वच्छ कोड लिहा." "अनावश्यकपणे गुंतागुंतीची रचना करू नका." "ते सोपे ठेवा." "Migrations करताना काळजी घ्या." यांपैकी कोणताही नियम एखाद्या विशिष्ट कृतीच्या आधारे agent किंवा तुम्ही तपासू शकत नाही. Agent ला स्वतःच्या output विरुद्ध तपासता न येणारा नियम दिल्यास तो अंदाज लावतो आणि तुम्ही त्या अंदाजाचे मूल्यमापन ठोस निकषांऐवजी जाणिवेवर करता.

तुमच्या file मधील प्रत्येक ओळीला हा test लागू करा. नियम मोडल्यावर non-zero exit होईल अशी shell command लिहा. ती command लिहिता येत नसेल, तर तो नियम checkable नाही. या जोड्यांची तुलना करा:

  • Checkable नाही: "Functions लहान ठेवा." Checkable: "60 lines पेक्षा मोठ्या function च्या वर ती इतकी मोठी का आहे हे स्पष्ट करणारी comment आवश्यक आहे."
  • Checkable नाही: "तुमचे बदल test करा." Checkable: "Task पूर्ण झाल्याचे सांगण्यापूर्वी npm test चालवा आणि failure count द्या."
  • Checkable नाही: "Files व्यवस्थित ठेवा." Checkable: "HTTP handlers src/api/handlers/ मध्येच असतात. त्या directory मध्ये इतर काहीही ठेवू नका."
  • Checkable नाही: "Code योग्य प्रकारे format करा." Checkable: ".ts files मध्ये 2 space indentation वापरा."

"अनावश्यकपणे गुंतागुंतीची रचना करू नका" हा नियम लोक सर्वप्रथम सोडून देतात, कारण त्याची दुरुस्ती लहान वाक्य नसते, तर मोठे वाक्य असते: प्रत्यक्षात काम करणारा सर्वात लहान बदल म्हणजे काय, हे स्पष्टपणे लिहिल्यास agent स्वतःच्या diff विरुद्ध तपासता येतील असे निकष मिळतात.

Size ची समस्या वेगळ्या रूपात दिसते. Claude Code च्या guidance मध्ये प्रत्येक instruction file 200 lines पेक्षा कमी ठेवण्याचे लक्ष्य दिले आहे आणि मोठ्या files मुळे adherence कमी होते, हे स्पष्टपणे नमूद केले आहे. 700 lines ची file अधिक ठोस instruction नसते. ती एकमेकांशी विरोध करण्याची अधिक शक्यता असलेल्या 700 claims ची file असते. तसेच प्रत्येक turn मध्ये ती तुमच्या window वर मोजली जाते आणि हे तुमच्या token usage मध्ये थेट दिसते. प्रत्येक rule reader सहज scan करू शकेल अशा heading खाली ठेवून file ची रचना करणे agent कृती करू शकेल अशी instruction file लिहिणे यात समाविष्ट आहे. याहून चांगले म्हणजे वर्णन करणारे, instruction न देणारे भाग काढून टाका: handlers आणि models कुठे आहेत याचा directory tour हा agent repository च्या parsed map मधून गरजेनुसार पाहू शकतो. त्यामुळे तो प्रत्येक turn मध्ये ही माहिती window मध्ये ठेवण्याची गरज राहत नाही.

दहा मिनिटांत समस्येचे निदान कसे करावे

हे आदेश याच क्रमाने चालवा. शेवटच्या चरणावर थेट जाण्यामुळे नियमांची मोठी फाइल तयार होते, पण समस्या तरीही सुटत नाही.

  1. फाइल लोड झाली आहे का ते तपासा. /context चालवा आणि Memory files यादी वाचा. Nested file साठी terminal मध्ये तिची Loaded ओळ शोधा. फाइल तेथे नसेल, तर तिचे स्थान दुरुस्त करा आणि थांबा. या यादीतील इतर कोणताही चरण अद्याप लागू होत नाही.
  2. नवीन session मध्ये पुन्हा समस्या निर्माण करा. नवीन session सुरू करा आणि नियम लागू व्हायला हवा असे सर्वात छोटे task द्या. येथे नियम लागू होऊन दीर्घ session मध्ये अपयश येत असेल, तर समस्या context distance किंवा compaction मध्ये असण्याची शक्यता आहे. येथेही अपयश आल्यास समस्या स्वतः नियमात आहे.
  3. स्पर्धक सूचना काढून टाका. तोच बदल अशा directory मध्ये करण्यास सांगा जिथे विद्यमान code आधीपासून त्या नियमाचे पालन करतो. पालन पुन्हा सुरू झाल्यास, आसपासचा code तुमच्या वाक्यापेक्षा अधिक प्रभावी ठरत होता.
  4. विरोधाभास शोधा. एकाच behaviour साठी दोन files मध्ये वेगवेगळ्या सूचना असणे ही नोंदवलेली failure mode आहे. Model त्यापैकी कोणतीही सूचना अनियंत्रितपणे निवडू शकतो आणि तसे केल्याचे तुम्हाला सांगणार नाही.
  5. नियम तपासता येईल असा करा आणि पुन्हा चाचणी घ्या. नियम concrete path आणि condition सह पुन्हा लिहा. पालनात मोठी सुधारणा झाल्यास, कारण 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 मध्ये वेगवेगळ्या सूचना आढळल्यास तीच तुमची bug आहे. त्यापैकी एक delete करा. अधिक कडक wording वापरून त्यांना क्रम देण्याचा प्रयत्न करू नका, कारण त्यासाठी कोणतेही ranking engine उपलब्ध नाही. Claude Code v2.1.283 किंवा त्यानंतरच्या आवृत्तीत /doctor prompt-audit ही search तुमच्या instruction files, rules आणि skills मध्ये अधिक व्यापकपणे चालवते आणि proposed edits सह contradictions दाखवते. तुम्ही सांगितल्याशिवाय ती कोणताही बदल करत नाही.

अंमलबजावणीच्या प्रभावानुसार उपाय

खालील प्रत्येक टप्प्याचा परिणाम त्याच्या वरच्या टप्प्यापेक्षा अधिक असतो आणि तो लागू करण्यासाठी अधिक खर्च येतो. एखादा नियम पुन्हा शब्दबद्ध करणे सोपे असल्यास वरच्या टप्प्यापासून सुरुवात करा. एखादा नियम इतका महत्त्वाचा झाल्यावर लगेच पुढे जा की अधूनमधून होणाऱ्या चुका स्वीकारता येणार नाहीत.

  1. नियम ठोस करा. एखादा path, command किंवा condition स्पष्टपणे नमूद करा. आधी दाखवल्याप्रमाणे repository मध्ये agent ला सापडणारे विरुद्ध पुरावेही जोडा. यासाठी कोणताही अतिरिक्त खर्च नाही आणि यामुळे अपेक्षेपेक्षा अधिक प्रकरणे सुटतात.
  2. नियम ज्यावर लागू होतो त्याच्या जवळ तो ठेवा. Nested CLAUDE.md, .claude/rules/ मधील path-scoped rule किंवा file च्या सुरुवातीला असलेली comment वापरा. त्यामुळे नियम ज्या code वर लागू होतो तो code वाचतानाच नियमही वाचला जातो. यातील तडजोड स्वीकारा: अशा प्रकारे load केलेली कोणतीही माहिती पुढील compaction वेळी काढून टाकली जाते आणि पुढील matching read वेळी पुन्हा येते.
  3. अंमलबजावणी hook मध्ये हलवा. Prose विनंती करते. Hook निर्णय घेतो. Hooks निश्चित lifecycle events वेळी code म्हणून चालतात आणि model कोणता निष्कर्ष काढतो याची पर्वा न करता लागू होतात.
  4. नियम deterministic tool कडे द्या आणि prose काढून टाका. Formatting, import order, line length, प्रतिबंधित imports आणि commit message ची रचना यांसाठी हे लागू होते. ruff format, prettier --write, eslint किंवा pre-commit hook वापरा. Formatter प्रत्येक वेळी योग्य असतो आणि त्यासाठी शून्य tokens लागतात. वाक्य बहुतेक वेळा योग्य असते, पण प्रत्येक turn वेळी tokens लागतात.

Step 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 0

chmod +x .claude/hooks/guard-migrations.sh चालवा. त्यानंतर नवीन session सुरू करा आणि agent ला migrations/ अंतर्गत असलेली file edit करण्यास सांगा. 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 नसलेल्या साध्या prohibition साठी तुमच्या settings मधील permissions.deny हेच काम script maintain न करता करते. तसेच, permission modes तुमची प्रथम विचारणा न करता काय चालवायचे हे ठरवतात. एखादी instruction user message ऐवजी system prompt स्तरावर असणे खरोखर आवश्यक असल्यास --append-system-prompt ती तेथे ठेवतो. मात्र हा launch flag आहे आणि प्रत्येक नवीन session साठी तो पुन्हा pass करावा लागतो. त्यामुळे तो interactive work पेक्षा scripts साठी अधिक योग्य आहे.

तुम्ही सूचनांनी काय दूर करू शकत नाही

यातील कोणता भाग तुमच्या नियंत्रणात आहे, हे स्पष्ट ठेवा. Placement, phrasing, files मधील conflicts आणि file size या लेखकाच्या समस्या आहेत आणि त्यांच्यासाठी लेखकानेच सुधारणा कराव्या लागतात. उरलेला भाग model behaviour आहे. अधिक चांगली wording केल्याने तो दूर होणार नाही.

Agreement म्हणजे compliance नाही. Agent एखादा rule मान्य करेल, तो तुम्हाला योग्य रीतीने पुन्हा सांगेल आणि दोन tool calls नंतर तो मोडेल. त्या acknowledgement साठी कोणताही प्रयत्न लागत नाही आणि त्यावरून पुढील वर्तनाचा अंदाज येत नाही. त्याला सुधारणा समजू नका आणि test म्हणूनही मोजू नका.

काही सवयी टिकून राहतात. Comments जोडणे, defensive error handling जोडणे, शेवटी summary लिहिणे आणि obvious next command चालवणे यांसारख्या सवयी rule ने प्रतिबंधित केल्यानंतरही परत दिसतात. त्यांचे प्रमाण शून्य होत नाही; ते कमी होते. स्वतःचा rate मोजण्यासाठी तेच task fresh sessions मध्ये दहा वेळा चालवा आणि violations मोजा. जिथे ही संख्या शून्य असणे आवश्यक आहे, तिथे तो rule prompt मधून काढावा लागतो. कामाचा काही भाग अजून बाकी असताना job finished म्हणणे हीदेखील याच प्रकारची सवय आहे. तिच्यासाठी verbal सुधारणा पुरेशी नाही. रचना बदलावी लागते: unlazy skill त्या sentence ऐवजी Depth Tree वापरते आणि agent ने done म्हणण्यापूर्वी clear करावयाच्या gate files वापरते.

तुमचे स्वतःचे session उदाहरण बनते. Agent ने turn 12 वर rule मोडला आणि तुम्ही ते तसेच जाऊ दिले, तर तो violation context मध्ये demonstration म्हणून राहतो आणि rule पेक्षा तो अधिक अलीकडचा असतो. Violation दिसताच तो दुरुस्त करा. दुरुस्ती न केलेला violation session च्या उर्वरित भागाला तोच नमुना शिकवतो.

Instruction file ही security boundary नाही. ती behaviour ला दिशा देते; enforcement करत नाही. ज्या गोष्टी चुकल्यास मोठे नुकसान होऊ शकते, जसे credentials किंवा destructive commands, त्या permissions किंवा hook मध्ये हाताळल्या पाहिजेत. Keeping secrets out of reach of an agent हाच principle data वर लागू करते: agent ला file वाचू नको असे सांगू नका; ती file वाचता येणार नाही अशी व्यवस्था करा.

थोडक्यात: file load झाल्याचा पुरावा द्या, rule तपासता येईल असा करा, तो ज्या गोष्टीवर लागू होतो तिच्या जवळ ठेवा आणि miss rate अजूनही महत्त्वाचा असेल, तर तो prose मधून काढा. Agent ज्याकडे दुर्लक्ष करू शकत नाही, असा rule agent कडून कधी मागितलाच गेला नव्हता.

FAQ

Claude Code माझ्या CLAUDE.md कडे दुर्लक्ष का करते?

दुर्लक्ष झाले असे गृहीत धरण्यापूर्वी ती फाइल लोड झाली आहे का ते तपासा. /context चालवा आणि Memory files यादी पाहा; या यादीत नाव नसलेली फाइल launch वेळी लोड झालेली नव्हती. Instruction files या system prompt नंतर user message म्हणून दिल्या जातात आणि enforced configuration ऐवजी context म्हणून हाताळल्या जातात. त्यामुळे त्यांचे काटेकोर पालन होईल याची हमी नसते. प्रत्यक्षात बहुतेक प्रकरणे चारपैकी एका कारणामुळे घडतात: agent ने ज्या subdirectory मधून कधीही वाचले नाही तिथे फाइल असते, दोन फाइल्समध्ये विसंगती असते आणि model त्यापैकी एक मनमानीपणे निवडतो, एखादा नियम कृतीशी पडताळता येईल इतका स्पष्ट नसतो, किंवा आजूबाजूचा code त्या नियमाच्या विरुद्ध उदाहरण दाखवतो.

सत्राच्या मध्यात instruction file संपादित केल्याने काही बदल होतो का?

संभाषणात आधीच आलेल्या copy वर नाही. तुमच्या working directory वरील फाइल्स launch वेळी पूर्णपणे लोड होतात. त्यामुळे model कडे असलेला मजकूर launch वेळेचा असतो. केलेला बदल वापरण्यासाठी नवीन session सुरू करा किंवा agent ला त्याच्या नेहमीच्या file tools वापरून फाइल वाचण्यास सांगा. त्यामुळे सध्याची आवृत्ती fresh message म्हणून संभाषणात येते. compaction नंतर project root file disk वरून पुन्हा वाचली जाते. त्यामुळे त्या वेळी नवीन आवृत्तीही उपलब्ध होते.

root CLAUDE.md आणि nested CLAUDE.md मध्ये मतभेद असल्यास कोणती फाइल लागू होते?

विश्वसनीयपणे कोणतीही नाही. सापडलेल्या फाइल्स एकमेकींना override करण्याऐवजी context मध्ये जोडल्या जातात. त्या filesystem root पासून working directory पर्यंतच्या क्रमाने जोडल्या जातात. त्यामुळे सर्वात जवळची फाइल फक्त शेवटी वाचली जाते. विरोधाभास सोडवणारे precedence engine नाही. Claude Code च्या documentation नुसार विरोधाभासी नियम मनमानीपणे सोडवले जाऊ शकतात. Nested फाइल्समध्ये त्या कोणत्या path साठी लागू आहेत हे स्पष्ट करून अतिरिक्त नियम लिहा. दुसऱ्या नियमावर मात करण्याचा प्रयत्न करण्याऐवजी विरोधाभास काढून टाका.

माझ्या सूचना /compact नंतरही टिकतात का?

त्या कशा लोड झाल्या यावर ते अवलंबून असते. Project root CLAUDE.md, unscoped rules आणि auto memory compaction नंतर disk वरून पुन्हा inject केले जातात. paths: frontmatter असलेले rules आणि subdirectories मधील nested CLAUDE.md files पुन्हा संबंधित फाइल वाचेपर्यंत उपलब्ध राहत नाहीत. तुम्ही chat मध्ये टाइप केलेली कोणतीही गोष्ट summariser ने ठेवली असेल तरच टिकते. एखादा नियम संपूर्ण session मध्ये लागू राहणे आवश्यक असल्यास, तो paths: frontmatter नसलेल्या project root file मध्ये ठेवा.

एखादा नियम prose ऐवजी hook कधी बनवावा?

पडताळणी deterministic असेल आणि चूक होण्याची किंमत लहान script लिहिण्याच्या किंमतीपेक्षा जास्त असेल तेव्हा. File path restrictions, commit करण्यापूर्वी आवश्यक commands आणि forbidden tool calls या सर्वांसाठी hook योग्य आहे. PreToolUse hook status 2 सह exit झाल्यास तो tool call थेट रोखतो आणि तुमचा stderr मजकूर कारण म्हणून model कडे परत पाठवतो. त्यामुळे तो नियम context मध्ये अजून आहे की नाही यावर परिणाम होत नाही. Formatter किंवा linter ठरवू शकणारी कोणतीही गोष्ट त्या tool कडेच सोपवा आणि instruction file मधून पूर्णपणे काढून टाका.

हा लेख उपयुक्त होता का?