Agent skills, MCP servers, rules files: ఏది ఎప్పుడు?

Agent skills, MCP servers, rules files మధ్య తేడా: సంక్షిప్త సమాధానం

Agent skills, MCP servers, rules files — ఇవన్నీ coding agent కు అవసరమైన జ్ఞానాన్ని అందిస్తాయి. ఆ జ్ఞానం ఏ పని చేస్తుందో ఆధారంగా ఎంపిక చేయండి. MCP (model context protocol) అనేది మీరు తదుపరిసారి పరిశీలించినప్పుడు మారి ఉండగల data కోసం ఉపయోగించాలి. Skill అనేది ఈరోజు రాసి ఉంచినా ఆరు వారాల తర్వాత కూడా సరైనదిగా ఉండే procedure కోసం ఉపయోగించాలి. ప్రతి session లోనూ తప్పనిసరిగా వర్తించాల్సిన కొన్ని facts కోసం rules file ఉపయోగించాలి.

ఈ ఎంపికకు ఒక ఖర్చు ఉంది. ఆ ఖర్చు context. Agent కు అవసరం లేని instruction పై ఖర్చు చేసే ప్రతి token, అది చదువుతున్న code కోసం అందుబాటులో ఉండదు. ప్రతి turn లోనూ దానికి మళ్లీ చెల్లించాలి, ఎందుకంటే ప్రతి request తో మొత్తం context window మళ్లీ పంపబడుతుంది. అందువల్ల ఉపయోగకరమైన ప్రశ్న “ఏ mechanism ఈ పని చేయగలదు?” అనేది కాదు. సాధారణంగా ఈ మూడింటితోనూ పని చేయవచ్చు. పనిలేకుండా ఉన్న సమయంలో ఏది తక్కువ ఖర్చు అవుతుందనేదే అసలు ప్రశ్న.

మీరు ఉపయోగించే ముందు ప్రతి దాని ఖర్చు

ఈ మూడు వేర్వేరు సమయాల్లో లోడ్ అవుతాయి. ఆ సమయమే వాటి మధ్య ప్రధాన తేడా.

Rules file ప్రారంభ సమయంలో, ప్రతి session లో, అది సంబంధితదా కాదా అన్నది పరిగణించకుండా పూర్తిగా లోడ్ అవుతుంది. Claude Code ప్రతి conversation ప్రారంభంలో CLAUDE.md ను చదివి, దాని పొడవుతో సంబంధం లేకుండా పూర్తిగా లోడ్ చేస్తుంది. Documented target ప్రతి file కు 200 lines కంటే తక్కువగా ఉండాలి. ఎక్కువ పొడవున్న file కు context ఎక్కువ ఖర్చవుతుంది. అలాగే దాన్ని model తక్కువ విశ్వసనీయంగా అనుసరిస్తుంది. ఈ రెండు ప్రభావాలు ఒకే దిశలో పనిచేస్తాయి. అందుకే 900-line rules file ఉపయోగకరంగా ఉండటంకన్నా హానికరంగా ఉంటుంది.

Skill రెండు దశల్లో లోడ్ అవుతుంది. Startup సమయంలో ప్రతి SKILL.md frontmatter నుంచి description line మాత్రమే context లోకి వస్తుంది. అందువల్ల skill ఉందని, అది సుమారుగా ఎప్పుడు వర్తిస్తుందో model కు తెలుస్తుంది. Skill invoke చేసినప్పుడు దాని body లోడ్ అవుతుంది. కాబట్టి 400-line reference document అవసరమైన సమయం వచ్చే వరకు దాదాపు ఎలాంటి ఖర్చూ కలిగించదు.

MCP server గతంలో ఎక్కువ ఖర్చు కలిగించేది. మీరు ప్రస్తుతం చదివే చాలా పోలికలు ఈ కారణంగా పాతవైపోయాయి. ప్రస్తుత Claude Code లో tool search default గా enabled అయి ఉంటుంది. Session ప్రారంభంలో tool names మరియు server యొక్క instructions field మాత్రమే లోడ్ అవుతాయి. Claude వాటి కోసం search చేసినప్పుడు పూర్తి JSON (JavaScript object notation) schemas మాత్రమే deferred గా లోడ్ అవుతాయి. Server ను జోడించడం వల్ల ఇకపై ప్రారంభంలో వేల tokens ఖర్చు కావు. అయినప్పటికీ కొంత ఖర్చు ఉంటుంది. Tool search off ఉన్న configurations లో మాత్రం మొత్తం ఖర్చు ప్రారంభంలోనే జరుగుతుంది.

