Agent skills, MCP servers और rules files में क्या अंतर है?

Agent skills, MCP servers और rules files: संक्षिप्त उत्तर

Agent skills, MCP servers और rules files, ये सभी एक coding agent के सामने जानकारी प्रस्तुत करते हैं। जानकारी के कार्य के आधार पर इनका चयन करें। MCP (model context protocol) उन डेटा के लिए है जो अगली बार देखने पर बदल सकता है। Skill उस प्रक्रिया के लिए है जिसे आप आज लिख सकते हैं और जो छह सप्ताह बाद भी सही रहेगी। Rules file उन कुछ तथ्यों के लिए है जो हर session में लागू होने चाहिए।

इस चयन की एक कीमत है, और वह कीमत context है। जिस instruction की agent को आवश्यकता नहीं थी, उस पर खर्च किया गया हर token उस code के लिए अनुपलब्ध हो जाता है जिसे वह पढ़ रहा है। यह एक ऐसा token भी है जिसे आप हर turn पर दोबारा चुकाते हैं, क्योंकि हर request के साथ पूरा context window फिर से भेजा जाता है। इसलिए उपयोगी प्रश्न यह नहीं है कि कौन सा mechanism काम कर सकता है। अधिकतर दिन तीनों ही काम कर सकते हैं। प्रश्न यह है कि idle रहने के दौरान कौन सा सबसे कम खर्चीला है।

उपयोग से पहले प्रत्येक की लागत

ये तीनों अलग-अलग समय पर लोड होते हैं, और यही समय का अंतर ही मुख्य अंतर है।

एक rules file लॉन्च के समय, हर सत्र में पूरी तरह लोड हो जाती है, चाहे वह प्रासंगिक हो या न हो। Claude Code हर बातचीत की शुरुआत में CLAUDE.md को पढ़ता है और लंबाई की परवाह किए बिना इसे पूरा लोड करता है। लक्षित सीमा प्रति फ़ाइल 200 पंक्तियों से कम है, क्योंकि लंबी फ़ाइल अधिक context की लागत लेती है और उसका पालन कम विश्वसनीयता से होता है। ये दोनों प्रभाव एक ही दिशा में काम करते हैं, यही कारण है कि 900-पंक्तियों वाली rules file बेकार से भी बदतर होती है।

एक skill दो चरणों में लोड होती है। स्टार्टअप पर केवल प्रत्येक SKILL.md frontmatter से description पंक्ति ही context में आती है, ताकि मॉडल को पता रहे कि skill मौजूद है और मोटे तौर पर यह कब लागू होती है। जब skill को invoke किया जाता है, तब उसका body लोड होता है। इसलिए, 400-पंक्तियों का reference document तब तक लगभग कुछ भी खर्च नहीं करता जब तक कि उसकी आवश्यकता न हो।

MCP server पहले महंगा हुआ करता था, और यहीं पर अधिकांश तुलनाएं जो आप पढ़ेंगे, अब पुरानी हो चुकी हैं। वर्तमान Claude Code में tool search डिफ़ॉल्ट रूप से चालू है। सत्र की शुरुआत में केवल tool के नाम और server का instructions field लोड होते हैं, और पूर्ण JSON (JavaScript object notation) schemas को तब तक के लिए टाल दिया जाता है जब तक कि Claude उन्हें खोज न ले। एक server जोड़ने पर अब शुरुआत में हजारों tokens खर्च नहीं होते। इसकी अभी भी कुछ लागत है, और उन configurations में जहाँ tool search बंद है, यह अभी भी शुरुआत में पूरी लागत लेता है।

[
  {
    "label": "Rules file, 200 lines",
    "at_startup": "2,500",
    "after_use": "2,500"
  },
  {
    "label": "Skill, 12 KB body",
    "at_startup": 40,
    "after_use": "3,000"
  },
  {
    "label": "MCP server, tool search on",
    "at_startup": 500,
    "after_use": "3,200"
  },
  {
    "label": "MCP server, tool search off",
    "at_startup": "4,500",
    "after_use": "4,500"
  }
]

