Agent skills vs MCP servers vs rules files: alin ang

Mga skill ng agent vs MCP servers vs rules files: ang maikling sagot

Lahat ng agent skills, MCP servers, at rules files ay naglalagay ng kaalaman sa harap ng coding agent. Pumili batay sa gamit ng kaalamang iyon. Ang MCP (model context protocol) ay para sa data na maaaring magbago sa susunod na pagtingin mo rito. Ang skill ay para sa procedure na maaari mong isulat ngayon at tama pa rin pagkalipas ng anim na linggo. Ang rules file ay para sa iilang fact na dapat laging masunod sa bawat session.

May kapalit ang pagpiling ito, at ang kapalit ay context. Bawat token na ginugol sa instruction na hindi kailangan ng agent ay token na hindi magagamit sa code na binabasa nito. Binabayaran mo rin ang token na iyon sa bawat turn, dahil ipinapadala muli ang buong context window sa bawat request. Kaya hindi ang tanong kung aling mechanism ang makagagawa ng trabaho. Sa karamihan ng pagkakataon, kaya ito ng lahat ng tatlo. Ang tamang tanong ay kung alin ang may pinakamababang gastos habang hindi ito ginagamit.

Magkano ang gastos ng bawat isa bago mo ito gamitin

Nilo-load ang tatlo sa magkakaibang pagkakataon, at ang timing na iyon ang pangunahing pagkakaiba.

Ang rules file ay ganap na nilo-load sa pagsisimula, sa bawat session, kailangan man ito o hindi. Binabasa ng Claude Code ang CLAUDE.md sa simula ng bawat conversation at nilo-load ito nang buo anuman ang haba. Ang nakadokumentong target ay wala pang 200 linya bawat file, dahil mas malaki ang context na kinakain ng mas mahabang file at mas hindi ito nasusunod nang maaasahan. Parehong nagpapalala sa sitwasyon ang dalawang epektong ito, kaya mas masahol pa sa walang silbi ang 900-line rules file.

Dalawang yugto ang loading ng isang skill. Sa startup, ang description line lamang mula sa frontmatter ng bawat SKILL.md ang pumapasok sa context, kaya alam ng model na umiiral ang skill at kung kailan ito karaniwang ginagamit. Nilo-load ang body kapag tinawag ang skill. Kaya halos walang gastos ang 400-line reference document hanggang sa sandaling kailanganin ito.

Dati, ang MCP server ang pinakamalaki ang gastos, at dito luma na ang karamihan sa mga paghahambing na mababasa mo ngayon. Naka-enable bilang default ang tool search sa kasalukuyang Claude Code. Ang mga pangalan lamang ng tool at ang instructions field ng server ang nilo-load sa pagsisimula ng session, at ipinagpapaliban ang buong JSON (JavaScript object notation) schemas hanggang sa hanapan ito ni Claude. Hindi na nagkakahalaga ng libo-libong tokens agad ang pagdaragdag ng server. May gastos pa rin ito, at agad nitong sinisingil ang buong gastos sa mga configuration na naka-off ang 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"
  }
]

Mga pagtatantiya ang mga ito, hindi mga sukat mula sa iyong machine. Batay ang mga ito sa laki ng text na nilo-load ng bawat mechanism, sa tinatayang apat na character bawat token: ang 200-line rules file ay humigit-kumulang 10 KB ng markdown, ang skill description ay humigit-kumulang 160 character, at ang server na naglalantad ng labindalawang tool ay may humigit-kumulang 18 KB ng schema at 2 KB na instructions block. Tine-truncate ng Claude Code sa 2 KB ang bawat tool description at bawat server instructions field, kaya may maximum ang bahaging iyon. Ipapakita sa susunod na section kung paano basahin ang aktuwal mong mga numero.