[
  {
    "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"
  }
]

అవి estimates మాత్రమే. మీ machine నుంచి తీసిన measurements కావు. ప్రతి mechanism లోడ్ చేసే text పరిమాణాన్ని బట్టి, సుమారుగా నాలుగు characters కు ఒక token చొప్పున ఇవి లెక్కించబడ్డాయి: 200-line rules file దాదాపు 10 KB markdown, skill description దాదాపు 160 characters, మరియు పన్నెండు tools ను అందించే server వద్ద సుమారుగా 18 KB schema తో పాటు 2 KB instructions block ఉంటుంది. Claude Code ప్రతి tool description మరియు ప్రతి server instructions field ను 2 KB వద్ద truncate చేస్తుంది. అందువల్ల ఆ భాగానికి గరిష్ఠ పరిమితి ఉంటుంది. మీ స్వంత వాస్తవ సంఖ్యలను ఎలా చదవాలో తదుపరి section చూపిస్తుంది.

మొదటి రెండు rows ను కలిసి చదవండి. అవసరం లేని session లో rules file 2,500 tokens ఖర్చు చేస్తుంది. అదే session లో skill 40 tokens ఖర్చు చేస్తుంది. Skill activate అయ్యే పది sessions లో ఒకదానిలో అది 3,000 tokens ఖర్చు చేస్తుంది. చివరి రెండు rows ఒకే server కు సంబంధించినవి. ఒకదాంట్లో tool search on గా, మరొకదాంట్లో off గా ఉంటుంది: 500 tokens కు వ్యతిరేకంగా 4,500 tokens. పాత MCP context bloat సలహా ఇప్పటికీ వ్యాప్తిలో ఉండటానికి ఈ తేడానే కారణం.

Tool search కు tool_reference blocks కు మద్దతు ఇచ్చే model అవసరం. August 2026 నాటికి ఇందులో Claude Sonnet 4.5, Haiku 4.5, Opus 4.5 మరియు తరువాతి versions ఉన్నాయి. ANTHROPIC_BASE_URL first-party కాని host ను సూచించినప్పుడు Claude Code tool search ను off చేస్తుంది, ఎందుకంటే చాలా proxies ఆ blocks ను forward చేయవు. దీన్ని నియంత్రించడానికి ENABLE_TOOL_SEARCH ను set చేయండి: false ప్రతి schema ను ప్రారంభంలోనే load చేస్తుంది, true అన్నింటినీ defer చేస్తుంది, మరియు auto schemas context window లోని 10% లోపల సరిపడినప్పుడు మాత్రమే వాటిని ప్రారంభంలో load చేస్తుంది.

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

డేటా ప్రతి invocation మధ్య మారుతుందా అనేదే నిర్ణయాత్మక ప్రశ్న.

ముందుగా దీన్నే అడగాలి, ఎందుకంటే ఇది ఒక ఎంపికను వెంటనే తొలగిస్తుంది. Agent తదుపరి సారి చూసే సమయానికి మారిపోయి ఉండగల దాన్ని చదవాలి లేదా రాయాలి అంటే, మీకు server అవసరం. ఉదాహరణకు issue tracker, database, monitoring dashboard లేదా మీ స్వంత internal API (application programming interface). దాన్ని రాసి ఉంచడం ఉపయోగకరం కాదు, ఎందుకంటే మరెవరైనా record ను సవరించిన వెంటనే మీరు రాసినది పాతదైపోతుంది.

ఎవరూ నిర్వహించకపోయినా ఆ సమాధానం ఆరు వారాల తర్వాత కూడా సరైనదిగానే ఉంటే, మీకు 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 కి ఒక్కో line ఉంచండి. ఒక entry steps గా విస్తరించిన క్షణం నుంచి అది వాస్తవం కాక procedure అవుతుంది. అప్పుడు దాన్ని skill లోకి మార్చాలి.

Rules file సరిపడే సందర్భం