ये अनुमान हैं, आपकी मशीन से लिए गए माप नहीं। ये उस टेक्स्ट के आकार से आते हैं जिसे प्रत्येक तंत्र लोड करता है, लगभग चार वर्ण प्रति token के हिसाब से: एक 200-पंक्ति वाली rules file लगभग 10 KB markdown की होती है, एक skill description लगभग 160 वर्णों की होती है, और बारह tools को expose करने वाला एक server लगभग 18 KB schema और 2 KB instructions block के साथ आता है। Claude Code प्रत्येक tool description और प्रत्येक server instructions field को 2 KB पर truncate कर देता है, इसलिए उस हिस्से की एक ऊपरी सीमा है। अगला भाग आपको अपने वास्तविक आंकड़े पढ़ना सिखाएगा।

पहली दो पंक्तियों को एक साथ पढ़ें। एक ऐसे सत्र में जहाँ किसी को इसकी आवश्यकता नहीं थी, rules file की लागत 2,500 tokens है। उसी सत्र में skill की लागत 40 tokens है, और दस में से उस एक सत्र में जब यह सक्रिय होती है, तो लागत 3,000 होती है। अंतिम दो पंक्तियाँ एक ही server को दो बार दर्शाती हैं, tool search के चालू और बंद होने के साथ: 500 tokens बनाम 4,500। यही अंतर वह कारण है कि MCP context bloat के बारे में पुरानी सलाह अभी भी प्रचलित है।

Tool search के लिए एक ऐसे मॉडल की आवश्यकता होती है जो tool_reference blocks का समर्थन करता हो, जिसका अर्थ अगस्त 2026 तक Claude Sonnet 4.5, Haiku 4.5, Opus 4.5 और बाद के संस्करण हैं। जब ANTHROPIC_BASE_URL किसी ऐसे host की ओर इशारा करता है जो first party नहीं है, तो Claude Code इसे बंद कर देता है, क्योंकि अधिकांश proxies उन blocks को forward नहीं करते हैं। इसे नियंत्रित करने के लिए ENABLE_TOOL_SEARCH सेट करें: false हर schema को शुरुआत में ही लोड करता है, true उन सभी को टाल देता है, और auto उन्हें शुरुआत में केवल तभी लोड करता है जब वे context window के 10% के भीतर फिट हो जाते हैं।

# Load schemas up front only if they fit in 5% of the window
ENABLE_TOOL_SEARCH=auto:5 claude

निर्णायक प्रश्न: क्या invocations के बीच डेटा बदलता है?

सबसे पहले यह पूछें, क्योंकि यह एक विकल्प को पूरी तरह से समाप्त कर देता है। यदि agent को कुछ ऐसा पढ़ना या लिखना है जो अगली बार देखने पर अलग हो सकता है, तो आपको एक server की आवश्यकता है। एक issue tracker, एक database, एक monitoring dashboard, या आपका अपना internal API (application programming interface)। इसे लिख देना मदद नहीं करता, क्योंकि जिस क्षण कोई और record को edit करता है, आपके द्वारा लिखा गया डेटा पुराना (stale) हो जाता है।

यदि छह सप्ताह बाद भी, बिना किसी के रखरखाव के, उत्तर सही रहता है, तो आपको एक skill की आवश्यकता है। एक release checklist। एक migration procedure। आपके error responses का स्वरूप। यह repository कैसे चाहती है कि tests लिखे जाएं। एक skill, git में मौजूद एक file है। इसका कोई port नहीं होता, कोई process नहीं होती, और गलत होने के अलावा इसका कोई failure mode नहीं होता, जिसे एक code review द्वारा पकड़ा जा सकता है।

यदि यह एक ऐसा तथ्य है जो उन कार्यों पर लागू होना चाहिए जिनके बारे में आपने अभी तक सोचा भी नहीं है, तो इसे rules file में डालें। Run make lint before committing. Never push to main. Handlers live in src/api/handlers/. प्रत्येक के लिए एक पंक्ति। जिस क्षण कोई entry चरणों (steps) में बढ़ जाती है, वह तथ्य नहीं रह जाती और एक procedure बन जाती है, और उसे एक skill में स्थानांतरित हो जाना चाहिए।

जब एक rules file पर्याप्त हो

