SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor

Agent skills vs MCP servers vs rules files में अंतर

Coding agent को context देने के इन तीन तरीकों को समझें। जानें कि कब MCP server, skill या rules file का उपयोग करना चाहिए और token लागत कम करने के लिए सही विकल्प कैसे चुनें।

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 होते हैं, तो उनमें से किसकी लागत सबसे कम होती है।

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

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

एक unconditional rules file हर सत्र की शुरुआत में लोड होती है, चाहे वह प्रासंगिक हो या न हो, जब तक कि उसे बाहर न रखा गया हो। Claude Code हर बातचीत की शुरुआत में startup CLAUDE.md files को पढ़ता है, कोड ब्लॉक के बाहर के block-level HTML comments को हटाकर उनकी सामग्री को इंजेक्ट करता है, और 4 MiB से बड़ी फाइलों को छोड़ देता है; claudeMdExcludes का उपयोग करके managed policy file को छोड़कर अन्य फाइलों को बाहर भी रखा जा सकता है। दस्तावेजी लक्ष्य प्रति फाइल 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 बंद है, यह अभी भी सब कुछ पहले ही लोड कर लेता है।

चार्टStartup and post-use context cost, estimated tokens
इस चार्ट के पीछे का डेटा
[
  {
    "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"
  }
]

ये अनुमान हैं, आपकी मशीन से लिए गए माप नहीं। ये उस टेक्स्ट के आकार से आते हैं जिसे प्रत्येक तंत्र लोड करता है, जो लगभग चार characters प्रति token है: एक 200-लाइन की rules file लगभग 10 KB markdown की होती है, एक skill description लगभग 160 characters का होता है, और बारह tools को expose करने वाला एक server लगभग 18 KB schema और 2 KB instructions block ले जाता है। Claude Code डिफ़ॉल्ट रूप से server के instructions field और पहले से लोड होने वाले प्रत्येक tool के description को 4,096 characters पर काट देता है, और tool search के माध्यम से लोड किए गए tool description को 16,384 characters पर काटता है। v2.1.296 से पहले छोटी सीमा 2,048 characters थी, और यदि आप CLAUDE_CODE_MAX_MCP_DESCRIPTION_LENGTH सेट करते हैं तो यह दोनों सीमाओं को बदल देता है। कुछ Anthropic-hosted MCP servers के instructions और descriptions उस variable के सेट होने पर भी Claude तक पूर्ण रूप से पहुँचते हैं, इसलिए ये सीमाएं सार्वभौमिक नहीं हैं। अगला भाग आपको अपने वास्तविक numbers को पढ़ना सिखाएगा।

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

अक्टूबर 2026 तक, Claude Code Claude Opus 4, Sonnet 4, Haiku 4.5 और बाद के मॉडलों पर, तथा Google Cloud के Agent Platform पर Opus 4.5, Sonnet 4.5, Haiku 4.5 और बाद के मॉडलों पर tool search का उपयोग करता है। पुराने मॉडलों पर, और Azure पर होस्ट किए गए Microsoft Foundry deployments पर, प्रत्येक MCP tool आपके द्वारा सेट की गई किसी भी सेटिंग के बावजूद पहले ही लोड हो जाता है। v2.1.304 के बाद से, जब ANTHROPIC_BASE_URL को LLM gateway पर पॉइंट किया जाता है, तो tool search डिफ़ॉल्ट रूप से चालू रहता है; पुराने संस्करणों में इसे तब तक बंद रखा जाता था जब तक आप इसे चुनते नहीं थे। v2.1.305 के बाद से, Claude Code 400 या 422 के बाद tool search के बिना gateway request को retry कर सकता है, और उस retry के सफल होने पर tools को पहले ही लोड कर सकता है। इसे नियंत्रित करने के लिए ENABLE_TOOL_SEARCH सेट करें: false हर schema को पहले ही लोड कर देता है, true इसे उसी मॉडल और deployment fallbacks के साथ टाल देता है जैसे कि इसे unset छोड़ने पर होता है, और auto उन्हें तब तक पहले ही लोड करता है जब तक उनकी परिभाषाएं context window के 10% से कम रहती हैं, फिर एक बार वह सीमा पार हो जाने पर tool search को चालू रखता है, भले ही कुल योग बाद में उस सीमा से नीचे गिर जाए। "alwaysLoad": true के साथ कॉन्फ़िगर किया गया server ENABLE_TOOL_SEARCH की परवाह किए बिना अपने tools को पहले ही लोड कर लेता है।

