Coding agents உங்கள் கட்டளைகளை ஏன் புறக்கணிக்கின்றன?
Coding agents உங்கள் அறிவுறுத்தல்களை மீறுவதற்கான நான்கு முக்கிய காரணங்கள் மற்றும் அவற்றைச் சரிபார்க்கும் முறைகள் குறித்து இந்த கட்டுரையில் விரிவாகக் காணலாம்.
Coding agents ஏன் உங்கள் அறிவுறுத்தல்களைப் புறக்கணிக்கின்றன
Coding agents உங்கள் அறிவுறுத்தல்களைப் புறக்கணிப்பதற்கு நான்கு காரணங்கள் உள்ளன. நீங்கள் மிகவும் பணிவாக இருந்தது ஒரு காரணமே அல்ல. அந்த விதி context window-ல் இல்லை என்பது முதல் காரணம். அந்த விதியை ஒரு செயலுடன் ஒப்பிட்டுச் சரிபார்க்க முடியாத அளவுக்கு அது தெளிவற்றதாக இருந்தது என்பது இரண்டாவது காரணம். context-ல் இருந்த வேறொன்று அதற்கு முரணாக இருந்தது என்பது மூன்றாவது காரணம்; பொதுவாக agent இப்பதான் படித்த code-ல் இது நிகழும். அல்லது, அந்த விதி இன்னும் load ஆகியிருக்கும், ஆனால் தற்போதைய உரையாடலுக்கு வெகு தொலைவில் இருக்கும்; agent தனக்கு அருகில் உள்ள தகவல்களை வைத்தே செயல்படும்.
ஒவ்வொரு காரணத்திற்கும் ஒரு தீர்வு உண்டு, எனவே முதலில் எதனால் பிரச்சினை என்பதைப் பிரித்தறிவதே முதல் வேலை. பெரிய எழுத்துக்களும் (Capital letters) IMPORTANT என்ற வார்த்தையும் தீர்வாகாது. கீழே உள்ள நுட்பங்கள் Claude Code-ஐ உதாரணமாகக் கொள்கின்றன, ஏனெனில் அக்டோபர் 2026 நிலவரப்படி அதன் loading மற்றும் compaction செயல்பாடுகள் விரிவாக ஆவணப்படுத்தப்பட்டுள்ளன. பிற கருவிகள் விவரங்களில் மாறுபடலாம், ஆனால் அடிப்படைச் செயல்பாட்டில் அவை ஒரே மாதிரியானவை.
முதலில் இரண்டு கலைச்சொற்கள். context window என்பது ஒரு குறிப்பிட்ட கட்டத்தில் model பார்க்கும் உரையின் தொகுப்பாகும்: system prompt, உங்கள் அறிவுறுத்தல் கோப்புகள், உரையாடல் மற்றும் agent படித்த ஒவ்வொரு கோப்பும் இதில் அடங்கும். harness என்பது model-ஐச் சுற்றியுள்ள நிரலாகும்; இது வட்டில் (disk) உள்ள கோப்புகளைப் படித்து அந்தத் தொகுப்பை உருவாக்கும் கருவியாகும். இந்தப் பதிவில் உள்ள பெரும்பாலான புகார்கள் உண்மையில் model-ஐப் பற்றியவை அல்ல, அவை harness-ஐப் பற்றிய புகார்களே.
உங்கள் அறிவுறுத்தல் கோப்பு ஒரு செய்தி, அமைப்பு அல்ல
ஒரு அறிவுறுத்தல் கோப்பு என்பது configuration அல்ல. runtime-ல் எதையும் CLAUDE.md வாசித்து, அதை அமல்படுத்துவதில்லை. இந்த harness கோப்பை வட்டில் (disk) இருந்து வாசித்து, உரையில் ஒட்டுகிறது. Claude Code-ல், அந்த உள்ளடக்கம் system prompt-க்கு பிறகு ஒரு பயனர் செய்தியாக வழங்கப்படுகிறது. அதாவது, நீங்கள் தட்டச்சு செய்த மற்ற அனைத்தையும் போலவே, இந்த விதிகளையும் model ஒரே மாதிரியாகவே பார்க்கிறது.
இதன் விளைவாக ஒரு சங்கடமான சூழல் ஏற்படுகிறது. உங்கள் விதிகள், அந்த விண்டோவில் உள்ள மற்ற அனைத்து உரைப்பகுதிகளுடனும் சமமான நிலையில் போட்டியிடுகின்றன. ஒரு விதி என்பது ஒரு கோரிக்கை. ஏஜென்ட் இப்போது திறந்த கோப்பு என்பது ஒரு சான்று. இவை இரண்டும் முரண்படும்போது, பெரும்பாலும் சான்றே வெற்றி பெறுகிறது. எவ்வித பிழையும் (error) ஏற்படுவதில்லை, ஏனெனில் model-ன் பார்வையில் அங்கு தவறு எதுவும் நடக்கவில்லை.
அதிகாரப்பூர்வ ஆவணங்கள் இதைத் தெளிவாகக் கூறுகின்றன: அறிவுறுத்தல் கோப்புகள் சூழலாகவே (context) கருதப்படுகின்றன, அமல்படுத்தப்படும் configuration-ஆக அல்ல. model என்ன முடிவெடுத்தாலும் ஒரு செயலைத் தடுக்க, உங்களுக்கு ஒரு hook தேவை, ஒரு வாக்கியம் அல்ல. அந்த வரிகளை நினைவில் கொள்ளுங்கள். இந்தப் பதிவின் இறுதியில் உள்ள பெரும்பாலான தீர்வுகள், ஒரு குறிப்பிட்ட சூழலுக்குப் பயன்படுத்தப்பட்ட அந்த வரிகளே ஆகும்.
எந்த instruction கோப்புகள் எப்போது ஏற்றப்படுகின்றன
Claude Code நீங்கள் அதைத் தொடங்கிய கோப்பகத்திலிருந்து (directory) கோப்பக மரத்தின் மேல்நோக்கிச் செல்கிறது. கோப்பு முறைமையின் (filesystem) root-லிருந்து உங்கள் working directory வரை உள்ள அனைத்து CLAUDE.md மற்றும் CLAUDE.local.md கோப்புகளும் தொடக்கத்தின்போதே முழுமையாக ஏற்றப்படும். அவை அந்த வரிசையிலேயே இணைக்கப்படுகின்றன, எனவே நீங்கள் தொடங்கிய இடத்திற்கு மிக அருகில் உள்ள கோப்பு கடைசியாக வாசிக்கப்படும், மேலும் ஒரே கோப்பகத்திற்குள் .local கோப்பு முதன்மை கோப்பிற்குப் பிறகு சேர்க்கப்படும்.
உங்கள் working directory-க்கு கீழே உள்ள துணைக்கோப்பகங்களில் (subdirectories) உள்ள கோப்புகள் வித்தியாசமாகச் செயல்படுகின்றன. அவை தொடக்கத்தின்போது ஏற்றப்படுவதில்லை. அந்த கோப்பகத்தில் உள்ள ஒரு கோப்பை agent வாசிக்கும்போது அவை ஏற்றப்படுகின்றன. .claude/rules/-ல் உள்ள path scoped விதிகள், paths: frontmatter புலத்தைக் கொண்டிருந்தால், அவை ஒவ்வொரு முறையும் அல்லாமல், பொருந்தக்கூடிய கோப்பு வாசிக்கப்படும்போது மட்டுமே சூழலுக்குள் (context) நுழைகின்றன. v2.1.309 முதல், இவ்வாறு ஏற்றப்படும் கோப்புகளுக்கு ஒரு கோப்பிற்கான அளவு வரம்பு உள்ளது (200K context window-வில் 40,000 எழுத்துகள்), மேலும் agent நீண்ட கோப்பின் தொடக்கத்தை மட்டுமே பெறுகிறது, எனவே ஒரு பெரிய nested கோப்பின் இறுதியில் உள்ள விதிகள் சூழலுக்குள் வராமலேயே போகலாம்.
இந்த ஒரு வித்தியாசம், பதிவாகும் தோல்விகளில் பெரும் பகுதியை விளக்குகிறது. நீங்கள் packages/api/CLAUDE.md-ல் ஒரு விதியை வைக்கிறீர்கள், API பற்றி ஒரு கேள்வியைக் கேட்கிறீர்கள், ஆனால் packages/api/-க்குக் கீழே உள்ள எந்தக் கோப்பையும் திறக்காமலேயே agent பதிலளிக்கிறது. அந்த விதி புறக்கணிக்கப்படவில்லை. அது அங்கேயே இல்லை. உங்கள் களஞ்சியம் (repository) வழிகாட்டுதல்களை monorepo-வில் உள்ள ஒவ்வொரு தொகுப்புக்கான instruction கோப்புகள் எனப் பிரித்திருந்தால், ஒவ்வொரு முறையும் சரிபார்க்க வேண்டிய முதல் விஷயம் இதுதான்.
AGENTS.md-ஐத் தரப்படுத்திய களஞ்சியங்களை பாதிக்கும் மற்றொரு loading சிக்கல் உள்ளது. v2.1.277 முதல், Claude Code இயல்பாகவே AGENTS.md-ஐ உங்கள் project instructions-ஆக வாசிக்கிறது, ஆனால் உங்கள் working 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 அறிவுறுத்தல்களைப் பிரித்தல் பகுதியில் விவரிக்கப்பட்டுள்ளது.
கோப்பை மீண்டும் எழுதுவதற்கு முன்பு அது ஏற்றப்பட்டதை உறுதிப்படுத்தவும்
முகவர் (agent) கோப்பைக் காண முடியும் என்பதற்கு ஆதாரம் கிடைக்கும் வரை அதன் உள்ளடக்கத்தை மாற்ற வேண்டாம். இரண்டு சோதனைகள் உள்ளன, அவற்றில் எளிமையானதை முதலில் செய்யவும்.
அமர்விற்குள் /context கட்டளையை இயக்கவும். இது தற்போதைய சாளரத்தை வகை வாரியாகப் பிரித்துக் காட்டும், மேலும் Memory files பட்டியலில் தொடக்கத்தின்போது ஏற்றப்பட்ட ஒவ்வொரு அறிவுறுத்தல் கோப்பின் பெயரும் இருக்கும். அந்தப் பட்டியலில் இல்லாத ஒரு கோப்பு தொடக்கத்தில் ஏற்றப்படவில்லை என்று பொருள்; எனவே, ஏதேனும் ஒன்று அதை ஏற்றும் வரை, நீங்கள் அதற்குள் எழுதும் எதற்கும் எந்தப் பயனும் இல்லை. ஒரு துணை அடைவில் (subdirectory) உள்ள கோப்பு அங்கு ஒருபோதும் தோன்றாது, ஏனெனில் அது தேவைப்படும்போது மட்டுமே ஏற்றப்படும்; அது ஏற்றப்படும்போது, அதன் பாதையுடன் கூடிய ஒரு Loaded வரி முனையத்தில் (terminal) தோன்றும். /memory கோப்பு இருப்பிடங்களைப் பட்டியலிட்டு, அவை இன்னும் உருவாக்கப்படவில்லை என்றாலும், திருத்துவதற்காகத் திறக்கும்.
மேலும் துல்லியமான பதிலைப் பெற, ஏற்றப்படும் நிகழ்வுகளைப் பதிவு செய்யவும் (log). ஒவ்வொரு முறை ஒரு CLAUDE.md அல்லது விதிகள் கோப்பு சூழலுக்குள் நுழையும்போதும் InstructionsLoaded ஹூக் நிகழ்வு தூண்டப்படும், மேலும் அதன் மேட்சர் (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"
}
]
}
]
}
}இந்த ஹூக் அதன் பேலோடை (payload) JSON வடிவில் standard input வழியாகப் பெறுகிறது, எனவே cat முழுப் பதிவையும் இணைக்கும் (append). நீங்கள் பணிபுரியும் போது tail -f /tmp/instructions-loaded.log மூலம் அதைக் கண்காணிக்கவும். இந்த நிகழ்வின் exit status புறக்கணிக்கப்படும், எனவே ஹூக் கவனிப்பதற்கு மட்டுமே பயன்படும், எதையும் தடுக்க முடியாது. நீங்கள் எதிர்பார்த்த அமர்வில் உங்கள் துணைக்கோப்பு அந்தப் பதிவில் ஒருபோதும் தோன்றவில்லை என்றால், மீண்டும் எழுதுவதை நிறுத்திவிடவும். சிக்கல் கோப்பின் இருப்பிடத்தில் உள்ளது. ஒரு விதிவிலக்கு: Claude Code நேரடியாக வாசிக்கும் ஒரு AGENTS.md இந்த நிகழ்வைத் தூண்டாது, எனவே அதன் பாதையை /memory-ல் தேடவும். ஒரு CLAUDE.md-லிருந்து இறக்குமதி செய்யப்படும் AGENTS.md வழக்கம்போல இதைத் தூண்டும்.
நீண்ட session-ல் உங்கள் விதிகள் எவ்வாறு பாதிக்கப்படுகின்றன
இங்கு இரண்டு தனித்தனி விளைவுகள் ஏற்படுகின்றன, அவற்றுக்கு வெவ்வேறு தீர்வுகள் தேவை.
தொலைவு (Distance). ஒரு compaction நடக்கும் வரை, 1-வது turn-ல் குறிப்பிடப்பட்ட விதி 90-வது turn-லும் window-க்குள் இருக்கும். இப்போது அது, நீங்கள் தற்போது செய்து கொண்டிருக்கும் செயலுக்கு மிகவும் பொருத்தமான மற்றும் சமீபத்திய 90 turns உரையாடல்களுடன் போட்டியிடும். ஒருமுறை compaction நடந்துவிட்டால், நீங்கள் chat-ல் மட்டும் தட்டச்சு செய்த விதி window-ல் இல்லாமல் போகலாம்: உரையாடலின் தொடக்கத்தில் கொடுக்கப்பட்ட அறிவுறுத்தல்கள் தொலைந்து போகக்கூடும் என்று Claude Code-ன் ஆவணங்களே எச்சரிக்கின்றன, இது கீழே உள்ள இரண்டாவது விளைவாகும். நீங்கள் தொலைவை (distance) configuration மூலம் சரிசெய்ய முடியாது, ஆனால் அதை அளவிட முடியும். ஒரு புதிய session-ல் அதே பணியைச் செய்து பாருங்கள். அந்த விதி புதிய session-ல் சரியாகச் செயல்பட்டு, நீண்ட session-ன் ஆழத்தில் தோல்வியடைந்தால், அதற்குத் தொலைவு அல்லது compaction தான் காரணம்.
Compaction. window நிரம்பும்போது, harness இதுவரை நடந்த உரையாடலைச் சுருக்கி (summarise), அந்தச் சுருக்கத்திலிருந்து தொடரும். சுருக்கம் செய்பவர் (summariser) எதை முக்கியமாகக் கருதினாரோ அது மட்டுமே எஞ்சியிருக்கும்; அது நீங்கள் முக்கியமாகக் கருதுவதிலிருந்து மாறுபடலாம். Claude Code ஒவ்வொரு mechanism-க்கும் ஏற்ப முடிவுகளை ஆவணப்படுத்துகிறது, அவற்றுக்கிடையேயான வேறுபாடுகள் அதிகம். Project root CLAUDE.md மற்றும் unscoped விதிகள் compaction-க்கு பிறகு disk-லிருந்து மீண்டும் சேர்க்கப்படுகின்றன. Auto memory disk-லிருந்து மீண்டும் சேர்க்கப்படுகிறது. paths: frontmatter கொண்ட விதிகள், தொடர்புடைய கோப்பு மீண்டும் வாசிக்கப்படும் வரை இழக்கப்படுகின்றன. துணை அடைவுகளில் (subdirectories) உள்ள nested CLAUDE.md கோப்புகள், அந்தத் துணை அடைவில் உள்ள ஒரு கோப்பு மீண்டும் வாசிக்கப்படும் வரை இழக்கப்படுகின்றன.
உங்கள் அறிவுறுத்தல்களை அந்த அட்டவணையின்படி வரிசைப்படுத்தினால், அவற்றின் உறுதித்தன்மை (fragility) வரிசை தெளிவாகும். நீங்கள் chat-ல் மட்டும் தட்டச்சு செய்த விதிதான் session-ல் மிகவும் பலவீனமானது: சுருக்கம் செய்பவர் அதைத் தற்செயலாகத் தக்கவைத்துக் கொண்டால் மட்டுமே அது நீடிக்கும். packages/api/CLAUDE.md-ல் உள்ள விதி அடுத்த நிலையில் உள்ளது, ஏனெனில் அது ஒருமுறை ஏற்றப்பட்டு, சுருக்கத்தின் போது நீக்கப்பட்டு, அந்த அடைவில் அடுத்த முறை வாசிக்கும்போது மட்டுமே மீண்டும் வரும். Project root கோப்பில் உள்ள விதியே மிகவும் நீடித்தது, ஏனெனில் அது ஒவ்வொரு முறையும் disk-லிருந்து மீண்டும் வாசிக்கப்படுகிறது.
எனவே, ஒரு அறிவுறுத்தல் முழு session-க்கும் பொருந்த வேண்டும் என்றால், அது paths: frontmatter இல்லாமல் project root கோப்பில் இருக்க வேண்டும். மற்ற அனைத்தும் நீங்கள் திட்டமிட்டுச் செய்ய வேண்டிய சமரசங்கள் (tradeoffs) ஆகும். context window-ல் எதைத் தக்கவைப்பது என்பதை நிர்வகித்தல் பகுதி, focus argument-உடன் /compact மற்றும் தொடர்பில்லாத பணிகளுக்கு இடையே /clear ஆகியவற்றைக் கையாள்கிறது; இவை இரண்டும் உங்கள் விதிகள் எவை என்பதைச் சுருக்கம் செய்பவர் எவ்வளவு அடிக்கடி தீர்மானிக்கிறார் என்பதை மாற்றுகின்றன.
ஏன் சுற்றியுள்ள குறியீடு விதியை விட மேலோங்கி நிற்கிறது
இதுவே மக்கள் அடிக்கடி விவரிக்கும், ஆனால் மிகக் குறைவாகவே கண்டறியும் தோல்வியாகும். உங்கள் கோப்பு, தரவுத்தள அணுகல் repository layer வழியாகச் செல்ல வேண்டும் என்று கூறுகிறது. ஆனால், agent நேரடியாக ORM-ஐ (object relational mapper) அழைக்கும் ஒரு handler-ஐ எழுதுகிறது. உங்கள் பாணி (style) நிராகரிக்கப்படவில்லை; மாறாக, ஆதாரங்களின் அடிப்படையில் அது புறக்கணிக்கப்பட்டுள்ளது.
ஒரு விதி என்பது விருப்பத்தை மட்டுமே விவரிக்கிறது. ஆனால் குறியீடு ஒரு நடைமுறையைச் செய்து காட்டுகிறது. ஒரு agent தான் திருத்தப்போகும் தொகுதியில் உள்ள மூன்று கோப்புகளைத் திறக்கும்போது, அந்த மூன்றிலும் ORM நேரடியாக அழைக்கப்பட்டிருந்தால், சூழலில் ஒருபுறம் ஒரு சுருக்கமான வாக்கியமும், மறுபுறம் மூன்று உறுதியான, சமீபத்திய, பணிக்கு ஏற்ற உதாரணங்களும் இருக்கும். உள்ளூர் பாணியைப் பின்பற்றுவது பொதுவாகச் சரியான செயலாகும். ஆனால், சூழலுக்குத் தெரியாத ஒரு விஷயம் உங்களுக்குத் தெரியும் என்பதால், இங்கே அது தவறாகிறது: அந்த கோப்புகள் பழையவை (legacy).
எனவே, அதை விதியிலேயே எழுதுங்கள். தங்களுக்கு எதிரான ஆதாரங்களை முன்கூட்டியே குறிப்பிடும் விதிகள் மட்டுமே உண்மையான repository-ல் நிலைத்து நிற்கும். வெறும் விருப்பத்தை மட்டும் கூறும் விதிகள் நிலைக்காது.
புதிய தரவுத்தள அணுகல்app/repositories/வழியாகச் செல்ல வேண்டும்.app/legacy/-க்குக் கீழே உள்ள கோப்புகள் இன்னும் ORM-ஐ நேரடியாக அழைக்கின்றன. அது பழைய குறியீடு, அது புதிய நடைமுறை அல்ல. அதைப் பின்பற்ற வேண்டாம்.
இரண்டாவது வாக்கியமே முக்கியப் பணியைச் செய்கிறது. இது agent எதைக் கண்டறியப் போகிறது என்பதையும், அதைக் கண்டறிவதற்கு முன்பே அதை எப்படிப் புரிந்துகொள்ள வேண்டும் என்பதையும் அதற்குத் தெரிவிக்கிறது. உங்கள் repository-ல் உள்ள நடைமுறைக்கு முரணான எந்தவொரு விதிக்கும் இதே திருத்தம் பொருந்தும்: உங்கள் வரலாற்றில் பின்பற்றப்படாத commit பாணி, உங்கள் தொகுப்பில் பாதியளவு புறக்கணிக்கப்படும் test அமைப்பு, புதிய குறியீட்டில் மட்டுமே கடைபிடிக்கப்படும் import மரபு என எதுவாக இருந்தாலும், குறியீடு விதியுடன் முரண்படும் இடங்களை விதியிலேயே குறிப்பிடுங்கள்.
தெளிவற்ற விதியைச் சரிபார்க்க முடியாது, எனவே அதைப் பின்பற்றவும் முடியாது
"சுத்தமான குறியீட்டை எழுதுங்கள்." "அதிகப்படியான பொறியியல் (over-engineer) செய்யாதீர்கள்." "எளிமையாக வைத்திருங்கள்." "migration-களைக் கவனமாகக் கையாளுங்கள்." இவை எதையுமே ஒரு குறிப்பிட்ட செயலை வைத்து, முகவரோ (agent) அல்லது நீங்களோ சோதிக்க முடியாது. தனது வெளியீட்டைச் சரிபார்க்க முடியாத விதியைப் பெறும் ஒரு முகவர், யூகத்தின் அடிப்படையிலேயே செயல்படுகிறார்; நீங்களும் அந்த யூகத்தை உங்கள் உணர்வின் அடிப்படையில் மதிப்பிடுகிறீர்கள்.
உங்கள் கோப்பில் உள்ள ஒவ்வொரு வரிக்கும் இந்தச் சோதனையைப் பயன்படுத்துங்கள். விதி மீறப்படும்போது non-zero exit status-ஐத் தரும் shell command-ஐ எழுதுங்கள். உங்களால் அந்த command-ஐ எழுத முடியவில்லை என்றால், அந்த விதியைச் சரிபார்க்க முடியாது என்று பொருள். இந்த இணைகளை ஒப்பிட்டுப் பாருங்கள்:
- சரிபார்க்க முடியாதது: "functions-ஐச் சிறியதாக வைத்திருங்கள்." சரிபார்க்கக்கூடியது: "60 வரிகளுக்கு மேல் உள்ள function-க்கு மேலே, அதற்கான காரணத்தை விளக்கும் comment இருக்க வேண்டும்."
- சரிபார்க்க முடியாதது: "உங்கள் மாற்றங்களைச் சோதியுங்கள்." சரிபார்க்கக்கூடியது: "
npm test-ஐ இயக்கி, ஒரு பணியை முடித்ததாகக் குறிக்கும் முன் தோல்வியடைந்த எண்ணிக்கையை (failure count) பதிவிடுங்கள்." - சரிபார்க்க முடியாதது: "கோப்புகளை ஒழுங்கமைத்து வைத்திருங்கள்." சரிபார்க்கக்கூடியது: "HTTP handlers
src/api/handlers/-ல் இருக்க வேண்டும். அந்த directory-ல் வேறு எதுவும் இருக்கக்கூடாது." - சரிபார்க்க முடியாதது: "குறியீட்டைச் சரியாக வடிவமைக்கவும்." சரிபார்க்கக்கூடியது: "
.tsகோப்புகளில் 2 space indentation-ஐப் பயன்படுத்துங்கள்."
"அதிகப்படியான பொறியியல் செய்யாதீர்கள்" என்பது மக்கள் முதலில் கைவிடும் விதியாகும். ஏனெனில், இதற்கான தீர்வு குறுகிய வாக்கியம் அல்ல, மாறாக நீண்ட வாக்கியமே: செயல்படக்கூடிய மிகச்சிறிய மாற்றம் எது என்பதைத் தெளிவாகக் குறிப்பிடுவது, முகவர் தனது diff-ஐ ஒப்பிட்டுப் பார்க்கத் தேவையான அளவுகோல்களை வழங்குகிறது.
அளவும் (size) இதே போன்ற சிக்கல்தான், ஆனால் வேறு வடிவில் வருகிறது. Claude Code-ன் வழிகாட்டுதல், ஒரு instruction கோப்பிற்கு 200 வரிகளுக்குக் குறைவாக இருக்க வேண்டும் என்று பரிந்துரைக்கிறது. கோப்புகள் நீளமாக இருந்தால், விதிகளைப் பின்பற்றும் திறன் குறையும் என்று அது நேரடியாகக் கூறுகிறது. 700 வரிகள் கொண்ட கோப்பு என்பது உறுதியான அறிவுறுத்தல் அல்ல. அது 700 வரிகள் கொண்ட கூற்றுகள்; இதில் ஒன்றுக்கொன்று முரண்பட அதிக வாய்ப்புகள் உள்ளன. மேலும், ஒவ்வொரு முறையும் இது உங்கள் window-ல் கணக்கிடப்படுவதால், உங்கள் token பயன்பாட்டில் இது நேரடியாகத் தெரியும். ஒரு வாசகர் எளிதாகப் பார்க்கும் வகையில் ஒவ்வொரு விதியையும் ஒரு தலைப்பின் கீழ் வைப்பது, முகவர் செயல்படக்கூடிய வகையில் instruction கோப்பை எழுதுதல் என்பதில் விளக்கப்பட்டுள்ளது. அதைவிடச் சிறந்தது, விவரிக்கும் பகுதிகளை நீக்கிவிட்டு அறிவுறுத்தும் பகுதிகளை மட்டும் வைப்பது: handlers மற்றும் models எங்கே உள்ளன என்ற directory விவரங்களை, repository-ன் parsed map மூலம் முகவர் தேவைப்படும்போது பார்த்துக்கொள்ளலாம். ஒவ்வொரு முறையும் அதை window-ல் சுமக்க வேண்டிய அவசியமில்லை.
பத்து நிமிடங்களில் கண்டறிவது எப்படி
இவற்றை வரிசையாகச் செய்யவும். கடைசி நிலைக்கு நேரடியாகச் செல்வதுதான், வேலை செய்யாத நீண்ட விதிகளின் தொகுப்பை உருவாக்குவதற்கு வழிவகுக்கும்.
- கோப்பு ஏற்றப்பட்டதை உறுதிப்படுத்தவும்.
/context-ஐ இயக்கி Memory கோப்புகளின் பட்டியலைப் பார்க்கவும், அல்லது nested கோப்பு என்றால் terminal-ல் அதன்Loadedவரியைத் தேடவும். கோப்பு அங்கு இல்லை என்றால், அதன் இருப்பிடத்தைச் சரிசெய்து நிறுத்தவும். இந்த பட்டியலில் உள்ள மற்றவை இப்போதைக்கு பொருந்தாது. - புதிய session-ல் மீண்டும் நிகழ்த்தவும். புதிய session-ஐத் தொடங்கி, விதியைத் தூண்டக்கூடிய மிகச்சிறிய பணியைச் செய்யவும். நீண்ட session-ல் தோல்வியடைந்து, இங்கு சரியாக இருந்தால், அது distance அல்லது compaction தொடர்பான சிக்கல். இங்கும் தோல்வியடைந்தால், விதியே சிக்கலாக உள்ளது என்று பொருள்.
- போட்டியிடும் விதிகளை நீக்கவும். ஏற்கனவே விதியைப் பின்பற்றும் ஒரு directory-ல் அதே மாற்றத்தைச் செய்யக் கேட்கவும். compliance சரியாக வந்தால், சுற்றியுள்ள குறியீடுகள் உங்கள் விதியை மீறுகின்றன என்று அர்த்தம்.
- முரண்பாட்டைத் தேடவும். ஒரே செயலுக்கு இரண்டு கோப்புகள் வெவ்வேறு வழிகாட்டுதல்களை வழங்குவது ஆவணப்படுத்தப்பட்ட தோல்வியாகும்: model ஏதேனும் ஒன்றை தன்னிச்சையாகத் தேர்ந்தெடுக்கலாம், அது குறித்து உங்களுக்குத் தெரிவிக்காது.
- சரிபார்க்கக்கூடியதாக மாற்றி மீண்டும் சோதிக்கவும். விதியை ஒரு குறிப்பிட்ட path மற்றும் நிபந்தனையுடன் மீண்டும் எழுதவும். compliance-ல் பெரிய முன்னேற்றம் தெரிந்தால், விதியின் phrasing-தான் சிக்கலாக இருந்துள்ளது என்று பொருள்.
நிலை 4 என்பது ஒரே ஒரு கட்டளைதான். நீங்கள் திருத்திய கோப்பை மட்டும் பார்க்காமல், அந்த தலைப்பு தொடர்பான அனைத்து அறிவுறுத்தல் மூலங்களையும் (instruction sources) 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இரண்டு கோப்புகளில் வெவ்வேறு தகவல்கள் இருப்பது கண்டறியப்பட்டால், அதுவே உங்கள் bug. ஒன்றைத் நீக்கிவிடவும். வலுவான சொற்களைப் பயன்படுத்தி அவற்றை வரிசைப்படுத்த முயற்சிக்காதீர்கள், ஏனெனில் வரிசைப்படுத்தும் engine எதுவும் இல்லை. Claude Code v2.1.283 அல்லது அதற்குப் பிந்தைய பதிப்புகளில், /doctor prompt-audit உங்கள் அறிவுறுத்தல் கோப்புகள், விதிகள் மற்றும் திறன்கள் முழுவதும் இந்தத் தேடலை விரிவாகச் செய்யும். நீங்கள் கேட்கும் வரை எதையும் மாற்றாமல், முரண்பாடுகளை மட்டும் பட்டியலிடும்.
தீர்வுகளின் வரிசைமுறை
கீழே கொடுக்கப்பட்டுள்ள ஒவ்வொரு படியும் அதற்கு முந்தைய படியை விட அதிக தாக்கத்தை ஏற்படுத்தும், ஆனால் அமைப்பதற்கு அதிக செலவாகும். ஒரு விதியை மாற்றி அமைப்பது எளிது என்றால் மேலிருந்து தொடங்கவும். ஒரு விதியைத் தவறவிடுவது ஏற்றுக்கொள்ள முடியாத அளவுக்கு முக்கியமானது என்றால், கீழே உள்ள நிலைகளுக்குச் செல்லவும்.
- விதியைத் தெளிவாக வரையறுக்கவும். ஒரு path, command அல்லது நிபந்தனையைக் குறிப்பிடவும். முன்னரே காட்டியபடி, repository-ல் முகவர் (agent) கண்டறியக்கூடிய எதிர்-ஆதாரத்தைச் சேர்க்கவும். இது இலவசமானது மற்றும் பல சிக்கல்களைத் தீர்க்கும்.
- விதியை அது கட்டுப்படுத்தும் இடத்திற்கு அருகிலேயே நகர்த்தவும். ஒரு nested
CLAUDE.md,.claude/rules/-ல் உள்ள path scoped விதி, அல்லது கோப்பின் மேலேயே ஒரு comment. குறியீட்டைப் படிக்கும்போதே விதியும் கண்ணில் படும். இதில் உள்ள சமரசத்தை ஏற்கவும்: அவ்வாறு ஏற்றப்படும் எதையும் அடுத்த compaction-ன் போது நீக்கப்படும், மீண்டும் தேவைப்படும்போது வாசிக்கப்படும். - அமலாக்கத்தை ஒரு hook-க்குள் கொண்டு வரவும். உரை (prose) கோரிக்கை மட்டுமே வைக்கும். ஒரு hook முடிவெடுக்கும். Hooks நிலையான lifecycle நிகழ்வுகளின்போது குறியீடாக இயங்கும், மேலும் மாதிரி (model) என்ன முடிவெடுத்தாலும் அதைப் பொருட்படுத்தாமல் செயல்படும்.
- விதியை ஒரு deterministic கருவியிடம் ஒப்படைத்துவிட்டு, உரை விளக்கத்தை நீக்கவும். Formatting, import வரிசை, வரியின் நீளம், தடைசெய்யப்பட்ட imports, commit message வடிவம் போன்றவை.
ruff format,prettier --write,eslint, ஒருpre-commithook. Formatter ஒவ்வொரு முறையும் சரியாகச் செயல்படும், மேலும் இதற்கு tokens செலவாகாது. உரை விளக்கம் பெரும்பாலும் சரியாக இருக்கும், ஆனால் ஒவ்வொரு முறையும் tokens-ஐச் செலவழிக்கும்.
படி 3-ன் முழு விளக்கம். migration கோப்புகளை முகவர் ஒருபோதும் திருத்தக்கூடாது என்று வைத்துக்கொள்வோம். இதை .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/-க்குக் கீழ் உள்ள கோப்பைத் திருத்த முகவரிடம் கேட்கவும். அந்தத் திருத்தம் நிராகரிக்கப்படும், உங்கள் செய்தி அதற்கான காரணமாகத் திரும்ப வரும். PreToolUse-ல் உள்ள exit status 2, கருவி அழைப்பை (tool call) அது இயங்குவதற்கு முன்பே தடுக்கும், மேலும் உங்கள் stderr உரை ஒரு தடுப்புச் செய்தியாக மாதிரிக்கு அனுப்பப்படும். ${CLAUDE_PROJECT_DIR} project root-ஐக் குறிக்கும், எனவே முகவர் எந்த directory-ல் இருந்தாலும் இந்த hook வேலை செய்யும். முகவர் விதியை ஒப்புக்கொள்ள வேண்டியதில்லை, நினைவில் வைத்திருக்க வேண்டியதில்லை, அல்லது விதியை context-ல் வைத்திருக்க வேண்டியதில்லை. திருத்தம் நடக்காது.
எந்தவிதமான தர்க்கமும் இல்லாத நேரடித் தடையை உருவாக்க, உங்கள் settings-ல் உள்ள permissions.deny எந்த script-ம் பராமரிக்காமல் அதே வேலையைச் செய்யும், மேலும் அனுமதி முறைகள் உங்களைக் கேட்காமலேயே எதை இயக்க வேண்டும் என்பதைத் தீர்மானிக்கும். ஒரு அறிவுறுத்தல் பயனர் செய்தியில் இல்லாமல் system prompt மட்டத்தில் இருக்க வேண்டும் என்றால், --append-system-prompt அதை அங்கு வைக்கும். இருப்பினும், இது ஒவ்வொரு புதிய session-க்கும் மீண்டும் வழங்கப்பட வேண்டிய ஒரு launch flag ஆகும், இது interactive வேலையை விட script-களுக்கு மிகவும் பொருத்தமானது.
நீங்கள் கட்டளையிட்டு மாற்ற முடியாதவை
இதில் எந்தப் பகுதி உங்களுடையது என்பதில் தெளிவாக இருங்கள். கோப்புகளின் இருப்பிடம், சொற்றொடர் அமைப்பு, கோப்புகளுக்கு இடையிலான முரண்பாடுகள் மற்றும் கோப்பின் அளவு ஆகியவை ஆசிரியரின் சிக்கல்கள், அவற்றை ஆசிரியரே சரிசெய்ய வேண்டும். மீதமுள்ளவை மாதிரியின் (model) செயல்பாடுகள், அவற்றைச் சிறந்த சொற்களால் நீக்க முடியாது.
ஒப்புதல் என்பது இணக்கம் அல்ல. ஒரு ஏஜென்ட் ஒரு விதியை ஒப்புக்கொள்ளும், அதை உங்களிடம் சரியாகத் திரும்பக் கூறும், ஆனால் இரண்டு tool calls-க்கு பிறகு அதை மீறும். அந்த ஒப்புதலுக்கு எந்த மதிப்பும் இல்லை, அது எதையும் முன்கூட்டியே தீர்மானிக்காது. அதை ஒரு தீர்வாகக் கருதாதீர்கள், அதை ஒரு சோதனையாகவும் எண்ணாதீர்கள்.
சில பழக்கங்கள் மாறாதவை. கருத்துகளைச் (comments) சேர்த்தல், தற்காப்பு பிழை கையாளுதலை (defensive error handling) சேர்த்தல், முடிவுரையை எழுதுதல், அடுத்த கட்டமாகத் தெளிவான கட்டளையை இயக்குதல் போன்றவை. இவற்றைத் தடை செய்யும் விதியின் கீழும் இவை மீண்டும் வரும், ஆனால் பூஜ்ஜியத்திற்குப் பதிலாகக் குறைந்த அளவில் வரும். உங்கள் சொந்த விகிதத்தை நீங்கள் அளவிடலாம்: ஒரே பணியைப் புதிய அமர்வுகளில் பத்து முறை இயக்கி, மீறல்களை எண்ணுங்கள். அந்த எண்ணிக்கை பூஜ்ஜியமாக இருக்க வேண்டிய இடத்தில், அந்த விதியை prompt-லிருந்து நீக்க வேண்டும். ஒரு பணி முழுமையடையாத நிலையில் அதை முடித்துவிட்டதாகக் கூறுவதும் இதே போன்ற பழக்கம்தான், இதற்கான தீர்வு வாய்மொழியாக இல்லாமல் கட்டமைப்பில் உள்ளது: சோம்பேறித்தனமற்ற திறன் என்பது வாக்கியத்திற்குப் பதிலாக ஒரு Depth Tree-ஐப் பயன்படுத்துவது மற்றும் ஏஜென்ட் முடித்துவிட்டதாகக் கூறுவதற்கு முன் கடக்க வேண்டிய gate files-ஐ உருவாக்குவது ஆகும்.
உங்கள் சொந்த அமர்வே ஒரு உதாரணமாகிறது. ஏஜென்ட் 12-வது சுற்றில் விதியை மீறியபோது நீங்கள் அதை அனுமதித்தால், அந்த மீறல் இப்போது சூழலில் (context) ஒரு முன்னுதாரணமாக அமர்கிறது, இது விதியை விட மிக சமீபத்தியது. ஒரு மீறலைக் கண்டவுடன் அதைச் சரிசெய்யுங்கள். சரிசெய்யப்படாத மீறல் அந்த அமர்வின் எஞ்சிய பகுதிக்குத் தவறான பாடத்தைக் கற்பிக்கும்.
ஒரு அறிவுறுத்தல் கோப்பு (instruction file) ஒரு பாதுகாப்பு எல்லை அல்ல. இது நடத்தையை வடிவமைக்கிறது, ஆனால் அதை அமல்படுத்துவதில்லை. தவறு நடந்தால் அதிக விலை கொடுக்க வேண்டிய விஷயங்கள், நற்சான்றிதழ்கள் (credentials) அல்லது அழிவுகரமான கட்டளைகள் போன்றவை permissions அல்லது hook-ன் கீழ் வர வேண்டும். ரகசியங்களை ஏஜென்ட்டின் கைக்கு எட்டாதவாறு வைத்திருப்பது என்பது தரவுகளுக்கும் அதே கொள்கையைப் பயன்படுத்துகிறது: ஒரு கோப்பைப் படிக்க வேண்டாம் என்று ஏஜென்டிடம் கேட்காதீர்கள், அந்தக் கோப்பைப் படிக்க முடியாதபடி ஏற்பாடு செய்யுங்கள்.
சுருக்கமாகச் சொன்னால்: கோப்பு ஏற்றப்பட்டதை நிரூபியுங்கள், விதியைச் சரிபார்க்கக்கூடியதாக ஆக்குங்கள், அதை அது நிர்வகிக்கும் விஷயத்திற்கு அருகிலேயே வையுங்கள், தவறு நடக்கும் விகிதம் முக்கியமாக இருக்கும்போது, அதை உரையிலிருந்து (prose) நீக்கிவிடுங்கள். ஒரு ஏஜென்ட் புறக்கணிக்க முடியாத விதி என்பது, ஏஜென்டிடம் கேட்கப்படாத விதியே ஆகும்.
FAQ
Claude Code ஏன் எனது CLAUDE.md கோப்பைப் புறக்கணிக்கிறது?
அது புறக்கணிக்கப்பட்டதா என்று முடிவு செய்வதற்கு முன், அது ஏற்றப்பட்டதா என்பதைச் சரிபார்க்கவும். /context கட்டளையை இயக்கி, Memory files பட்டியலைப் பார்க்கவும்; அதில் இடம்பெறாத கோப்பு தொடக்கத்தின்போது ஏற்றப்படவில்லை என்று அர்த்தம். அறிவுறுத்தல் கோப்புகள் system prompt-க்கு பிறகு பயனர் செய்தியாக வழங்கப்படுகின்றன, மேலும் அவை கட்டாயப்படுத்தப்பட்ட உள்ளமைவாக (enforced configuration) இல்லாமல் சூழலாகவே (context) கருதப்படுகின்றன, எனவே இதில் கடுமையான இணக்க உத்தரவாதம் இல்லை. பெரும்பாலான நேரங்களில் பின்வரும் நான்கு காரணங்களில் ஒன்றுதான் இதற்குக் காரணமாக இருக்கும்: கோப்பு முகவர் (agent) படிக்காத ஒரு துணை அடைவில் (subdirectory) இருக்கலாம், இரண்டு கோப்புகள் முரண்பட்டு மாதிரி (model) ஏதேனும் ஒன்றை தன்னிச்சையாகத் தேர்ந்தெடுத்திருக்கலாம், விதி ஒரு செயலைச் சரிபார்க்க முடியாத அளவுக்குத் தெளிவாக இல்லாமல் இருக்கலாம், அல்லது சுற்றியுள்ள குறியீடு (code) விதியில் கூறப்பட்டதற்கு நேர்மாறாக இருக்கலாம்.
அமர்வின் நடுவில் அறிவுறுத்தல் கோப்பைத் திருத்தினால் ஏதேனும் மாற்றம் ஏற்படுமா?
உரையாடலில் ஏற்கனவே உள்ள நகலுக்கு எந்த மாற்றமும் ஏற்படாது. உங்கள் பணி அடைவுக்கு (working directory) மேலே உள்ள கோப்புகள் தொடக்கத்தின்போது முழுமையாக ஏற்றப்படுகின்றன, எனவே மாதிரி (model) வைத்திருக்கும் உரை தொடக்க நேரத்தில் இருந்த உரையாகவே இருக்கும். திருத்தத்தைப் பயன்படுத்த, புதிய அமர்வைத் தொடங்கவும் அல்லது சாதாரண கோப்பு கருவிகளைப் பயன்படுத்தி கோப்பைப் படிக்குமாறு முகவரிடம் கேட்கவும்; இது தற்போதைய பதிப்பை ஒரு புதிய செய்தியாக உரையாடலில் சேர்க்கும். ஒரு compaction-க்கு பிறகு, project root கோப்பு வட்டில் (disk) இருந்து மீண்டும் படிக்கப்படும், எனவே அந்த நேரத்தில் புதிய பதிப்பு வந்து சேரும்.
root CLAUDE.md மற்றும் உள்ளமைக்கப்பட்ட (nested) கோப்பு முரண்படும்போது எது வெற்றி பெறும்?
எதுவும் நம்பகத்தன்மையுடன் வெற்றி பெறாது. கண்டறியப்பட்ட கோப்புகள் ஒன்றையொன்று மேலெழுதாமல் (override), கோப்பு முறைமையின் root-லிருந்து உங்கள் பணி அடைவு வரை வரிசைப்படுத்தப்பட்டு சூழலில் இணைக்கப்படுகின்றன, எனவே அருகிலுள்ள கோப்பு கடைசியாகப் படிக்கப்படுகிறது. முரண்பாடுகளைத் தீர்க்கும் முன்னுரிமை இயந்திரம் (precedence engine) எதுவும் இல்லை, மேலும் முரண்பாடான விதிகள் தன்னிச்சையாகத் தீர்க்கப்படலாம் என்று Claude Code ஆவணங்கள் கூறுகின்றன. உள்ளமைக்கப்பட்ட கோப்புகளை அவை நிர்வகிக்கும் பாதையைக் குறிப்பிடும் கூடுதல் கோப்புகளாக எழுதவும், முரண்பாட்டை விஞ்ச முயற்சிப்பதற்குப் பதிலாக அதை நீக்கவும்.
எனது அறிவுறுத்தல்கள் /compact கட்டளைக்குப் பிறகும் இருக்குமா?
அவை எவ்வாறு ஏற்றப்பட்டன என்பதைப் பொறுத்தது. Project root CLAUDE.md, வரையறுக்கப்படாத விதிகள் (unscoped rules) மற்றும் தானியங்கி நினைவகம் (auto memory) ஆகியவை compaction-க்கு பிறகு வட்டில் இருந்து மீண்டும் செலுத்தப்படுகின்றன. paths: frontmatter கொண்ட விதிகள் மற்றும் துணை அடைவுகளில் உள்ள CLAUDE.md கோப்புகள், மீண்டும் ஒரு பொருத்தமான கோப்பு படிக்கப்படும் வரை இழக்கப்படும். நீங்கள் அரட்டையில் தட்டச்சு செய்தவை, சுருக்கக் கருவி (summariser) அதை வைத்திருந்தால் மட்டுமே இருக்கும். ஒரு விதி முழு அமர்விலும் நிலைத்திருக்க வேண்டுமென்றால், அதை paths: frontmatter இல்லாமல் project root கோப்பில் வைக்கவும்.
ஒரு விதியை எப்போது உரைக்கு (prose) பதிலாக hook-ஆக மாற்ற வேண்டும்?
சரிபார்ப்பு தீர்மானிக்கக்கூடியதாக (deterministic) இருக்கும்போதும், ஒரு தவறுக்கான செலவு ஒரு சிறிய ஸ்கிரிப்டை எழுதுவதற்கான செலவை விட அதிகமாக இருக்கும்போதும் இதைச் செய்ய வேண்டும். கோப்பு பாதை கட்டுப்பாடுகள், commit செய்வதற்கு முன் தேவைப்படும் கட்டளைகள் மற்றும் தடைசெய்யப்பட்ட கருவி அழைப்புகள் (tool calls) அனைத்தும் இதற்குப் பொருந்தும். 2 என்ற நிலையில் வெளியேறும் ஒரு PreToolUse hook, கருவி அழைப்பை நேரடியாகத் தடுத்து, உங்கள் stderr உரையை அதற்கான காரணமாக மாதிரிக்குத் திருப்பித் தரும், எனவே விதி சூழலில் இருந்தாலும் இல்லாவிட்டாலும் அது செயல்படும். ஒரு formatter அல்லது linter தீர்மானிக்கக்கூடிய எதையும் அந்த கருவியே கையாள வேண்டும், மேலும் அதை அறிவுறுத்தல் கோப்பிலிருந்து முழுமையாக நீக்கிவிட வேண்டும்.