Rules files అనేక ప్రదేశాల నుంచి load అవుతాయి. అవి విస్తృత పరిధి నుంచి అత్యంత నిర్దిష్ట పరిధి వరకు ఈ క్రమంలో ఉంటాయి: managed policy file, మీ వ్యక్తిగత ~/.claude/CLAUDE.md, project యొక్క ./CLAUDE.md లేదా ./.claude/CLAUDE.md, అలాగే gitignored ./CLAUDE.local.md. కనుగొనబడిన అన్ని files ఒకదానిని మరొకటి override చేయకుండా కలిపి ఉపయోగించబడతాయి. మీ working directory కి దగ్గరగా ఉన్న files చివరిగా చదవబడతాయి.

Claude Code, AGENTS.md ను కాదు, CLAUDE.md ను చదువుతుంది. మీ repository లో ఇతర tools కోసం ఇప్పటికే AGENTS.md ఉంటే, పరస్పరం మార్పులు ప్రతిబింబించకుండా విడిపోయే రెండు copies ను నిర్వహించవద్దు.

ln -s AGENTS.md CLAUDE.md

Symlink విజయవంతమైనప్పుడు ఏ output ను చూపదు. ఒక session ప్రారంభించి, /context ను అమలు చేయండి. తరువాత Memory files కింద CLAUDE.md కనిపిస్తుందో నిర్ధారించండి. అది అక్కడ జాబితా కాలేదంటే, agent దాన్ని ఎప్పుడూ చూడలేదు. అలాంటప్పుడు పదాలను మార్చడం వల్ల ప్రయోజనం ఉండదు. Claude-specific lines కూడా కావాలంటే, బదులుగా import రూపాన్ని ఉపయోగించి, వాటిని import కింద ఉంచండి.

@AGENTS.md

## Claude Code

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

ఇక్కడ ఒక ముఖ్యమైన పొరపాటు అవకాశం ఉంది. @path imports context ను save చేయవు. Referencing చేసిన file తో పాటు imported file launch సమయంలో expand చేసి load చేయబడుతుంది. ఇది గరిష్ఠంగా నాలుగు hops లోతు వరకు జరుగుతుంది. 600-line rules file ను ఆరు imports గా విభజించడం మనుషులకు దాన్ని నిర్వహించడం సులభం చేస్తుంది. కానీ token cost లో ఖచ్చితంగా ఎలాంటి మార్పూ ఉండదు. Layout నిర్ణయించే ముందు AGENTS.md మరియు దాని మానవ-కేంద్రిత ప్రతిరూపం వెనుక ఉన్న conventions చదవడం ఉపయోగకరం.

Cost ను తగ్గించేది paths field కలిగిన .claude/rules/. paths frontmatter ఉన్న rule file, patterns లోని ఒకదానికి సరిపడే file ను agent access చేసినప్పుడు మాత్రమే load అవుతుంది.

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

# API rules

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

paths field లేని rule, .claude/CLAUDE.md తో సమానమైన priority తో launch సమయంలో load అవుతుంది. అందువల్ల ఉపయోగకరమైన విధానం: చిన్న unconditional rules ను ఉంచి, ఒక directory లో మాత్రమే అవసరమైన విషయాలకు paths list ను జోడించడం.

మీకు ఒక skill అవసరమైనప్పుడు

ఒక skill అనేది దానిలో SKILL.md ఉన్న directory. వ్యక్తిగత skills ~/.claude/skills/<name>/SKILL.md లో ఉంటాయి. అవి మీ machine లోని ప్రతి 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.

ఆ file లోని description మాత్రమే skill అమలు కావడానికి ముందు context లోకి వచ్చే భాగం. అందువల్ల అది రెండు పనులు చేస్తుంది. skill ఏమి చేస్తుందో అది చెబుతుంది. దాన్ని ఎప్పుడు ఉపయోగించాలో కూడా అది చెబుతుంది. "Helps with deploys" అనే description ఉంటే, request తో సరిపోల్చడానికి model కు ఏ సమాచారం ఉండదు. అందువల్ల skill నిశ్శబ్దంగా ఎప్పుడూ అమలు కాదు. చివరకు skills పనిచేయవని మీరు భావిస్తారు.

Directory పేరు command గా మారుతుంది. కాబట్టి పై ఉదాహరణలో మీకు /summarize-changes లభిస్తుంది. Personal skill లేదా project skill లోని frontmatter name listings లో కనిపించే label ను మాత్రమే నిర్ణయిస్తుంది.