# 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 करता है, वह जानकारी पुरानी हो जाती है। आपका अपना codebase भी इसी सूची में आता है, क्योंकि इसकी संरचना हर commit के साथ बदलती है। यही कारण है कि repository का parsed map MCP के माध्यम से agent को देना बेहतर है, बजाय इसके कि layout को ऐसी file में वर्णित किया जाए जो पुरानी हो जाती है।

यदि उत्तर छह सप्ताह बाद भी सही रहेगा, बिना किसी के उसे maintain किए, तो आपको एक 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। सभी खोजी गई फाइलें एक-दूसरे को ओवरराइड करने के बजाय आपस में जुड़ (concatenate) जाती हैं, और आपकी working directory के करीब वाली फाइलें सबसे अंत में पढ़ी जाती हैं।

v2.1.277 के बाद से Claude Code AGENTS.md को भी पढ़ता है, लेकिन डिफ़ॉल्ट रूप से केवल तब जब आपकी working directory या उससे ऊपर कोई CLAUDE.md, .claude/CLAUDE.md या CLAUDE.local.md मौजूद न हो। यदि आपके repository में दोनों हैं, तो Claude केवल CLAUDE.md फाइलों को पढ़ता है, इसलिए ऐसी दो प्रतियां न रखें जो समय के साथ अलग-अलग हो जाएं।

ln -s AGENTS.md CLAUDE.md

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

@AGENTS.md

## Claude Code

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

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

जो चीज लागत को कम करती है, वह है paths field के साथ .claude/rules/। paths frontmatter वाली एक rule file केवल तभी लोड होती है जब agent उन patterns में से किसी एक से मेल खाने वाली फाइल को छूता है।

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

# API rules

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

बिना paths field वाली एक rule, .claude/CLAUDE.md के समान प्राथमिकता के साथ लॉन्च पर लोड होती है। इसलिए काम करने का तरीका यह है कि छोटी बिना शर्त वाली rules रखें, और किसी भी ऐसी चीज़ पर paths सूची का उपयोग करें जो केवल एक 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 को request से match करने के लिए कुछ नहीं देता, इसलिए skill चुपचाप कभी नहीं चलती और आप यह निष्कर्ष निकालते हैं कि skills काम नहीं करती हैं।

Directory का नाम command बन जाता है, इसलिए ऊपर दिया गया उदाहरण आपको /summarize-changes देता है। Personal या project skill में, एक frontmatter name जो directory के नाम से अलग है, वह command सेट करता है जिसे / menu दिखाता है, जब तक कि कोई अन्य command पहले से ही उस नाम का उपयोग न कर रहा हो, और directory का नाम अभी भी skill को invoke करता है।

एक बार 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 करता है, और 25,000 tokens के combined budget के भीतर प्रत्येक के पहले 5,000 tokens को रखता है। एक session में कई बड़ी skills invoke करें और सबसे पुरानी पूरी तरह से हटा दी जाती हैं, यही कारण है कि एक लंबी conversation के बाद skill का महत्व खत्म होता हुआ लग सकता है। इसे फिर से invoke करें और यह वापस आ जाएगी। एक procedure-heavy skill उस trade को ठोस बनाती है: the unlazy skill and its Depth Tree method एक ऐसे agent के बदले में gates और plan file पर वास्तविक context खर्च करती है जो काम को जल्दी पूरा घोषित करना बंद कर देता है। जब एक ही procedure एक से अधिक codebase पर लागू होता है, तो file को इधर-उधर copy करने के बजाय share one skill across several repositories करें।