Rules files कई स्थानों से लोड होती हैं, सबसे व्यापक से लेकर सबसे विशिष्ट तक: एक managed policy file, आपकी व्यक्तिगत ~/.claude/CLAUDE.md, प्रोजेक्ट की ./CLAUDE.md या ./.claude/CLAUDE.md, और एक gitignored ./CLAUDE.local.md। सभी खोजी गई फाइलें एक-दूसरे को override करने के बजाय आपस में जुड़ (concatenate) जाती हैं, और आपकी working directory के करीब वाली फाइलें अंत में पढ़ी जाती हैं।

Claude Code CLAUDE.md को पढ़ता है, AGENTS.md को नहीं। यदि आपके repository में अन्य टूल्स के लिए पहले से ही एक AGENTS.md मौजूद है, तो दो ऐसी प्रतियां न रखें जो समय के साथ अलग-अलग हो जाएं।

ln -s AGENTS.md CLAUDE.md

Symlink सफल होने पर कुछ भी प्रिंट नहीं करता है। एक session शुरू करें, /context चलाएं, और पुष्टि करें कि Memory files के अंतर्गत CLAUDE.md दिखाई देता है। यदि यह वहां सूचीबद्ध नहीं है, तो agent ने इसे कभी नहीं देखा है और शब्दों को बदलने से कोई मदद नहीं मिलेगी। जब आप Claude-विशिष्ट पंक्तियाँ भी चाहते हैं, तो import form का उपयोग करें और उन्हें import के नीचे रखें।

@AGENTS.md

## Claude Code

Use plan mode for changes under `src/billing/`.

यहाँ एक समस्या है। @path imports context को save नहीं करते हैं। Import की गई फाइल को launch के समय उस फाइल के साथ expand और load किया जाता है जिसने इसे reference किया है, चार hops की गहराई तक। 600-line की rules file को छह imports में विभाजित करना इसे मनुष्यों के लिए व्यवस्थित करता है और token cost को बिल्कुल भी नहीं बदलता है। AGENTS.md और इसके human-facing twin के पीछे के conventions को पढ़ना उपयोगी है, इससे पहले कि आप किसी layout को अंतिम रूप दें।

जो चीज़ cost को कम करती है, वह है paths field के साथ .claude/rules/। paths frontmatter वाली एक rule file तभी लोड होती है जब agent किसी ऐसे file को touch करता है जो patterns में से किसी एक से मेल खाता हो।

---
paths:
  - "src/api/**/*.ts"
---

# API rules

- Every endpoint validates its input.
- Use the standard error response shape.

बिना paths field वाली एक rule, launch के समय .claude/CLAUDE.md के समान प्राथमिकता के साथ लोड होती है। इसलिए काम करने का तरीका यह है कि छोटी unconditional rules रखें, और किसी भी ऐसी चीज़ पर paths list का उपयोग करें जो केवल एक directory के भीतर मायने रखती है।

जब आप कोई skill चाहते हैं

एक skill एक ऐसी directory है जिसके अंदर एक SKILL.md होता है। Personal skills ~/.claude/skills/<name>/SKILL.md में रहती हैं और आपकी मशीन पर हर project पर लागू होती हैं। Project skills .claude/skills/<name>/SKILL.md में रहती हैं, repository के साथ चलती हैं, और किसी भी अन्य file की तरह pull request में review की जा सकती हैं।

mkdir -p ~/.claude/skills/summarize-changes

---
name: summarize-changes
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.
---

Run `git status` and `git diff` against the merge base.
Group the changes by intent, not by file.
Call out anything touching auth, migrations or deletions.

description उस file का एकमात्र हिस्सा है जो skill चलने से पहले context में रहता है, इसलिए यह दो काम करता है। यह बताता है कि skill क्या करती है, और यह बताता है कि इसे कब इस्तेमाल करना है। "Helps with deploys" जैसी description model को match करने के लिए कुछ नहीं देती, इसलिए skill चुपचाप कभी नहीं चलती और आप निष्कर्ष निकालते हैं कि skills काम नहीं करती हैं।

Directory का नाम command बन जाता है, इसलिए ऊपर दिया गया उदाहरण आपको /summarize-changes देता है। Personal या project skill में frontmatter name केवल listings में display label सेट करता है।