ఒక skill invoke అయిన తర్వాత, దాని rendered content conversation లోకి ఒకే message గా చేరుతుంది. Session మిగిలినంత కాలం అది అక్కడే ఉంటుంది. తరువాతి turns లో Claude Code ఆ file ను మళ్లీ చదవదు. ఒక్కసారి మాత్రమే చేసే steps బదులుగా నిరంతరం వర్తించే instructions రాయండి. Body ను సంక్షిప్తంగా ఉంచండి. ఎందుకంటే ఆ దశ నుంచి ప్రతి request పై ప్రతి line మళ్లీ ఖర్చవుతుంది. Auto-compaction తర్వాత Claude Code ప్రతి skill యొక్క అత్యంత ఇటీవలి invocation ను మళ్లీ జతచేస్తుంది. ప్రతి skill నుంచి మొదటి 5,000 tokens ను కలిపిన 25,000 tokens budget లో ఉంచుతుంది. ఒకే session లో అనేక పెద్ద skills ను invoke చేస్తే, అత్యంత పాత skills పూర్తిగా తొలగించబడతాయి. అందుకే దీర్ఘమైన conversation తర్వాత skill ప్రభావం తగ్గినట్లు అనిపించవచ్చు. దాన్ని మళ్లీ invoke చేస్తే తిరిగి వస్తుంది. ఒకే procedure ఒకటి కంటే ఎక్కువ codebase లకు వర్తించినప్పుడు, file ను కాపీ చేయడం కంటే అనేక repositories మధ్య ఒక skill ను share చేయండి.

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 స్వంత options ను మీ server ను ప్రారంభించే command line నుంచి వేరు చేస్తుంది. దీన్ని వదిలేస్తే, server కోసం ఉద్దేశించిన --port 8080 ను claude mcp add option గా parse చేస్తుంది. అప్పుడు అది దాన్ని తిరస్కరిస్తుంది.

claude mcp list
claude mcp get notion

claude mcp add ఒక Added ... line తో నిర్ధారిస్తుంది. ఇది configuration disk కు రాయబడిందని మాత్రమే చెబుతుంది. నిజమైన స్థితిని claude mcp list చెబుతుంది. ఇది ప్రతి server పక్కన health status ను ముద్రిస్తుంది: ✔ Connected, ! Needs authentication లేదా ✘ Failed to connect. Failure status అంటే Claude Code ఆ server ను చేరుకోలేకపోయిందని అర్థం. List command విఫలమైందని కాదు. Session లో /mcp ప్రతి server కు ఇదే వివరాలతో పాటు tool count ను కూడా చూపిస్తుంది.

MCP server కు చేసే ప్రతి call స్వతంత్రంగా ఉంటుంది. దానికి అవసరమైన మొత్తం సమాచారాన్ని అది తనతో తీసుకెళ్తుంది. అందుకే MCP server మీ మునుపటి అభ్యర్థనను గుర్తుంచుకోదు. ఇది మీరు స్వీకరించాల్సిన ఒక design choice తో వస్తుంది: నిల్వ చేయాల్సిన ఏ state అయినా server వెనుక, database లేదా file లో ఉండాలి. ఇప్పుడు దాని నిర్వహణ కూడా మీ బాధ్యత అవుతుంది.

MCP server అనేది మీరు అమలు చేయాల్సిన process

వెండర్ పోలికలు చూపించని ఖర్చు ఇదే. Skill అనేది ఒక file. MCP server అనేది ఎక్కడో నడిచే software. ఆ software మీ VPS (virtual private server)లో నడిస్తే, దాని uptime బాధ్యత మీపై ఉంటుంది.

stdio server అనేది తక్కువ ఖర్చుతో కూడిన సందర్భం. Session ప్రారంభమైనప్పుడు Claude Code దాన్ని child processగా ప్రారంభిస్తుంది. Session ముగిసినప్పుడు అది ఆగిపోతుంది. Monitor చేయాల్సినది ఏదీ ఉండదు. దాని స్వంత schedule ప్రకారం patch చేయాల్సిన అవసరం ఉండదు. Remote HTTP server మాత్రం ఎక్కువకాలం నడిచే service. అలాంటి ప్రతి 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 లేదా మరొక process ఇప్పటికే ఉపయోగిస్తున్న port కావచ్చు. ఇక్కడ Restart=on-failure ఐచ్ఛికం కాదు. ఎందుకంటే crash అయిన MCP server తనంతట తాను తెలియజేయదు. Agent మీ issue trackerను చదవలేకపోతున్నానని చెప్పినప్పుడు మాత్రమే విషయం తెలుస్తుంది.