आपको 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 ... line के साथ पुष्टि करता है, जो केवल यह बताता है कि 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 server एक ऐसी process है जिसे आपको चलाना पड़ता है

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

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

sudo useradd --system --home-dir /srv/notes-mcp --shell /usr/sbin/nologin mcp
sudo chown -R mcp:mcp /srv/notes-mcp
[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 print करना चाहिए। यदि यह failed print करता है, तो journal में इसका कारण मौजूद होगा, और पहली बार चलाने पर यह लगभग हमेशा कोई missing environment variable या किसी अन्य process द्वारा पहले से bind किया गया port होता है। यहाँ Restart=on-failure वैकल्पिक नहीं है, क्योंकि एक crashed MCP server खुद को सूचित नहीं करता है। आपको तब पता चलता है जब agent आपको बताता है कि वह आपके issue tracker को पढ़ नहीं सकता है।

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

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

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

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

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

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

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

मेरा skill कभी trigger क्यों नहीं होता?

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

दूसरा कारण frontmatter में टाइपो है, और Claude Code में यह भी चुपचाप होता है। field का नाम बिल्कुल मेल खाना चाहिए, जिसमें hyphens भी शामिल हैं, और Claude Code किसी ऐसे field को अनदेखा कर देता है जिसे वह नहीं पहचानता है, बिना कोई error बताए। इसका loud version केवल तब दिखाई देता है जब आप skill को package करते हैं या उसे claude.ai या Skills API पर upload करते हैं, जो कम fields स्वीकार करते हैं और बाकी को पूरी तरह से reject कर देते हैं:

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

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

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

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 पढ़ना है जिसे कोई और बदल सकता है, जैसे कि issue tracker, database या dashboard, तो आपको MCP server की आवश्यकता है, क्योंकि आपके द्वारा लिखी गई कोई भी जानकारी रिकॉर्ड बदलते ही पुरानी (stale) हो जाती है। यदि आप उत्तर को एक बार लिख दें और वह छह सप्ताह बाद भी सही रहे, तो skill लिखें। Skill git में मौजूद एक फाइल है जिसे चलाने के लिए किसी process, open port या patch schedule की आवश्यकता नहीं होती, इसलिए जब भी संभव हो, यह सस्ता विकल्प है।

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

पहले की तुलना में बहुत कम। वर्तमान Claude Code में tool search डिफ़ॉल्ट रूप से सक्षम है, इसलिए session शुरू होने पर केवल tool के नाम और server के instructions लोड होते हैं, और जब Claude उन्हें खोजता है तब पूर्ण schemas fetch किए जाते हैं। इसमें अब v2.1.304 के बाद से ANTHROPIC_BASE_URL के माध्यम से सेट किए गए LLM gateway के पीछे के sessions भी शामिल हैं। Upfront loading अभी भी इन स्थितियों में होती है: ENABLE_TOOL_SEARCH=false के साथ, "alwaysLoad": true पर सेट किए गए server के लिए, Claude Opus 4 और Sonnet 4 से पुराने model पर (Google Cloud के Agent Platform पर 4.5 generation से पुराने), और Azure पर host किए गए Microsoft Foundry deployments पर। यह देखने के लिए कि आप किस स्थिति में हैं, /context all चलाएं, क्योंकि पुरानी तुलनात्मक पोस्ट में दिए गए आंकड़े upfront loading मानकर चलते हैं।

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

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

session के बीच में मेरी skill का असर क्यों खत्म हो गया?

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

मैं एक लंबी rules फाइल को हर session में लोड होने से कैसे रोकूँ?

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

क्या यह लेख उपयोगी था?