Agent skills, MCP או קובצי חוקים: מה לבחור?

השוואה בין Agent skills, שרתי MCP וקובצי חוקים: תשובה קצרה

Agent skills, שרתי MCP וקובצי חוקים נועדו כולם להנגיש ידע לסוכן (agent) תכנות. הבחירה ביניהם תלויה בתפקיד של אותו ידע. פרוטוקול MCP (Model Context Protocol) מיועד לנתונים שעשויים להשתנות בכל פעם שתגשו אליהם. Skill מיועד להליך שניתן לתעד היום ויהיה נכון גם בעוד שישה שבועות. קובץ חוקים מיועד למספר מצומצם של עובדות שחייבות להישאר תקפות בכל סשן.

לבחירה הזו יש מחיר, והמחיר הוא context. כל token שמושקע בהנחיה שהסוכן לא היה זקוק לה הוא token שלא יהיה זמין עבור הקוד שהוא קורא. בנוסף, זהו token שאתם משלמים עליו שוב בכל תור, כיוון שכל ה־context window נשלח מחדש בכל בקשה. לכן, השאלה המועילה אינה איזה מנגנון יכול לבצע את המשימה; ברוב המקרים, שלושתם מסוגלים לכך. השאלה היא איזה מהם גובה את המחיר הנמוך ביותר בזמן שהוא אינו בשימוש.

העלות של כל רכיב לפני השימוש בו

שלושת הרכיבים נטענים ברגעים שונים, והתזמון הזה הוא ההבדל המהותי ביניהם.

קובץ חוקים (rules file) נטען במלואו בעת ההפעלה, בכל סשן, בין אם הוא רלוונטי ובין אם לא. Claude Code קורא את CLAUDE.md בתחילת כל שיחה וטוען אותו במלואו ללא קשר לאורכו. היעד המומלץ הוא פחות מ-200 שורות לקובץ, כיוון שקובץ ארוך יותר צורך יותר context וגם נענה בצורה פחות אמינה. שתי ההשפעות הללו פועלות באותו כיוון, וזו הסיבה שקובץ חוקים באורך 900 שורות הוא גרוע יותר מחסר תועלת.

מיומנות (skill) נטענת בשני שלבים. בעת ההפעלה, רק שורת ה-description מתוך ה-frontmatter של כל SKILL.md נכנסת ל-context, כך שהמודל יודע שהמיומנות קיימת ומתי בערך היא רלוונטית. גוף המיומנות נטען רק כאשר היא מופעלת. לכן, מסמך עזר באורך 400 שורות כמעט אינו עולה לכם דבר עד לרגע שבו יש בו צורך.

בעבר, שרת MCP היה הרכיב היקר ביותר, וזהו המקום שבו רוב ההשוואות שתקראו כיום אינן מעודכנות. חיפוש כלים (tool search) מופעל כברירת מחדל בגרסה הנוכחית של Claude Code. רק שמות הכלים ושדה ההוראות של השרת נטענים בתחילת הסשן, בעוד שסכימות ה-JSON (JavaScript object notation) המלאות נדחות עד לרגע שבו Claude מחפש אותן. הוספת שרת אינה עולה יותר אלפי טוקנים מראש. היא עדיין כרוכה בעלות מסוימת, והיא עדיין עולה את מלוא המחיר מראש בתצורות שבהן חיפוש הכלים כבוי.

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

אלו הן הערכות, לא מדידות מהמכונה שלכם. הן נגזרות מגודל הטקסט שכל מנגנון טוען, לפי חישוב של כארבעה תווים לטוקן: קובץ חוקים של 200 שורות הוא כ-10 KB של markdown, תיאור מיומנות הוא כ-160 תווים, ושרת החושף שנים-עשר כלים נושא כ-18 KB של סכימה בתוספת בלוק הוראות של 2 KB. Claude Code קוטם כל תיאור כלי וכל שדה הוראות שרת ב-2 KB, כך שלחלק הזה יש תקרה. הסעיף הבא מראה לכם כיצד לקרוא את המספרים האמיתיים שלכם.