Processను 127.0.0.1 కు bind చేసి, దాని ముందు TLS (transport layer security)తో reverse proxy ఉంచండి. మీ databaseకు చేరుకుని, authentication లేకుండా public portపై సమాధానం ఇచ్చే MCP server అంటే మీరు publicగా అందుబాటులో ఉంచిన database అన్నమాట. VPSపై MCP serverను అమలు చేయడంలో proxy, certificate, firewall అంశాలను సరిగ్గా వివరించారు.

తర్వాత పునరావృతమయ్యే పనిని నిజాయితీగా లెక్కించండి. Agentతో మాట్లాడే serviceకు సంబంధం లేకుండా, ఆ service తన స్వంత schedule ప్రకారం security updates స్వీకరిస్తుంది. దాని OAuth token గడువు ముగుస్తుంది. అనుకూలం కాని సమయంలో claude mcp list, ! Needs authentication ను చూపించడం ప్రారంభిస్తుంది. దాని credentials config fileలో లేదా Authorization headerలో ఉంటాయి. అందువల్ల ఇతర secretsలాగే వాటినీ జాగ్రత్తగా నిర్వహించాలి. ఇది ప్రత్యేకంగా పరిశీలించాల్సిన పెద్ద అంశం: AI agentకు secrets అందకుండా ఉంచడం. Skillకు ఈ పనుల్లో ఏదీ ఉండదు.

మీరు నిర్మించే ముందు ప్రత్యామ్నాయంతో పోల్చి నిర్ణయించండి. ప్రతిపాదిత server వెనుక ఉన్న dataలో మార్పులు సుమారు quarterకు ఒకసారి మాత్రమే ఉంటే, agent ఎక్కడ చూడాలో మరియు fields అర్థం ఏమిటో తెలిపే skillను ఉపయోగించడం, మీరు నిరంతరం నడిపించాల్సిన service కంటే చవకగా ఉంటుంది.

మీ స్వంత context ఖర్చును ఎలా కొలవాలి

అంచనా వేయడం ఆపి, ఒక session లో /context ను అమలు చేయండి. ఇది startup breakdown ను చూపిస్తుంది: system prompt, memory files, tools మరియు MCP servers. ప్రతి అంశానికి సంబంధించిన token weight కూడా చూపిస్తుంది.

రెండు విషయాలను తనిఖీ చేయండి. Memory files కింద, మీరు ఆశించే ప్రతి rules file జాబితాలో ఉందో నిర్ధారించండి. ఏదైనా file లేకపోతే agent దాన్ని చూడలేడు. అందువల్ల instructions అమలు కాకపోతే ముందుగా పరిశీలించాల్సిన విషయం ఇదే. తరువాత మీ servers ఎంత ఖర్చు చేస్తున్నాయో చూడండి. నెలకు రెండుసార్లు మాత్రమే ఉపయోగించే server ఆ జాబితాలోని అతిపెద్ద అంశాలలో ఒకటైతే, /mcp లో దాన్ని off చేసి, అవసరమైన sessions కోసం మళ్లీ on చేయండి. రెండు సందర్భాల్లోనూ configuration అలాగే నిల్వ ఉంటుంది.

ఒక remote server cached 2h ago · connects on first use · 5 tools వంటి status ను కూడా చూపించవచ్చు. అంటే Claude Code startup సమయంలో connect కాకుండా, మునుపటి session నుంచి tool list ను చదివిందని అర్థం. ఏదైనా tool ను మొదటిసారి call చేసినప్పుడు అది connect అవుతుంది. మీ మొదటి message నుంచే tools అందుబాటులో ఉంటాయి. కాబట్టి సరిచేయాల్సిన సమస్య ఏదీ లేదు. ప్రతి server startup సమయంలో connect కావాలంటే MCP_DISCOVERY_CACHE=0 ను సెట్ చేయండి. మొత్తం పరిస్థితిని అర్థం చేసుకోవడానికి Claude Code context window ను నిర్వహించడం compaction తర్వాత ఏవి కొనసాగుతాయో వివరిస్తుంది. ఆ tokens మీకు వాస్తవంగా ఎంత ఖర్చవుతాయి అనే అంశం ఆ సంఖ్యలను డబ్బు విలువగా చూపిస్తుంది.