Basahin nang magkasama ang unang dalawang row. Ang rules file ay nagkakahalaga ng 2,500 tokens sa isang session kung saan walang nangangailangan nito. Ang skill ay nagkakahalaga ng 40 tokens sa parehong session, at 3,000 sa isang session sa bawat sampu kung saan ito gumagana. Ang huling dalawang row ay iisang server na ipinakita nang dalawang beses, na naka-on at naka-off ang tool search: 500 tokens laban sa 4,500. Ang agwat na ito ang dahilan kung bakit patuloy pa ring kumakalat ang lumang payo tungkol sa MCP context bloat.

Kailangan ng tool search ng model na sumusuporta sa tool_reference blocks. Noong August 2026, kabilang dito ang Claude Sonnet 4.5, Haiku 4.5, Opus 4.5, at mga mas bagong version. Ino-off ito ng Claude Code kapag nakaturo ang ANTHROPIC_BASE_URL sa host na hindi first party, dahil hindi ipinapasa ng karamihan sa mga proxy ang mga block na iyon. Itakda ang ENABLE_TOOL_SEARCH upang kontrolin ito: nilo-load ng false ang lahat ng schema agad, ipinagpapaliban ng true ang lahat ng ito, at nilo-load ng auto ang mga ito agad kapag kasya ang mga ito sa loob ng 10% ng context window.

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

Ang pangunahing tanong: nagbabago ba ang data sa pagitan ng mga invocation?

Itanong muna ito dahil agad nitong inaalis ang isang option. Kung kailangang magbasa o magsulat ang agent ng isang bagay na maaaring mag-iba sa susunod nitong pagtingin, kailangan mo ng server. Halimbawa, issue tracker, database, monitoring dashboard, o sarili mong internal API (application programming interface). Hindi makatutulong ang pagsulat nito sa file dahil stale na agad ang isinulat mo kapag may ibang nag-edit ng record.

Kung tama pa rin ang sagot pagkalipas ng anim na linggo kahit walang nagme-maintain nito, skill ang kailangan mo. Halimbawa, release checklist, migration procedure, format ng error responses, o paraan ng pagsulat ng tests sa repository na ito. Ang skill ay isang file sa git. Wala itong port, process, o failure mode maliban sa pagiging mali, at matutukoy ito ng code review.

Kung isa itong fact na dapat mailapat sa trabahong hindi mo pa napag-iisipan, ilagay ito sa rules file. Run make lint before committing. Never push to main. Handlers live in src/api/handlers/. Tig-iisang linya. Kapag naging sunod-sunod na hakbang ang isang entry, hindi na ito fact kundi procedure, kaya dapat itong ilipat sa isang skill.

Kapag sapat na ang rules file

Nilo-load ang rules files mula sa ilang lugar, mula sa pinakamalawak hanggang sa pinakatukoy: isang managed policy file, ang personal mong ~/.claude/CLAUDE.md, ang ./CLAUDE.md o ./.claude/CLAUDE.md ng project, at isang gitignored na ./CLAUDE.local.md. Pinagsasama ang lahat ng natukoy na file sa halip na magpalitan ang mga ito, at huling binabasa ang mga file na mas malapit sa working directory mo.

Binabasa ni Claude Code ang CLAUDE.md, hindi ang AGENTS.md. Kung mayroon nang AGENTS.md ang repository mo para sa ibang tools, huwag magpanatili ng dalawang kopya na maaaring magkaiba sa paglipas ng panahon.

ln -s AGENTS.md CLAUDE.md

Walang inilalabas ang symlink kapag matagumpay. Magsimula ng session, patakbuhin ang /context, at tiyaking lumilitaw ang CLAUDE.md sa ilalim ng Memory files. Kung hindi ito nakalista roon, hindi pa ito nakita ng agent at walang makatutulong na rewording. Kung gusto mo ring maglagay ng mga linyang partikular kay Claude, gamitin sa halip ang import form at ilagay ang mga ito sa ibaba ng import.

@AGENTS.md