קראו את שתי השורות הראשונות יחד. קובץ החוקים עולה 2,500 טוקנים בסשן שבו איש לא נזקק לו. המיומנות עולה 40 טוקנים באותו סשן, ו-3,000 בסשן אחד מתוך עשרה שבו היא מופעלת. שתי השורות האחרונות הן אותו שרת פעמיים, עם חיפוש כלים פעיל וכבוי: 500 טוקנים לעומת 4,500. הפער הזה הוא הסיבה לכך שעצות ישנות בנוגע לנפיחות ב-context של MCP עדיין מסתובבות.

חיפוש כלים דורש מודל התומך בבלוקים של tool_reference, מה שנכון לאוגוסט 2026 אומר Claude Sonnet 4.5, Haiku 4.5, Opus 4.5 ומעלה. Claude Code מכבה את האפשרות הזו כאשר ANTHROPIC_BASE_URL מצביע על מארח שאינו צד ראשון (first party), כיוון שרוב ה-proxies אינם מעבירים את הבלוקים הללו. הגדירו את ENABLE_TOOL_SEARCH כדי לשלוט בכך: false טוען כל סכימה מראש, true דוחה את כולן, ו-auto טוען אותן מראש רק כאשר הן נכנסות בתוך 10% מחלון ה-context.

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

השאלה המכריעה: האם הנתונים משתנים בין הרצות?

שאלו זאת תחילה, כיוון שזה פוסל אפשרות אחת על הסף. אם ה-agent צריך לקרוא או לכתוב משהו שעשוי להיות שונה בפעם הבאה שהוא בודק, אתם זקוקים לשרת. מערכת לניהול משימות (issue tracker), מסד נתונים, לוח בקרה לניטור, או ה-API (ממשק תכנות יישומים) הפנימי שלכם. כתיבת המידע אינה עוזרת, כיוון שמה שכתבתם הופך למיושן ברגע שמישהו אחר עורך את הרשומה.

אם התשובה תישאר נכונה גם בעוד שישה שבועות ללא תחזוקה, אתם זקוקים ל-skill. רשימת תיוג ל-release. נוהל הגירה (migration). המבנה של הודעות השגיאה שלכם. האופן שבו המאגר הזה דורש כתיבת בדיקות. ה-skill הוא קובץ ב-git. אין לו פורט, אין לו תהליך, ואין לו מצב כשל מלבד היותו שגוי, דבר שניתן לזהות ב-code review.

אם מדובר בעובדה אחת שחייבת לחול על עבודה שטרם חשבתם עליה, הכניסו אותה לקובץ ה-rules. Run make lint before committing. Never push to main. Handlers live in src/api/handlers/. שורה אחת לכל ערך. ברגע שערך מתפתח לכדי שלבים, הוא חדל מלהיות עובדה והופך לנוהל, ועליו לעבור ל-skill.

מתי קובץ חוקים מספיק

קבצי חוקים נטענים ממספר מיקומים, מהכללי ביותר לספציפי ביותר: קובץ מדיניות מנוהל, ה-~/.claude/CLAUDE.md האישי שלכם, ה-./CLAUDE.md או ה-./.claude/CLAUDE.md של הפרויקט, וקובץ ./CLAUDE.local.md שמופיע ב-gitignore. כל הקבצים שנמצאו משורשרים זה לזה במקום לדרוס זה את זה, וקבצים הקרובים יותר לספריית העבודה שלכם נקראים אחרונים.

Claude Code קורא את CLAUDE.md, לא את AGENTS.md. אם המאגר שלכם כבר מכיל AGENTS.md עבור כלים אחרים, אל תתחזקו שני עותקים שיהפכו ללא מסונכרנים.

ln -s AGENTS.md CLAUDE.md

ה-symlink לא מדפיס דבר במקרה של הצלחה. התחילו סשן, הריצו את /context, וודאו ש-CLAUDE.md מופיע תחת Memory files. אם הוא לא מופיע שם, הסוכן מעולם לא ראה אותו ושום ניסוח מחדש לא יעזור. כאשר אתם רוצים גם שורות ספציפיות ל-Claude, השתמשו בפורמט ה-import והציבו אותן מתחת ל-import.