एक बार skill invoke हो जाने के बाद, इसका rendered content एक single message के रूप में conversation में प्रवेश करता है और session के बाकी हिस्से के लिए वहीं रहता है। Claude Code बाद के turns में file को दोबारा नहीं पढ़ता। एक बार के steps के बजाय स्थायी निर्देश (standing instructions) लिखें, और body को संक्षिप्त रखें, क्योंकि उस बिंदु से हर line हर request पर एक recurring cost है। Auto-compaction के बाद, Claude Code प्रत्येक skill के सबसे हालिया invocation को फिर से attach करता है, और प्रत्येक के पहले 5,000 tokens को 25,000 tokens के संयुक्त budget के भीतर रखता है। एक session में कई बड़ी skills invoke करें और सबसे पुरानी पूरी तरह से हटा दी जाती हैं, यही कारण है कि एक लंबी conversation के बाद skill का महत्व खत्म होता हुआ लग सकता है। इसे फिर से invoke करें और यह वापस आ जाएगी। जब एक ही प्रक्रिया एक से अधिक codebase पर लागू होती है, तो file को इधर-उधर copy करने के बजाय कई repositories में एक skill साझा करें।

आपको MCP server की आवश्यकता कब होती है

इसे जोड़ना एक सिंगल command का काम है, और transport यह तय करता है कि इसका स्वरूप क्या होगा।

# Remote HTTP server
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Remote HTTP server behind a bearer token
claude mcp add --transport http secure-api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"

# Local stdio server: everything after -- is passed through untouched
claude mcp add --env AIRTABLE_API_KEY=YOUR_KEY --transport stdio airtable \
  -- npx -y airtable-mcp-server

-- महत्वपूर्ण है। stdio server के लिए, यह Claude Code के अपने विकल्पों को उस command line से अलग करता है जो आपके server को start करती है। यदि आप इसे छोड़ देते हैं, तो server के लिए बना --port 8080, claude mcp add के एक विकल्प के रूप में parse हो जाता है, जिसे वह फिर अस्वीकार कर देता है।

claude mcp list
claude mcp get notion

claude mcp add एक Added ... लाइन के साथ पुष्टि करता है, जो केवल यह बताती है कि configuration को disk पर लिख दिया गया है। claude mcp list वह command है जो आपको सही स्थिति बताती है, क्योंकि यह प्रत्येक server के बगल में एक health status print करती है: ✔ Connected, ! Needs authentication, या ✘ Failed to connect। Failure status का मतलब है कि Claude Code उस server तक नहीं पहुँच सका, न कि यह कि list command खराब हो गई है। एक session के भीतर, /mcp प्रत्येक server के लिए वही view और tool count प्रदान करता है।

MCP server को की गई प्रत्येक call स्वतंत्र होती है और अपनी जरूरत की हर चीज साथ ले जाती है, जो कि MCP server आपके पिछले अनुरोध को याद क्यों नहीं रखता का कारण है। यह एक design choice है जिसका परिणाम आपको भुगतना पड़ता है: किसी भी ऐसी state को, जिसे सुरक्षित रखना जरूरी है, server के पीछे, किसी database या file में रखना होगा, और अब यह वह चीज है जिसे आप operate करते हैं।

MCP सर्वर एक ऐसी प्रक्रिया है जिसे आपको चलाना होता है

यहाँ वह लागत है जिसे वेंडर तुलनाओं में छोड़ देते हैं। एक skill एक फाइल होती है। एक MCP सर्वर वह सॉफ्टवेयर है जो कहीं न कहीं चलता है, और जब वह 'कहीं' आपका VPS (virtual private server) होता है, तो उसकी uptime की जिम्मेदारी आपकी होती है।

एक stdio सर्वर सबसे सस्ता विकल्प है। Claude Code सत्र शुरू होने पर इसे एक child process के रूप में spawn करता है, और सत्र समाप्त होने पर यह बंद हो जाता है। इसमें न तो कुछ monitor करने की जरूरत होती है और न ही इसे अलग से patch करने की। एक remote HTTP सर्वर एक long-lived service है, और इसे उन सभी चीजों की आवश्यकता होती है जिनकी किसी भी long-lived service को होती है।

[Unit]
Description=Notes MCP server
After=network-online.target
Wants=network-online.target