## Claude Code

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

May isang karaniwang bitag dito. Hindi nagse-save ng context ang @path imports. Ine-expand at nilo-load ang imported file sa launch, kasabay ng file na nag-reference rito, hanggang apat na hop ang lalim. Ang paghahati ng 600-line rules file sa anim na import ay nag-aayos lamang nito para sa mga tao at eksaktong walang binabago sa token cost. Mainam basahin ang mga convention sa likod ng AGENTS.md at ng human-facing nitong katumbas bago magpasya sa layout.

Ang talagang nagpapababa sa cost ay ang .claude/rules/ na may paths field. Ang rules file na may paths frontmatter ay nilo-load lamang kapag nagbubukas ang agent ng file na tumutugma sa isa sa mga pattern.

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

# API rules

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

Ang rule na walang paths field ay nilo-load sa launch na kapantay ang priority ng .claude/CLAUDE.md. Kaya ang praktikal na pattern ay maiikling unconditional rule, kasama ang paths list sa anumang rule na mahalaga lamang sa loob ng isang directory.

Kapag gusto mo ng isang skill

Ang skill ay isang directory na may SKILL.md sa loob nito. Ang personal skills ay nasa ~/.claude/skills/<name>/SKILL.md at nalalapat sa lahat ng project sa machine mo. Ang project skills ay nasa .claude/skills/<name>/SKILL.md, kasama sa repository, at maaaring i-review sa pull request gaya ng ibang file.

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.

Ang description ang tanging bahagi ng file na nasa context bago tumakbo ang skill, kaya dalawang gawain ang ginagawa nito. Sinasabi nito kung ano ang ginagawa ng skill at kung kailan ito dapat gamitin. Walang sapat na batayan ang model para iugnay sa request ang description na "Tumutulong sa deploys", kaya hindi kailanman awtomatikong tumatakbo ang skill at maiisip mong hindi gumagana ang skills.

Ang pangalan ng directory ang nagiging command, kaya ang halimbawa sa itaas ay nagbibigay sa iyo ng /summarize-changes. Sa personal o project skill, itinatakda ng frontmatter name ang display label lamang sa mga listing.

Kapag na-invoke ang isang skill, pumapasok ang rendered content nito sa conversation bilang isang mensahe at nananatili roon hanggang sa matapos ang session. Hindi muling binabasa ng Claude Code ang file sa mga susunod na turn. Sumulat ng mga standing instruction sa halip na mga step na para sa isang beses lang, at panatilihing maikli ang body dahil mula sa puntong iyon, recurring cost ang bawat linya sa bawat request. Pagkatapos ng auto-compaction, muling ikinakabit ng Claude Code ang pinakabagong invocation ng bawat skill. Pinananatili nito ang unang 5,000 tokens ng bawat isa sa pinagsamang budget na 25,000 tokens. Kapag nag-invoke ka ng ilang malalaking skill sa isang session, ganap na inaalis ang pinakamatatanda. Dahil dito, maaaring magmukhang hindi na nakaaapekto ang isang skill pagkatapos ng mahabang conversation. I-invoke itong muli para bumalik. Kapag pareho ang procedure para sa higit sa isang codebase, mag-share ng isang skill sa maraming repository sa halip na kopyahin ang file sa iba’t ibang lugar.

Kapag kailangan mo ng MCP server

Isang command lang ang kailangan para magdagdag nito, at ang transport ang nagtatakda ng anyo nito.

# 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

Mahalaga ang --. Para sa stdio server, hinihiwalay nito ang sariling options ng Claude Code sa command line na nagsisimula sa server mo. Kapag iniwan ito, ang --port 8080 na para sa server ay mababasa bilang option ng claude mcp add, at tatanggihan ito ng huli.

claude mcp list
claude mcp get notion