@AGENTS.md

## Claude Code

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

מלכודת אחת קיימת כאן. ייבוא של @path לא שומר הקשר (context). הקובץ המיובא מורחב ונטען בעת ההפעלה לצד הקובץ שהפנה אליו, עד לעומק של ארבע רמות. פיצול קובץ חוקים של 600 שורות לשישה ייבואים מארגן אותו עבור בני אדם ולא משנה את עלות ה-tokens כלל. כדאי לקרוא את המוסכמות מאחורי AGENTS.md והתאום המיועד לבני אדם לפני שתחליטו על מבנה.

מה שכן מפחית את העלות הוא .claude/rules/ עם שדה paths. קובץ חוקים המכיל frontmatter של paths נטען רק כאשר הסוכן נוגע בקובץ התואם לאחד מהדפוסים.

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

# API rules

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

חוק ללא שדה paths נטען בעת ההפעלה באותה עדיפות כמו .claude/CLAUDE.md. לכן, דפוס העבודה הנכון הוא חוקים קצרים ללא תנאי, בתוספת רשימת paths לכל דבר שרלוונטי רק בתוך ספרייה אחת.

כאשר ברצונך להשתמש ב-skill

skill הוא ספרייה המכילה קובץ SKILL.md. skills אישיים נמצאים ב-~/.claude/skills/<name>/SKILL.md וחלים על כל פרויקט במכונה שלך. skills של פרויקט נמצאים ב-.claude/skills/<name>/SKILL.md, עוברים יחד עם ה-repository, וניתן לבחון אותם ב-pull request כמו כל קובץ אחר.

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 הוא החלק היחיד בקובץ שנמצא בהקשר לפני הרצת ה-skill, ולכן הוא מבצע שתי משימות. הוא מגדיר מה ה-skill עושה, ומתי יש להשתמש בו. תיאור כמו "עוזר ב-deploys" אינו מספק למודל מידע להתאמה מול בקשה, ולכן ה-skill לא יופעל לעולם ואתה תסיים במסקנה ש-skills אינם עובדים.

שם הספרייה הופך לפקודה, כך שהדוגמה לעיל מעניקה לך את /summarize-changes. ב-skill אישי או של פרויקט, ה-name ב-frontmatter מגדיר רק את תווית התצוגה ברשימות.

ברגע ש-skill מופעל, התוכן המרונדר שלו נכנס לשיחה כהודעה בודדת ונשאר שם למשך שארית הסשן. Claude Code אינו קורא מחדש את הקובץ בתורות מאוחרים יותר. כתוב הוראות קבועות במקום צעדים חד-פעמיים, ושמור על גוף ה-skill תמציתי, כיוון שמנקודה זו כל שורה מהווה עלות מתמשכת בכל בקשה. לאחר דחיסה אוטומטית (auto-compaction), Claude Code מצרף מחדש את ההפעלה האחרונה של כל skill, תוך שמירה על 5,000 ה-tokens הראשונים של כל אחד בתוך תקציב כולל של 25,000 tokens. הפעלת מספר skills גדולים בסשן אחד תגרום להסרת הישנים ביותר, וזו הסיבה ש-skill עשוי להפסיק להשפיע לאחר שיחה ארוכה. הפעל אותו שוב והוא יחזור. כאשר אותו נוהל חל על יותר מ-codebase אחד, שתף skill אחד בין מספר repositories במקום להעתיק את הקובץ.

מתי נדרש שרת MCP

הוספת שרת מתבצעת באמצעות פקודה אחת, והתצורה שלו נקבעת לפי סוג ה-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, הוא מפריד בין האפשרויות של Claude Code לבין שורת הפקודה שמפעילה את השרת שלך. אם תשמיט אותו, --port 8080 המיועד לשרת יפורש כאופציה עבור claude mcp add, שתדחה אותו בשל כך.