నా skill ఎందుకు ఎప్పుడూ trigger కావడం లేదు?

సాధారణ కారణం description. Skill అమలు కావడానికి ముందు context లో ఉండే ఏకైక text ఇదే. అందువల్ల ఇది పరిస్థితిని స్పష్టంగా పేర్కొనకపోతే ఏదీ match కాదు. Trigger ను sentence లోనే రాయండి: "వినియోగదారు ఏమి మారిందని అడిగినప్పుడు, commit message కోరినప్పుడు లేదా వారి diff ను review చేయమని అడిగినప్పుడు ఉపయోగించండి." అస్పష్టమైన వివరణలు ఎలాంటి error లేకుండానే విఫలమవుతాయి. అందువల్ల సమస్యను గుర్తించడం కష్టం.

రెండవ కారణం frontmatter typo. ఈ సందర్భంలో error స్పష్టంగా కనిపిస్తుంది. తెలియని key ను నేరుగా 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 లోని .claude/skills/ నుంచి, repository root వరకు ఉన్న ప్రతి parent directory లో load అవుతాయి. మీరు ప్రారంభించిన directoryకి దిగువన ఉన్న nested directories లోని skills launch సమయంలో load కావు. Agent ఆ subdirectory లోని file ను మొదటిసారి చదివినప్పుడు లేదా సవరించినప్పుడు అవి కనిపిస్తాయి. అప్పటి వరకు అవి autocomplete లో కనిపించవు, పేరుతో invoke చేయలేరు.

MCP లో దీనికి సమానమైన silent failure, url ఉన్నప్పటికీ .mcp.json entry లో type లేకపోవడం. type లేని ప్రతి entry ను Claude Code stdio server గా పరిగణిస్తుంది. అందువల్ల ఆ entry ను skip చేసి, ఈ సందేశాన్ని చూపిస్తుంది:

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

మూడు విధానాలను కలిపి ఉపయోగించడం

ఈ మూడు విధానాలు ఒకే స్థానం కోసం పోటీ పడవు. సమర్థవంతమైన అమరికలో, ఖర్చు తక్కువగా ఉండే చోట ప్రతి విధానాన్ని ఉపయోగిస్తారు. అన్ని సందర్భాల్లో వర్తించే కొన్ని నియమాలను rules file లో ఉంచాలి. procedures ను skills లో ఉంచాలి; అవి వర్తించినప్పుడు మాత్రమే load అవుతాయి. ముందుగా ఊహించలేని contents ఉన్న systems కు ఒక MCP server ను, అవసరమైతే రెండు MCP servers ను, connect చేయాలి. వీటిలో మొదటి విధానం గురించి మీ mental model ను ఇంకా రూపొందిస్తున్నట్లయితే, agent skill వాస్తవానికి ఏమిటి అనే వివరణలో format ను వివరంగా చూడవచ్చు.

ఏదైనా విషయం ఎక్కడ ఉండాలో నిర్ణయించడానికి ఒక test చాలాసార్లు సరిపోతుంది. దాన్ని తొలగించి, కొత్త session ప్రారంభించి, agent కు task ఇవ్వండి. Agent కేవలం నెమ్మదిగా పనిచేస్తే, అది skill లో ఉండాలి. Agent ధైర్యంగా తప్పు సమాధానం ఇస్తే, అది rules file లో ఉండాలి. Agent కు ఆ information అసలు లభించకపోతే, మీకు server అవసరం. ఆ server ను ఎల్లప్పుడూ up గా ఉంచే plan కూడా ఇప్పుడు అవసరం.

FAQ

నేను skill రాయాలా, లేక MCP server ప్రారంభించాలా?