Kinukumpirma ng claude mcp add ang operasyon gamit ang isang Added ... line, na nagsasabi lamang na naisulat sa disk ang configuration. Ang claude mcp list ang command na nagbibigay ng aktuwal na resulta, dahil nagpi-print ito ng health status sa tabi ng bawat server: ✔ Connected, ! Needs authentication, o ✘ Failed to connect. Ibig sabihin ng failure status ay hindi maabot ng Claude Code ang server na iyon, hindi na may problema ang list command. Sa loob ng session, nagbibigay ang /mcp ng parehong view para sa bawat server, kasama ang bilang ng tools.

Bawat tawag sa isang MCP server ay hiwalay at dala nito ang lahat ng kailangan nito. Ito ang dahilan kung bakit hindi naaalala ng isang MCP server ang dati mong request. May kapalit ang design choice na ito: anumang state na kailangang panatilihin ay dapat nasa likod ng server, sa isang database o file, at kailangan mo na itong i-operate.

Ang MCP server ay isang prosesong kailangan mong patakbuhin

Narito ang gastos na hindi isinasama sa mga paghahambing ng vendor. Ang skill ay isang file. Ang MCP server ay software na tumatakbo sa isang lugar. Kapag ang lugar na iyon ay ang iyong VPS (virtual private server), ikaw ang responsable sa uptime nito.

Ang stdio server ang mas murang sitwasyon. I-spawn ito ng Claude Code bilang child process kapag nagsimula ang session, at nagtatapos ito kapag natapos ang session. Walang kailangang i-monitor at walang sariling iskedyul ng pag-patch. Ang remote HTTP server ay isang long-lived service. Kailangan nito ang lahat ng karaniwang kailangan ng isang 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

Dapat i-print ng systemctl is-active ang active. Kung failed ang i-print nito, nasa journal ang dahilan. Sa unang pagtakbo, halos palaging missing environment variable o port na ginagamit na ng ibang proseso ang sanhi. Hindi optional ang Restart=on-failure dito dahil hindi nito awtomatikong ipinapaalam kapag nag-crash ang MCP server. Malalaman mo lamang ito kapag sinabi ng agent na hindi nito mabasa ang iyong issue tracker.

I-bind ang proseso sa 127.0.0.1 at maglagay ng reverse proxy na may TLS (transport layer security) sa harap nito. Ang MCP server na nakaka-access sa iyong database at sumasagot sa public port nang walang authentication ay katumbas ng database na inilathala mo sa internet. Sinasaklaw nang maayos ng Pagpapatakbo ng MCP server sa isang VPS ang proxy, certificate, at firewall configuration.

Pagkatapos, bilangin nang tapat ang paulit-ulit na maintenance work. Tumatanggap ang service ng security updates ayon sa sarili nitong iskedyul, na hiwalay sa agent na kumokonekta rito. Nag-e-expire ang OAuth token nito, at nagsisimulang mag-print ang claude mcp list ng ! Needs authentication sa hindi angkop na oras. Nasa config file o Authorization header ang credentials nito, kaya kailangan ang mga ito ng parehong pag-iingat tulad ng ibang secret. Hiwalay na paksa na ito: Pag-iwas na maabot ng AI agent ang mga secret. Wala sa mga gawaing ito ang kailangan para sa isang skill.

Suriin muna ito laban sa alternatibo bago ka mag-build. Kung humigit-kumulang isang beses bawat quarter nagbabago ang data sa likod ng iminungkahing server, mas mura ang isang skill na nagsasabi sa agent kung saan titingin at kung ano ang ibig sabihin ng mga field kaysa sa service na kailangan mong panatilihing tumatakbo.

Paano sukatin ang sarili mong context cost

Huwag nang manghula at patakbuhin ang /context sa loob ng session. Ipinapakita nito ang breakdown sa pagsisimula: system prompt, memory files, tools, at MCP servers, kasama ang token weight ng bawat isa.