[Service]
User=mcp
WorkingDirectory=/srv/notes-mcp
ExecStart=/usr/bin/node /srv/notes-mcp/dist/server.js
Environment=PORT=8931
Restart=on-failure
RestartSec=5
NoNewPrivileges=true
PrivateTmp=true

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now notes-mcp
systemctl is-active notes-mcp
journalctl -u notes-mcp -n 50 --no-pager

systemctl is-active को active प्रिंट करना चाहिए। यदि यह failed प्रिंट करता है, तो journal में इसका कारण मिल जाएगा, और पहली बार चलाने पर यह लगभग हमेशा एक missing environment variable या किसी अन्य प्रक्रिया द्वारा पहले से उपयोग किया जा रहा port होता है। Restart=on-failure यहाँ वैकल्पिक नहीं है, क्योंकि एक क्रैश हुआ MCP सर्वर खुद को सूचित नहीं करता है। आपको तब पता चलता है जब agent आपको बताता है कि वह आपके issue tracker को पढ़ नहीं पा रहा है।

प्रक्रिया को 127.0.0.1 पर bind करें और इसके सामने TLS (transport layer security) वाला एक reverse proxy लगाएँ। एक MCP सर्वर जो आपके database तक पहुँचता है और बिना authentication के public port पर जवाब देता है, वह एक ऐसा database है जिसे आपने सार्वजनिक कर दिया है। VPS पर MCP सर्वर चलाना proxy, certificate और firewall के पहलुओं को सही ढंग से कवर करता है।

फिर बार-बार होने वाले काम का ईमानदारी से आकलन करें। service को अपने स्वयं के schedule पर security updates की आवश्यकता होती है, जिसका उस agent से कोई संबंध नहीं है जो इससे बात करता है। इसका OAuth token expire हो जाता है, और claude mcp list किसी असुविधाजनक क्षण में ! Needs authentication प्रिंट करना शुरू कर देता है। इसके credentials एक config file या Authorization header में होते हैं, इसलिए उन्हें किसी भी अन्य secret की तरह ही सावधानी की आवश्यकता होती है, जो अपने आप में एक पूरा विषय है: secrets को AI agent की पहुँच से दूर रखना। skill के लिए इस तरह का कोई काम नहीं होता है।

बनाने से पहले विकल्प के साथ इसकी तुलना करें। यदि प्रस्तावित सर्वर के पीछे का डेटा लगभग हर तिमाही में बदलता है, तो एक ऐसी skill जो agent को यह बताती है कि कहाँ देखना है और fields का क्या अर्थ है, उस service की तुलना में सस्ती है जिसे आपको हर समय चालू रखना पड़ता है।

अपने कॉन्टेक्स्ट कॉस्ट को कैसे मापें

अनुमान लगाना बंद करें और किसी सेशन के भीतर /context चलाएं। यह स्टार्टअप का विवरण प्रिंट करता है: सिस्टम प्रॉम्प्ट, मेमोरी फाइलें, टूल्स और MCP सर्वर्स, साथ ही प्रत्येक का टोकन वेट।

दो चीजों की जांच करें। Memory files के अंतर्गत, पुष्टि करें कि आपकी अपेक्षित प्रत्येक रूल्स फाइल लिस्ट में है। एक गायब फाइल एजेंट को दिखाई नहीं देती है, इसलिए जब निर्देशों की अनदेखी की जा रही हो तो यह सबसे पहली चीज है जिसे चेक करना चाहिए। फिर देखें कि आपके सर्वर्स की लागत क्या है। यदि कोई सर्वर जिसे आप महीने में दो बार इस्तेमाल करते हैं, उस लिस्ट में सबसे बड़ी लाइनों में से एक है, तो उसे /mcp में टॉगल ऑफ कर दें और जिन सेशन्स में इसकी आवश्यकता हो, उनके लिए इसे वापस ऑन कर लें। कॉन्फ़िगरेशन दोनों स्थितियों में सुरक्षित रहता है।