ఒక invocation నుంచి తదుపరి invocation వరకు సమాచారం మారుతుందా అనే దానిపై నిర్ణయించండి. issue tracker, database లేదా dashboard వంటి మరెవరైనా మార్చగల live state ను agent చదవాల్సి ఉంటే, మీకు MCP server అవసరం. ఎందుకంటే record మారిన వెంటనే మీరు రాసి ఉంచిన సమాచారం stale అయిపోతుంది. ఒకసారి సమాధానం రాసి ఉంచినా ఆరు వారాల తర్వాత కూడా అది సరైనదిగా ఉంటే, skill రాయండి. skill అనేది git లోని ఒక file. దాన్ని అమలు చేయడానికి process, expose చేయడానికి port లేదా patch schedule అవసరం ఉండదు. అందువల్ల సాధ్యమైనప్పుడు ఇది తక్కువ ఖర్చుతో కూడిన ఎంపిక.

MCP servers ఇప్పటికీ నా context window ను నింపుతాయా?

గతంతో పోలిస్తే చాలా తక్కువగా నింపుతాయి. ప్రస్తుత Claude Code లో tool search default గా enabled ఉంటుంది. అందువల్ల session ప్రారంభంలో tool names మరియు server యొక్క instructions field మాత్రమే load అవుతాయి. Claude వాటి కోసం search చేసినప్పుడు full schemas fetch అవుతాయి. Tool search off లో ఉన్నప్పుడు upfront loading ఇంకా జరుగుతుంది: ENABLE_TOOL_SEARCH=false ఉన్నప్పుడు, ANTHROPIC_BASE_URL ను first-party కాని proxy కు point చేసినప్పుడు లేదా Claude 4.5 generation కంటే పాత model ఉపయోగించినప్పుడు. మీరు ఏ పరిస్థితిలో ఉన్నారో చూడటానికి /context run చేయండి. పాత comparison posts లోని సంఖ్యలు upfront loading ను ఆధారంగా చేసుకున్నాయి.

Claude Code AGENTS.md ను చదువుతుందా?

లేదు. Claude Code CLAUDE.md ను చదువుతుంది. మీ repository లో ఇతర agents కోసం ఇప్పటికే AGENTS.md ఉంటే, రెండు copies ఉంచకుండా ఒకదాన్ని మరొకదానికి point చేయండి. సాధారణ symlink కోసం ln -s AGENTS.md CLAUDE.md run చేయండి. లేదా CLAUDE.md లోని మొదటి line పై @AGENTS.md ఉంచి, దాని కింద Claude-specific instructions జోడించండి. తరువాత session ప్రారంభించి, CLAUDE.md Memory files కింద కనిపిస్తుందో నిర్ధారించడానికి /context run చేయండి.

Session మధ్యలో నా skill ప్రభావం చూపడం ఎందుకు ఆగిపోయింది?

సాధారణ కారణం auto-compaction. Conversation summarize అయినప్పుడు, Claude Code ప్రతి skill యొక్క అత్యంత ఇటీవలి invocation ను మళ్లీ attach చేస్తుంది. ప్రతి skill లో మొదటి 5,000 tokens వరకు ఉంచుతుంది. వీటన్నింటికీ కలిపి 25,000 tokens budget ఉంటుంది. ఇటీవలి invocation చేసిన skill నుంచి ప్రారంభించి ఆ budget ను నింపుతుంది. కాబట్టి మీరు అనేక పెద్ద skills ను invoke చేసి ఉంటే, పాత skills పూర్తిగా తొలగించబడతాయి. పూర్తి content ను తిరిగి పొందడానికి skill ను మళ్లీ invoke చేయండి.

ప్రతి session లో పొడవైన rules file load కాకుండా ఎలా ఆపాలి?

కొన్ని సందర్భాల్లో మాత్రమే అవసరమైన భాగాలను .claude/rules/ files లోకి తరలించండి. వాటి frontmatter లో paths field ఉంచండి. అప్పుడు agent సరిపోలే file ను access చేసినప్పుడు మాత్రమే అవి load అవుతాయి. File ను @path imports గా విభజించడం ఉపయోగపడదు. ఎందుకంటే imported files expand అయి, వాటిని reference చేసిన file తో పాటు launch సమయంలో load అవుతాయి. Multi-step procedure గా ఉండే ఏదైనా అంశాన్ని standing fact గా కాకుండా skill గా మార్చండి. Skill body invoke చేసే వరకు ఎటువంటి ఖర్చూ ఉండదు.