claude mcp list
claude mcp get notion

claude mcp add מאשר את הפעולה באמצעות שורת Added ..., המציינת רק שהתצורה נכתבה לדיסק. claude mcp list היא הפקודה שמציגה את המצב האמיתי, שכן היא מדפיסה סטטוס תקינות לצד כל שרת: ✔ Connected, ! Needs authentication, או ✘ Failed to connect. סטטוס של כשל מעיד על כך ש-Claude Code לא הצליח ליצור קשר עם השרת, ולא על תקלה בפקודת הרישום. בתוך סשן, /mcp מספקת תצוגה דומה עבור כל שרת, בצירוף מספר הכלים הזמינים.

כל קריאה לשרת MCP עומדת בפני עצמה ונושאת את כל המידע הדרוש לה, וזו הסיבה לכך ששרת MCP אינו זוכר בקשות קודמות. זוהי החלטת תכנון שגוררת השלכה שעליך לקחת בחשבון: כל מצב (state) שחשוב לשמור חייב להתקיים מאחורי השרת, בתוך מסד נתונים או קובץ, וזהו רכיב שמעתה עליך לתחזק.

שרת MCP הוא תהליך שעליכם להריץ

זהו העלות שספקי השירות משמיטים בהשוואות שלהם. Skill הוא קובץ. שרת MCP הוא תוכנה שרצה במקום כלשהו, וכאשר המקום הזה הוא ה-VPS (שרת וירטואלי פרטי) שלכם, האחריות על זמן הפעילות שלו מוטלת עליכם.

שרת stdio הוא המקרה הזול. Claude Code מפעיל אותו כתהליך בן (child process) עם תחילת הסשן, והוא נסגר עם סיום הסשן. אין מה לנטר ואין מה לעדכן לפי לוח זמנים עצמאי. שרת HTTP מרוחק הוא שירות בעל אורך חיים ארוך, והוא זקוק לכל מה ששירות כזה דורש.