एक रिमोट सर्वर cached 2h ago · connects on first use · 5 tools जैसी स्थिति भी रिपोर्ट कर सकता है। इसका मतलब है कि Claude Code ने स्टार्टअप पर कनेक्ट करने के बजाय पिछले सेशन से टूल लिस्ट पढ़ी है, और यह पहली बार टूल कॉल किए जाने पर कनेक्ट होगा। टूल्स आपके पहले मैसेज से ही उपलब्ध होते हैं, इसलिए इसमें कुछ भी ठीक करने की आवश्यकता नहीं है। यदि आप चाहते हैं कि हर सर्वर स्टार्टअप पर ही कनेक्ट हो, तो MCP_DISCOVERY_CACHE=0 सेट करें। व्यापक जानकारी के लिए, Claude Code कॉन्टेक्स्ट विंडो को मैनेज करना यह कवर करता है कि कॉम्पैक्शन के बाद क्या बचता है, और वे टोकन वास्तव में आपको कितना खर्च कराते हैं उन नंबरों को पैसों में बदलता है।

मेरा skill कभी ट्रिगर क्यों नहीं होता है?

इसका सामान्य कारण description है। skill चलने से पहले संदर्भ में यही एकमात्र टेक्स्ट होता है, इसलिए यदि यह स्थिति का नाम नहीं लेता है, तो कुछ भी मेल नहीं खाता है। ट्रिगर को वाक्य में इस प्रकार लिखें: "Use when the user asks what changed, wants a commit message, or asks to review their diff." अस्पष्ट विवरण चुपचाप विफल हो जाते हैं, जिससे इसे नोटिस करना कठिन हो जाता है।

दूसरा कारण frontmatter में टाइपो है, और यह स्पष्ट रूप से दिखाई देता है। एक अज्ञात key को पूरी तरह से अस्वीकार कर दिया जाता है:

Unexpected key(s) in SKILL.md frontmatter: argument-hint. Allowed properties are: allowed-tools, compatibility, description, license, metadata, name

तीसरा कारण स्थान है। Project skills आपके working directory में और repository root तक के प्रत्येक parent में .claude/skills/ से लोड होते हैं। जहाँ से आपने शुरू किया है, उसके नीचे के nested directories में स्थित skills लॉन्च के समय लोड नहीं होते हैं। वे पहली बार तब दिखाई देते हैं जब agent उस subdirectory के अंदर किसी file को पढ़ता या edit करता है, इसलिए तब तक वे autocomplete नहीं होते और नाम से invoke नहीं किए जा सकते।

इस silent failure का MCP समकक्ष एक .mcp.json एंट्री है जिसमें url है और कोई type नहीं है। Claude Code बिना type वाली किसी भी एंट्री को stdio server के रूप में पढ़ता है, इसलिए यह उस एंट्री को छोड़ देता है और रिपोर्ट करता है:

MCP server "notes" has a "url" but no "type"; add "type": "http" (or "sse" / "ws") to this entry

तीनों का एक साथ उपयोग

ये तंत्र एक ही स्थान के लिए प्रतिस्पर्धा नहीं करते हैं। एक प्रभावी सेटअप वह है जहाँ प्रत्येक का उपयोग वहां किया जाए जहाँ वह किफायती हो। rules फाइल में कुछ ऐसी पंक्तियाँ होती हैं जो हर जगह लागू होती हैं। Skills में प्रक्रियाएँ होती हैं और वे केवल तभी लोड होती हैं जब उनकी आवश्यकता होती है। एक MCP server, या कभी-कभी दो, उन सिस्टम को जोड़ते हैं जिनकी सामग्री का आप पहले से अनुमान नहीं लगा सकते। यदि आप अभी भी इनमें से पहले वाले का मानसिक मॉडल बना रहे हैं, तो agent skill वास्तव में क्या है इसके प्रारूप को विस्तार से कवर करता है।

एक परीक्षण अधिकांश तर्कों को सुलझा देता है कि कोई चीज़ कहाँ होनी चाहिए। इसे हटा दें, एक नया session शुरू करें, और agent को कार्य दें। यदि agent केवल धीमा है, तो वह skill में होना चाहिए था। यदि agent आत्मविश्वास के साथ गलत है, तो वह rules फाइल में होना चाहिए था। यदि agent जानकारी प्राप्त ही नहीं कर पा रहा है, तो आपको server की आवश्यकता थी, और अब आपको उस server को चालू रखने के लिए एक योजना की भी आवश्यकता है।