Suriin ang dalawang bagay. Sa ilalim ng Memory files, tiyaking nakalista ang lahat ng rules file na inaasahan mo. Hindi nakikita ng agent ang nawawalang file, kaya ito ang unang dapat i-check kapag hindi sinusunod ang mga instruction. Pagkatapos, tingnan kung magkano ang context cost ng iyong mga server. Kung ang server na ginagamit mo nang dalawang beses bawat buwan ay kabilang sa pinakamalalaking entry sa listahang iyon, i-toggle ito sa /mcp at i-on muli para sa mga session na nangangailangan nito. Nananatili ang configuration sa alinmang paraan.

Maaari ring mag-ulat ang remote server ng status na gaya ng cached 2h ago · connects on first use · 5 tools. Nangangahulugan ito na binasa ng Claude Code ang tool list mula sa nakaraang session sa halip na kumonekta sa pagsisimula, at kokonekta ito sa unang pagtawag sa isang tool. Available ang mga tool mula sa una mong message, kaya walang kailangang ayusin. Itakda ang MCP_DISCOVERY_CACHE=0 kung mas gusto mong kumonekta ang bawat server sa pagsisimula. Para sa mas malawak na paliwanag, tinatalakay sa pamamahala sa Claude Code context window kung ano ang nananatili pagkatapos ng compaction, at ginagawang halaga sa pera ng kung magkano talaga ang cost ng mga token na iyon para sa iyo ang mga numerong ito.

Bakit hindi kailanman nagti-trigger ang skill ko?

Ang karaniwang sanhi ay ang description. Ito lamang ang text sa context bago tumakbo ang skill, kaya kung hindi nito binabanggit ang sitwasyon, walang nagmamatch. Ilagay ang trigger sa mismong sentence: "Gamitin kapag nagtanong ang user kung ano ang nagbago, humingi ng commit message, o humiling na i-review ang kanilang diff." Tahimik na nagfa-fail ang malalabong description, kaya mahirap itong mapansin.

Ang pangalawang sanhi ay typo sa frontmatter, at maingay ang failure na ito. Agad nire-reject ang hindi kilalang key:

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

Ang pangatlo ay ang lokasyon. Nilo-load ang project skills mula sa .claude/skills/ sa working directory mo at sa bawat parent directory hanggang sa repository root. Hindi nilo-load sa launch ang mga skill sa nested directory na nasa ibaba ng lokasyon kung saan ka nagsimula. Lumilitaw ang mga ito sa unang pagkakataong magbasa o mag-edit ang agent ng file sa loob ng subdirectory na iyon, kaya bago iyon ay hindi lumalabas sa autocomplete at hindi mai-invoke gamit ang pangalan.

Ang katumbas na tahimik na failure sa MCP ay isang .mcp.json entry na may url at walang type. Binabasa ng Claude Code ang anumang entry na walang type bilang stdio server, kaya nilalaktawan nito ang entry at iniuulat:

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

Pagsasama sa tatlo

Hindi nag-aagawan ang mga mekanismong ito sa iisang puwesto. Gumagamit ang isang gumaganang setup ng bawat isa kung saan pinakamababa ang gastos nito. Naglalaman ang rules file ng ilang linya na laging naaangkop. Naglalaman ang skills ng mga procedure at nilo-load lamang kapag naaangkop ang mga ito. Kumokonekta ang isang MCP server, o kung minsan ay dalawa, sa mga system na hindi mo matitiyak nang maaga ang laman. Kung binubuo mo pa rin ang mental model mo tungkol sa una sa mga ito, inilalarawan nang detalyado ng kung ano talaga ang agent skill ang format nito.

Isang test ang karaniwang nakapaglilinaw kung saan dapat ilagay ang isang bagay. Burahin ito, magsimula ng bagong session, at ibigay sa agent ang task. Kung bumagal lamang ang agent, dapat itong nasa skill. Kung kumpiyansa ngunit mali ang sagot ng agent, dapat itong nasa rules file. Kung hindi talaga makuha ng agent ang impormasyon, kailangan mo ng server. Kailangan mo rin ngayon ng plano para mapanatiling gumagana ang server na iyon.