[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 מכיל את הסיבה, ובריצה ראשונה מדובר כמעט תמיד במשתנה סביבה חסר או בפורט שכבר תפוס על ידי תהליך אחר. Restart=on-failure אינו אופציונלי כאן, כיוון ששרת MCP שקרס לא מדווח על כך בעצמו. אתם תגלו זאת רק כשהסוכן יודיע לכם שהוא לא מצליח לקרוא את מערכת ניהול המשימות שלכם.

קשרו את התהליך ל-127.0.0.1 והציבו לפניו reverse proxy עם TLS (אבטחת שכבת תעבורה). שרת MCP שמגיע למסד הנתונים שלכם ומאזין בפורט ציבורי ללא אימות, הוא למעשה מסד נתונים שחשפתם לציבור. הרצת שרת MCP על גבי VPS מכסה את נושאי ה-proxy, התעודות וה-firewall בצורה נכונה.

לאחר מכן, שקללו בכנות את העבודה השוטפת הנדרשת. השירות מקבל עדכוני אבטחה לפי לוח זמנים משלו, ללא קשר לסוכן שמתקשר איתו. אסימון ה-OAuth שלו יפוג, ו-claude mcp list יתחיל להדפיס ! Needs authentication ברגע לא נוח. פרטי ההזדהות שלו נמצאים בקובץ תצורה או ב-header מסוג Authorization, לכן הם דורשים את אותה רמת זהירות כמו כל סוד אחר, נושא מורכב בפני עצמו: שמירה על סודות מחוץ להישג ידו של סוכן AI. עבודה זו אינה קיימת עבור Skill.

שקלו זאת מול החלופות לפני שאתם בונים. אם הנתונים שמאחורי השרת המוצע משתנים בערך פעם ברבעון, Skill שמנחה את הסוכן היכן לחפש ומה משמעות השדות הוא פתרון זול יותר משירות שעליכם לתחזק באוויר.

כיצד למדוד את עלות ההקשר (context) שלכם

הפסיקו לנחש והריצו את /context בתוך סשן. הפקודה מציגה פירוט של תהליך ההפעלה: ה-system prompt, קובצי הזיכרון, הכלים ושרתי ה-MCP, עם משקל הטוקנים של כל אחד מהם.

בדקו שני דברים. תחת Memory files, ודאו שכל קובץ חוקים שאתם מצפים לו אכן מופיע ברשימה. קובץ חסר אינו גלוי לסוכן (agent), ולכן זהו הדבר הראשון שיש לשלול כאשר הנחיות אינן מיושמות. לאחר מכן, בדקו מה העלות של השרתים שלכם. אם שרת שאתם משתמשים בו פעמיים בחודש מהווה את אחת השורות הגדולות ביותר ברשימה, כבו אותו ב-/mcp והפעילו אותו מחדש רק עבור סשנים שזקוקים לו. התצורה נשמרת בכל מקרה.

שרת מרוחק עשוי גם לדווח על סטטוס כמו cached 2h ago · connects on first use · 5 tools. המשמעות היא ש-Claude Code קרא את רשימת הכלים מסשן קודם במקום להתחבר בזמן ההפעלה, והוא יתחבר בפעם הראשונה שבה ייקרא כלי. הכלים זמינים כבר מההודעה הראשונה שלכם, כך שאין מה לתקן. הגדירו את MCP_DISCOVERY_CACHE=0 אם אתם מעדיפים שכל שרת יתחבר בזמן ההפעלה. לתמונה רחבה יותר, ניהול חלון ההקשר של Claude Code מכסה מה שורד דחיסה, ו-מה הטוקנים האלה באמת עולים לכם מתרגם את המספרים לכסף.

מדוע ה-skill שלי לעולם לא מופעל?

הסיבה הנפוצה ביותר היא ה-description. זהו הטקסט היחיד בהקשר שמופיע לפני הרצת ה-skill, לכן אם הוא אינו מתאר את הסיטואציה, שום דבר לא יתאים לו. כתבו את ה-trigger בתוך המשפט: "Use when the user asks what changed, wants a commit message, or asks to review their diff." תיאורים מעורפלים נכשלים בשקט, מה שמקשה על זיהוי הבעיה.

הסיבה השנייה היא שגיאת הקלדה ב-frontmatter, וזו תקלה רועשת. מפתח לא מוכר נדחה על הסף:

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

הסיבה השלישית היא מיקום. ה-skills של הפרויקט נטענים מ-.claude/skills/ בתיקיית העבודה שלכם ובכל תיקיית אב עד לשורש ה-repository. skills שנמצאים בתיקיות מקוננות מתחת למיקום שבו התחלתם לא נטענים בעת ההפעלה. הם מופיעים בפעם הראשונה שה-agent קורא או עורך קובץ בתוך אותה תיקיית משנה, לכן עד אז הם לא יופיעו ב-autocomplete ולא ניתן יהיה להפעיל אותם בשמם.

המקבילה ב-MCP לכשל שקט זה היא רשומה ב-.mcp.json עם url וללא type. Claude Code קורא לכל רשומה ללא type כשרת stdio, לכן הוא מדלג על הרשומה ומדווח:

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

שימוש בשלושתם יחד

המנגנונים הללו אינם מתחרים על אותו תפקיד. הגדרה שעובדת משתמשת בכל אחד מהם במקום שבו הוא יעיל וזול. קובץ ה-rules מכיל מספר מצומצם של שורות שתקפות בכל מצב. ה-skills מכילים את הנהלים ונטענים רק כאשר הם רלוונטיים. שרת MCP אחד, ולעיתים שניים, מחברים בין מערכות שאת תוכנן לא ניתן לחזות מראש. אם אתם עדיין בונים את המודל המנטלי של המרכיב הראשון, מהו למעשה skill של סוכן מסביר את הפורמט בפירוט.

בדיקה אחת מיישבת את רוב הוויכוחים לגבי המקום הנכון לכל רכיב. מחקו אותו, התחילו session חדש, ותנו לסוכן את המשימה. אם הסוכן רק איטי יותר, מקומו ב-skill. אם הסוכן טועה בביטחון, מקומו בקובץ ה-rules. אם הסוכן אינו מסוגל להשיג את המידע כלל, נדרש שרת, וכעת עליכם גם לתכנן כיצד לשמור על זמינותו של אותו שרת.

FAQ

האם עליי לכתוב skill או להקים שרת MCP?

ההחלטה תלויה בשאלה האם המידע משתנה בין הפעלה להפעלה. אם על הסוכן לקרוא מצב חי שמישהו אחר יכול לערוך, כגון מערכת ניהול משימות, מסד נתונים או לוח בקרה, עליך להשתמש בשרת MCP, כיוון שכל מידע שתכתוב יהיה לא מעודכן ברגע שהרשומה תשתנה. אם תוכל לכתוב את התשובה פעם אחת ועדיין להיות צודק בעוד שישה שבועות, כתוב skill. ה-skill הוא קובץ ב-git ללא תהליך שצריך להריץ, ללא פורט שצריך לחשוף וללא לוח זמנים לעדכוני אבטחה, ולכן זו האופציה הזולה יותר בכל מקרה שבו היא אפשרית.

האם שרתי MCP עדיין ממלאים את חלון ההקשר שלי?

הרבה פחות מבעבר. חיפוש כלים מופעל כברירת מחדל ב-Claude Code הנוכחי, כך שרק שמות הכלים ושדה ההנחיות של השרת נטענים בתחילת הסשן, והסכימות המלאות נשלפות כאשר Claude מחפש אותן. טעינה מראש עדיין מתרחשת כאשר חיפוש הכלים כבוי: עם ENABLE_TOOL_SEARCH=false, עם ANTHROPIC_BASE_URL המצביע על proxy שאינו צד ראשון, או בדגם ישן יותר מדור Claude 4.5. הרץ את /context כדי לראות באיזה מצב אתה נמצא, כיוון שהמספרים בפוסטים ישנים יותר להשוואה מניחים טעינה מראש.

האם Claude Code קורא את AGENTS.md?

לא. Claude Code קורא את CLAUDE.md. אם במאגר שלך כבר קיים AGENTS.md עבור סוכנים אחרים, הפנה אחד לשני במקום להחזיק שני עותקים. הרץ את ln -s AGENTS.md CLAUDE.md עבור קישור סימבולי פשוט, או שים את @AGENTS.md בשורה הראשונה של CLAUDE.md והוסף הנחיות ספציפיות ל-Claude מתחתיו. לאחר מכן התחל סשן והרץ את /context כדי לוודא ש-CLAUDE.md מופיע תחת קובצי הזיכרון (Memory files).

מדוע ה-skill שלי הפסיק להשפיע באמצע סשן?

דחיסה אוטומטית (auto-compaction) היא הסיבה הנפוצה לכך. כאשר השיחה מסוכמת, Claude Code מחבר מחדש את ההפעלה האחרונה של כל skill, תוך שמירה על 5,000 הטוקנים הראשונים של כל אחד, בתוך תקציב משולב של 25,000 טוקנים עבור כולם. הוא ממלא את התקציב הזה החל מה-skill שהופעל לאחרונה, כך שאם הפעלת כמה skills גדולים, הישנים שבהם נמחקים לחלוטין. הפעל את ה-skill שוב כדי לשחזר את מלוא התוכן שלו.

איך אוכל למנוע מקובץ חוקים ארוך להיטען בכל סשן?

העבר את החלקים שרלוונטיים רק לעיתים לתוך קובצי .claude/rules/ עם שדה paths ב-frontmatter שלהם, כך שכל אחד מהם ייטען רק כאשר הסוכן נוגע בקובץ תואם. פיצול הקובץ לייבואים של @path לא עוזר, כיוון שקובצי ייבוא מורחבים ונטענים בעת ההפעלה לצד הקובץ שהפנה אליהם. כל דבר שהוא הליך רב-שלבי ולא עובדה קבועה צריך להפוך ל-skill, כיוון שגוף ה-skill אינו עולה דבר עד שהוא מופעל.