FAQ

क्या मुझे skill लिखनी चाहिए या MCP server खड़ा करना चाहिए?

यह इस आधार पर तय करें कि क्या जानकारी हर बार इस्तेमाल करने पर बदलती है। यदि agent को live state पढ़नी है जिसे कोई और edit कर सकता है, जैसे कि issue tracker, database या dashboard, तो आपको MCP server की आवश्यकता है, क्योंकि आपके द्वारा लिखी गई कोई भी जानकारी record बदलते ही पुरानी (stale) हो जाती है। यदि आप उत्तर को एक बार लिख दें और वह छह सप्ताह बाद भी सही रहे, तो skill लिखें। Skill git में मौजूद एक file है जिसे न तो run करने के लिए किसी process की जरूरत है, न ही किसी port को expose करने की और न ही patch schedule की, इसलिए जब भी संभव हो, यह सस्ता विकल्प है।

क्या MCP servers अभी भी मेरी context window भर देते हैं?

पहले की तुलना में बहुत कम। वर्तमान Claude Code में tool search डिफ़ॉल्ट रूप से enabled है, इसलिए session शुरू होने पर केवल tool के नाम और server का instructions field ही load होता है, और जब Claude उन्हें search करता है तभी पूर्ण schemas fetch किए जाते हैं। जब tool search बंद हो, तब upfront loading अभी भी होती है: ENABLE_TOOL_SEARCH=false के साथ, जब ANTHROPIC_BASE_URL किसी ऐसे proxy की ओर point कर रहा हो जो first party नहीं है, या Claude 4.5 generation से पुराने model पर। यह देखने के लिए कि आप किस स्थिति में हैं, /context चलाएँ, क्योंकि पुराने comparison posts के आंकड़े upfront loading को मानकर चलते हैं।

क्या Claude Code AGENTS.md को पढ़ता है?

नहीं। Claude Code CLAUDE.md को पढ़ता है। यदि आपके repository में अन्य agents के लिए पहले से ही AGENTS.md मौजूद है, तो दो प्रतियां रखने के बजाय एक को दूसरे की ओर point कर दें। सादे symlink के लिए ln -s AGENTS.md CLAUDE.md चलाएँ, या CLAUDE.md की पहली पंक्ति पर @AGENTS.md रखें और उसके नीचे Claude-विशिष्ट निर्देश जोड़ें। फिर एक session शुरू करें और यह पुष्टि करने के लिए /context चलाएँ कि Memory files के अंतर्गत CLAUDE.md दिखाई देता है।

मेरी skill ने session के बीच में ही असर करना क्यों बंद कर दिया?

Auto-compaction इसका सामान्य कारण है। जब conversation का सारांश (summarize) तैयार किया जाता है, तो Claude Code प्रत्येक skill के सबसे हालिया invocation को पुनः जोड़ता है, जिसमें प्रत्येक के पहले 5,000 tokens रखे जाते हैं, जो उन सभी के लिए कुल 25,000 tokens के budget के भीतर होते हैं। यह budget सबसे हाल ही में invoke की गई skill से भरना शुरू होता है, इसलिए यदि आपने कई बड़ी skills invoke की हैं, तो पुरानी वाली पूरी तरह से हटा दी जाती हैं। इसकी पूर्ण सामग्री को restore करने के लिए skill को फिर से invoke करें।

मैं एक लंबी rules file को हर session में load होने से कैसे रोकूँ?

उन हिस्सों को जो केवल कभी-कभी मायने रखते हैं, उन्हें .claude/rules/ files में ले जाएं जिनमें उनके frontmatter में paths field हो, ताकि प्रत्येक केवल तभी load हो जब agent किसी matching file को touch करे। File को @path imports में विभाजित करने से कोई मदद नहीं मिलती, क्योंकि imported files को launch के समय उस file के साथ ही expand और load किया जाता है जिसने उन्हें reference किया था। जो कुछ भी स्थायी तथ्य (standing fact) के बजाय बहु-चरणीय प्रक्रिया (multi-step procedure) है, उसे skill बन जाना चाहिए, क्योंकि skill body के invoke होने तक उसकी कोई लागत नहीं होती।