FAQ

Dapat ba akong magsulat ng skill o magpatakbo ng MCP server?

Magpasya batay sa kung nagbabago ang impormasyon sa bawat invocation. Kung kailangang basahin ng agent ang live state na maaaring baguhin ng ibang tao, gaya ng issue tracker, database, o dashboard, kailangan mo ng MCP server, dahil nagiging stale agad ang anumang isinulat mo kapag nagbago ang record. Kung maaari mong isulat nang isang beses ang sagot at tama pa rin ito pagkalipas ng anim na linggo, magsulat ka ng skill. Ang skill ay isang file sa git na walang prosesong patatakbuhin, port na kailangang ilantad, o patch schedule, kaya ito ang mas matipid na opsyon kapag posible.

Kumokonsumo pa rin ba ng malaking bahagi ng context window ko ang mga MCP server?

Mas kaunti na kaysa dati. Naka-enable bilang default ang tool search sa kasalukuyang Claude Code, kaya tool names at ang instructions field ng server lamang ang nilo-load sa pagsisimula ng session. Kinukuha ang buong schemas kapag hinanap ito ng Claude. Nangyayari pa rin ang upfront loading kapag naka-off ang tool search: kapag may ENABLE_TOOL_SEARCH=false, kapag nakaturo ang ANTHROPIC_BASE_URL sa proxy na hindi first party, o kapag model na mas luma kaysa sa Claude 4.5 generation ang ginagamit. Patakbuhin ang /context para makita kung alin sa mga sitwasyong ito ang naaangkop sa iyo, dahil ipinapalagay ng mga numero sa mas lumang comparison posts ang upfront loading.

Binabasa ba ng Claude Code ang AGENTS.md?

Hindi. Binabasa ng Claude Code ang CLAUDE.md. Kung mayroon nang AGENTS.md ang repository mo para sa ibang agent, ituro ang isa sa kabila sa halip na magpanatili ng dalawang kopya. Patakbuhin ang ln -s AGENTS.md CLAUDE.md para sa plain symlink, o ilagay ang @AGENTS.md sa unang linya ng CLAUDE.md at idagdag sa ibaba nito ang mga instruction na partikular sa Claude. Pagkatapos, magsimula ng session at patakbuhin ang /context upang kumpirmahing lumalabas ang CLAUDE.md sa ilalim ng Memory files.

Bakit wala nang epekto ang skill ko sa kalagitnaan ng session?

Karaniwang dahilan ang auto-compaction. Kapag bina-buod ang conversation, muling ikinakabit ng Claude Code ang pinakabagong invocation ng bawat skill. Pinananatili nito ang unang 5,000 token ng bawat isa, sa loob ng pinagsamang budget na 25,000 token para sa lahat ng skill. Pinupunan nito ang budget simula sa pinakahuling na-invoke na skill. Kaya kung ilang malalaki nang skill ang na-invoke mo, maaaring tuluyang ma-drop ang mga mas luma. I-invoke muli ang skill upang maibalik ang buong content nito.

Paano ko pipigilan ang mahabang rules file na mag-load sa bawat session?

Ilipat ang mga bahaging kailangan lamang paminsan-minsan sa mga .claude/rules/ file na may paths field sa frontmatter, upang mag-load lamang ang bawat isa kapag hinawakan ng agent ang tumutugmang file. Hindi makatutulong ang paghahati ng file sa mga @path import, dahil ine-expand at nilo-load ang mga imported file sa launch kasabay ng file na nag-reference sa mga ito. Anumang multi-step procedure, sa halip na standing fact, ay dapat gawing skill, dahil walang cost ang skill body hangga't hindi ito ini-invoke.