🧠 פרק 10

מיומנויות וכישורים מותאמים (Skills)

מיומנויות (Skills) מרחיבות את היכולות של קלוד ב-Claude Code. יוצרים קובץ SKILL.md עם הוראות, וקלוד מוסיף אותו לארגז הכלים שלו. קלוד משתמש במיומנויות כאשר הן רלוונטיות, או שניתן להפעיל אותן ישירות בעזרת הפקודה /skill-name.

מומלץ ליצור מיומנות כאשר הוראות חוזרות, רשימת בדיקה (checklist) או נוהל מרובה שלבים מועתקים שוב ושוב לשיחה, או כאשר חלק בקובץ CLAUDE.md צמח לנוהל עבודה במקום להישאר עובדה קצרה. גוף המיומנות נטען בהקשר השיחה רק בעת השימוש בה. בזכות זאת, חומרי עזר ותיעוד ארוכים כמעט ואינם צורכים טוקנים עד לרגע שבו הם נחוצים בפועל.

פקודות מובנות כמו /help ו-/compact, ומיומנויות מובנות כמו /debug ו-/code-review, מפורטות ברשימת הפקודות בתיעוד הרשמי.

פקודות מותאמות אישית (Custom commands) מוזגו במלואן לתוך מיומנויות. קובץ בנתיב .claude/commands/deploy.md ומיומנות בנתיב .claude/skills/deploy/SKILL.md מייצרים שניהם את הפקודה /deploy ופועלים באותו אופן. קבצים קיימים בתיקיית .claude/commands/ ממשיכים לפעול כרגיל. מיומנויות מוסיפות יכולות נוספות: תיקייה ייעודית לקובצי עזר, הגדרות Frontmatter לשליטה במי מפעיל אותן (המשתמש או קלוד), והיכולת של קלוד לטעון אותן אוטומטית לפי הצורך.

מיומנויות של Claude Code פועלות לפי התקן הפתוח Agent Skills (agentskills.io), הנתמך במגוון כלי AI. Claude Code מרחיב את התקן עם תכונות ייעודיות: שליטה בהרשאות הפעלה, הרצה בסוכני משנה מבודדים והזרקת הקשר דינמי משורת הפקודה. חלק משדות ה-frontmatter שייכים לתקן הפתוח, וחלקם הם הרחבות של Claude Code. בתוך Claude Code, כולל מיומנות של תוסף, אפשר להשתמש בכל שדה. בהעלאות claude.ai, ב-Skills API ובאריזה עם package_skill.py מותרים רק השישה: name, description, license, compatibility, metadata, allowed-tools. שדה שהמפרט אינו מתיר מפיל את האריזה או ההעלאה בשגיאה קשיחה. תכונות גוף שקיימות רק ב-Claude Code, כמו הזרקת הקשר דינמי, אינן פועלות בצ'אט של claude.ai או דרך ה-API. Claude Code עצמו מקבל את כל השישה, ולכן frontmatter שעומד במפרט נטען בו בלי שינוי.

#מיומנויות מובנות (Bundled skills)

Claude Code כולל מיומנויות מובנות מוכנות מראש, כגון /doctor, /code-review, /batch, /debug, /loop ו-/claude-api. מיומנויות מובנות מבוססות הנחיות (prompt-based): הן מספקות לקלוד הוראות מפורטות ומאפשרות לו לנהל את המשימה בעזרת הכלים שלו. רוב הפקודות המובנות הרגילות מריצות לוגיקה קבועה מראש ישירות.

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

מרבית המיומנויות המובנות זמינות בכל סשן. חלקן תלויות בתכונה ספציפית: לדוגמה, /workflow-authoring זמינה רק כאשר תהליכי עבודה דינמיים מופעלים.

לכיבוי כל המיומנויות המובנות, השתמש בהגדרה disableBundledSkills.

בדיקת המערכת /doctor נשארת זמינה להקלדה גם כאשר disableBundledSkills מופעל. כדי להסתיר אותה, הגדר את משתנה הסביבה DISABLE_DOCTOR_COMMAND או הוסף ערך של "doctor": "off" תחת skillOverrides.

המיומנויות המובנות מופיעות לצד פקודות מובנות ברשימת הפקודות בתיעוד הרשמי, ומסומנות במילה Skill בעמודת הייעוד.

#בדיקת ההתקנה עם /doctor (Check your setup with /doctor)

מריצים /doctor בשורת Claude Code לבדיקת התקנה שמאתרת בעיות ויכולה לתקן אותן. קלוד מדווח קודם על הממצאים ומבקש אישור לפני שהוא משנה משהו. הבדיקה מכסה את התחומים האלה:

• בריאות ההתקנה: התקנות כפולות או שאריות, בעיות ב-PATH, קובצי הגדרות שלא ניתן לפרש, והאם קיימת גרסה חדשה יותר בערוץ ההפצה שלך.
• הרחבות: מיומנויות, שרתי MCP ותוספים שאינם בשימוש, מול עלות ההקשר שלהם, ו-hooks איטיים.
• קובצי CLAUDE.md: קבצים מקומיים שכפולים של קבצים שנשמרו ב-git, תוכן CLAUDE.md שנשמר ב-git ושקלוד יכול להסיק מהקוד, וההנחיה שנטענת תמיד ונשארת. קלוד מציע להעביר את מה שנשאר למיומנויות ולקובצי CLAUDE.md מקוננים שנטענים לפי הצורך.
• הרשאות: הצעה להפוך את auto mode למצב ההרשאות ברירת המחדל, ולאשר מראש פקודות לקריאה בלבד שאתה דוחה לעיתים קרובות.
• שימוש: בתוכנית Pro, Max, Ultra, Team או Enterprise, השינויים ש-/usage ממליץ עליהם כדי להוריד את השימוש בתוכנית, במדידה על 7 הימים האחרונים. קלוד מציע את השינויים שהוא יכול לבצע בעצמו, ומדווח על השאר כהמלצה, למשל פקודה שאתה מריץ. בדיקת השימוש דורשת Claude Code בגרסה v2.1.305 ואילך, ו-/doctor משמיט אותה כל עוד Remote Control מחובר.

לאבחון התקנה לקריאה בלבד בלי לפתוח סשן, הרץ claude doctor בטרמינל.

כדי לבדוק את ההוראות עצמן, הרץ /doctor prompt-audit בשורת Claude Code. קלוד בודק את קובצי CLAUDE.md, המיומנויות ושאר ההגדרות לאיתור הוראות מיושנות או סותרות, במקום להריץ את בדיקת ההתקנה. תת-הפקודה prompt-audit דורשת Claude Code בגרסה v2.1.283 ואילך.

#הרצה ואימות של היישום שלך (Run and verify your app)

שלוש מיומנויות מובנות פועלות יחד כדי להפעיל את היישום ולאמת שינויים מול יישום רץ:

המיומנויות /run ו-/verify פועלות בלי צורך בהגדרה מוקדמת. הן מסיקות את אופן ההפעלה מסוג הפרויקט (CLI, שרת, TUI, יישום מונחה דפדפן) ומתוך מה שקיים בקובצי README, package.json או Makefile. הסקה זו הופכת לבלתי אמינה בפרויקטים שדורשים דבר מעבר להפעלה סטנדרטית: מסד נתונים, קובץ משתני סביבה, סשן גרפי או תהליך בנייה מרובה שלבים.

המיומנות /run-skill-generator מקליטה את המתכון במקום זאת: היא מפעילה את היישום מסביבה נקייה, מתעדת את מה שהצליח (פקודות ההתקנה, משתני הסביבה, תסריט ההפעלה), ושומרת אותם כמיומנות פרויקט ייעודית בנתיב .claude/skills/run-<name>/. לאחר מכן, /run, /verify וכל סוכן אחר במאגר עוקבים אחר המתכון המוקלט במקום לגלות אותו מחדש. הרץ את /run-skill-generator פעם אחת בכל פרויקט, ושוב אם תהליך הבנייה או ההפעלה משתנה.

המיומנות /verify יכולה להקליט מתכון בעצמה: כאשר היא נדרשת לבנות ולהפעיל את היישום בלי מתכון קיים, היא כותבת את הפעולות שהצליחו לקובץ .claude/skills/verify/SKILL.md בשורש המאגר, או בתיקיית החבילה ששונתה במונו-ריפו, כך שריצות עתידיות וסוכנים אחרים יעקבו אחר אותם צעדים. בשורש המאגר, המיומנות המוקלטת מחליפה את /verify המובנית.

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

#הרצת הבדיקות לפני כל commit (Run your checks before each commit)

כאשר סשן מתחיל ומיומנות בשם verify או simplify כבר טעונה, הוראות ה-commit של Claude Code אומרות לקלוד להריץ אותה ממש לפני כל commit, למעט שינויים בתיעוד או בבדיקות. זה דורש Claude Code בגרסה v2.1.286 ואילך. קלוד מקבל את ההוראה כאשר התנאים האלה מתקיימים בתחילת הסשן:

• מיקום: המיומנות נטענת ממיקום enterprise, personal, project או תיקייה נוספת, או מקובץ ב-.claude/commands/ בשם הזה. המתכון ש-/verify מקליט בשורש המאגר הוא מיומנות פרויקט, ולכן הוא נספר. /verify ו-/simplify המובנות, מיומנויות של תוסף, ומיומנויות מחשבון claude.ai אינן נספרות.
• הפעלה: קלוד יכול להפעיל את המיומנות. אם עצרת את קלוד מלהפעיל אותה, למשל עם disable-model-invocation: true, קלוד אינו מקבל את ההוראה.
• הוראות Git: לא כיבית את includeGitInstructions. כיבוי מסיר את ההוראה הזו יחד עם שאר הוראות ה-commit וה-PR המובנות.

#עבודה על פרויקטי Claude API (Work on Claude API projects)

המיומנות המובנית /claude-api טוענת חומר עיון של Claude API ושל Managed Agents בשפת הפרויקט. קלוד גם מפעיל אותה אוטומטית כאשר הקוד מייבא את anthropic או את @anthropic-ai/sdk.

כדי להתחיל אחד מתהליכי העבודה של המיומנות, הקלד תת-פקודה אחרי שם המיומנות בשורת Claude Code, לדוגמה /claude-api migrate. הטבלה מפרטת מה כל תת-פקודה עושה ומהי גרסת Claude Code המוקדמת ביותר שכוללת אותה. migrate ו-managed-agents-onboard קודמות ל-v2.1.221, הגרסה הוותיקה ביותר שהטבלה עוקבת אחריה.

#תחילת העבודה (Getting started)

#יצירת המיומנות הראשונה שלך (Create your first skill)

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

1. צור את תיקיית המיומנות: צור תיקייה ייעודית תחת ספריית המיומנויות האישית שלך. מיומנויות אישיות זמינות בכל הפרויקטים שלך:

   העתק

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

2. כתוב את קובץ SKILL.md: כל מיומנות זקוקה לקובץ SKILL.md הכולל שני חלקים: הגדרות YAML Frontmatter בין סימני --- המגדירות לקלוד מתי להשתמש במיומנות, ותוכן Markdown עם ההוראות שקלוד מבצע כאשר המיומנות רצה. שם התיקייה, או השדה name ב-frontmatter אם הגדרת אותו, הופך לפקודה שאתה מקליד, והשדה description עוזר לקלוד להחליט מתי לטעון אותה אוטומטית. אם description חסר, Claude Code משתמש בשורה הראשונה שאינה ריקה בתוכן ה-Markdown.

   שמור את התוכן הבא בנתיב ~/.claude/skills/summarize-changes/SKILL.md:

   העתק

   ---
   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.
   ---
   
   ## Current changes
   
   !`git diff HEAD`
   
   ## Instructions
   
   Summarize the changes above in two or three bullet points, then list any risks you notice such as missing error handling, hardcoded values, or tests that need updating. If the diff is empty, say there are no uncommitted changes.

   השורה !`git diff HEAD` משתמשת בהזרקת הקשר דינמי: Claude Code מריץ את הפקודה ומחליף את השורה בפלט שלה לפני שקלוד רואה את תוכן המיומנות, כך שההוראות מגיעות עם השינויים הנוכחיים מוטמעים ישירות בתוכן.

3. בדוק את המיומנות: פתח פרויקט git כלשהו, בצע עריכה קלה בקובץ כלשהו, והפעל את Claude Code באמצעות הפקודה claude. ניתן לבדוק את המיומנות בשתי דרכים:

   אפשר לקלוד להפעיל אותה אוטומטית על ידי שאילת שאלה שמתאימה לתיאור:

   העתק

   What did I change?

   או הפעל אותה ישירות בשם המיומנות:

   העתק

   /summarize-changes

   בשני המקרים קלוד אמור להגיב עם סיכום קצר של השינוי שביצעת ורשימת סיכונים.

#קבצי עזר (Add supporting files)

תיקיית מיומנות יכולה להכיל כמה קבצים. SKILL.md נשאר ממוקד, וקלוד טוען חומר עיון, מפרט API או אוסף דוגמאות רק כשהם נחוצים. הפנה אליהם מתוך SKILL.md כדי שקלוד יידע מה יש בכל קובץ ומתי לטעון אותו. סקריפט בתיקייה מורץ, והוא אינו נטען כטקסט להקשר.

my-skill/
├── SKILL.md (required - overview and navigation)
├── reference.md (detailed API docs - loaded when needed)
├── examples.md (usage examples - loaded when needed)
└── scripts/
    └── helper.py (utility script - executed, not loaded)

## Additional resources

- For complete API details, see [reference.md](reference.md)
- For usage examples, see [examples.md](examples.md)

שמור את SKILL.md מתחת ל-500 שורות, והעבר פירוט לקבצים נפרדים. אחרי שהמיומנות נטענת, התוכן נשאר בהקשר לאורך התורות, ולכן כל שורה היא עלות טוקנים חוזרת. כתוב מה לעשות, בלי לספר איך או למה, באותו מבחן קיצור שחל על תוכן CLAUDE.md.

#סוגי תוכן (Types of skill content)

תוכן עיון מוסיף ידע שקלוד מיישם על העבודה הנוכחית: מוסכמות, תבניות, מדריך סגנון, ידע תחום. הוא רץ בתוך השיחה, כדי שקלוד ישתמש בו יחד עם הקשר השיחה.

---
name: api-conventions
description: API design patterns for this codebase
---

When writing API endpoints:
- Use RESTful naming conventions
- Return consistent error formats
- Include request validation

תוכן משימה נותן לקלוד צעדים לפעולה מסוימת, כמו פריסה, commit או יצירת קוד. לרוב אלה פעולות שכדאי להפעיל ישירות עם /skill-name. הוסף disable-model-invocation: true כדי שקלוד לא יפעיל אותן לבד. context: fork מריץ את המיומנות בהקשר של סוכן משנה נפרד. הפירוט בסעיף הרצה בסוכן משנה.

---
name: deploy
description: Deploy the application to production
context: fork
disable-model-invocation: true
---

Deploy the application:
1. Run the test suite
2. Build the application
3. Push to the deployment target

כל השדות אופציונליים. רק description מומלץ, כדי שקלוד יידע מתי להשתמש במיומנות. שמות השדות הם מילים קטנות מופרדות במקפים, חוץ מ-when_to_use, ושם שדה חייב להתאים לטבלה בדיוק: Claude Code מתעלם משדה שאינו מזהה, בלי לדווח על שגיאה. שדות בוליאניים מקבלים גם yes, no, on, off, 1 ו-0 בכל רישיות, בנוסף ל-true ו-false. קובץ פקודה ב-.claude/commands/ מקבל את אותם שדות, חוץ מ-name ו-paths.

שדה argument-hint מציג רמז בהשלמה אוטומטית, למשל [issue-number] או [filename] [format]. שדה arguments מגדיר ארגומנטים עם שם להחלפת $name בתוכן. הוא מקבל מחרוזת מופרדת ברווחים או רשימת YAML, והשמות ממופים למיקומים לפי הסדר. שדה model מחליף את המודל עד סוף התור הנוכחי ואינו נשמר להגדרות. בהודעה הבאה חוזר מודל הסשן. הערכים זהים לאלה של /model, ו-inherit משאיר את המודל הפעיל. ערך שהארגון הוציא מרשימת availableModels אינו בשימוש, והסשן נשאר על המודל הנוכחי. כך גם ב-auto mode, וב-plan mode בזמן שהמסווג בודק פקודות, למודל ש-auto mode אינו תומך בו. עם context: fork הערך קובע את מודל סוכן המשנה, וערך שהוצא מהרשימה עוקב אחרי אותם כללים כמו דריסת מודל של סוכן משנה. שדה effort חל עד סוף התור הנוכחי. הוא דורס את רמת ה-effort של הסשן, אבל לא את משתנה הסביבה CLAUDE_CODE_EFFORT_LEVEL. עם context: fork הערך קובע את רמת ה-effort של סוכן המשנה המפוצל. אם משמיטים אותו, הרמה נקבעת לפי סדר הרזולוציה הרגיל. כשהפיצול רץ על מודל אחר, פירוט רמת ה-effort נמצא בתיעוד הרשמי בסעיף Effort level of subagents and teammates (נכון ל-5 בנובמבר 2026). הערכים: low, medium, high, xhigh, max, לפי מה שהמודל תומך בו.

שדה paths מגביל מתי המיומנות מופעלת אוטומטית. הוא מקבל מחרוזת מופרדת בפסיקים או רשימת YAML של תבניות glob, יחסית לתיקיית העבודה הנוכחית של Claude Code, באותו פורמט כמו כללים לפי נתיב. קבצים מחוץ לתיקייה הזו אינם תואמים. שדה hooks רושם hooks מרגע הפעלת המיומנות ועד סוף הסשן. שדה shell בוחר מעטפת לפקודות !`command` ולבלוקי ```!: bash (ברירת המחדל) או powershell. הפירוט בסעיף כיצד פקודות מוזרקות רצות.

Claude Code מקבל גם את license, את compatibility ואת metadata, ואינו פועל לפיהם. license הוא הרישיון של המיומנות. compatibility מתאר דרישות סביבה, כמחרוזת של עד 500 תווים. metadata היא מפת YAML חופשית לכלים שלך, למשל שדות הרשאה או קטלוג. ערך שאינו מפה נזרק. אל תשתמש בשם של שדה frontmatter, כמו paths, כמפתח בתוך metadata.

משתני ${CLAUDE_*} ודוגמאות ההגדרה המלאות נמצאים בפרק ההעמקה. בקצרה, אלה המשתנים בתוכן המיומנות:

Claude Code מחליף את ${CLAUDE_SKILL_DIR} ואת ${CLAUDE_PROJECT_DIR} בשני מקומות: בתוכן ה-Markdown, ובכללי Bash ב-allowed-tools. במיומנות תוסף הוא מחליף באותם שני מקומות גם את ${CLAUDE_PLUGIN_ROOT} ואת ${CLAUDE_PLUGIN_DATA}.

Claude Code קורא frontmatter רק כאשר --- הפותח הוא השורה הראשונה בקובץ. אחרת הוא מתייחס לכל הקובץ, כולל סימני --- , כתוכן המיומנות. אם ה-YAML בין הסימנים אינו מתפרש, המיומנות עדיין נטענת בלי שדות.

#מי מפעיל את המיומנות (Control who invokes a skill)

כברירת מחדל גם אתה וגם קלוד יכולים להפעיל כל מיומנות: אתה עם /skill-name, וקלוד אוטומטית כשהיא רלוונטית. שני שדות מגבילים את זה:

• disable-model-invocation: true: קלוד אינו מפעיל את המיומנות בעצמו. מתאים לנוהל עם תופעת לוואי או לתזמון שאתה רוצה לשלוט בו, כמו /commit, /deploy או /send-slack-message. השדה גם מונע טעינה מראש לסוכני משנה, ומונע הרצה כשמשימה מתוזמנת ברמת הסשן נורה כשהמיומנות היא ההנחיה שלה. ברירת המחדל היא false. אם קלוד מנסה בכל זאת, Claude Code חוסם את הקריאה ומורה לו לא לשחזר את צעדי המיומנות בדרך אחרת, ולכן צפוי שהוא יציע להריץ את /deploy בעצמך.
• user-invocable: false: רק קלוד מפעיל. Claude Code מסתיר את המיומנות מתפריט / ואינו מריץ אותה כשמקלידים /name. מתאים לידע רקע, למשל איך מערכת ישנה עובדת, כשהפקודה עצמה אינה פעולה בעלת משמעות למשתמש. ברירת המחדל היא true.

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

כדי להריץ מיומנות ישירות, שים את שמה בתחילת ההודעה. אחרי טקסט רגיל, השם נותן לקלוד הרשאה להריץ באותה הודעה, אבל אינו מריץ ישירות:

כדי לכתוב על המיומנות בלי להתיר הרצה, השמט את הלוכסן.

עם user-invocable: false אי אפשר להפעיל בעצמך, אבל קלוד עדיין יכול. כדי שגם הוא לא יפעיל דרך כלי Skill, הגדר disable-model-invocation: true.

#העברת ארגומנטים (Pass arguments to skills)

גם אתה וגם קלוד יכולים להעביר ארגומנטים בהפעלה. הם זמינים דרך $ARGUMENTS.

---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---

Fix GitHub issue $ARGUMENTS following our coding standards.

בהרצת /fix-issue 123 קלוד מקבל את המספר בתוך ההוראה.

אם מפעילים מיומנות עם ארגומנטים ואף מציין מיקום בתוכן אינו מקבל אותם, Claude Code מוסיף בסוף התוכן ARGUMENTS: <your input>. מציין מיקום הוא $ARGUMENTS, צורה ממופתחת כמו $1, או ארגומנט עם שם. מציין ממופתח בלי ארגומנט במיקום שלו נשאר טקסט מילולי ואינו נחשב כמקבל ארגומנט. מציין עם שם נחשב גם כשאין ארגומנט במיקום, כי הוא מתרחב למחרוזת ריקה.

לפי מיקום משתמשים ב-$ARGUMENTS[N] או בקיצור $N. האינדקס מתחיל ב-0: $0 הוא הארגומנט הראשון. שדה arguments ב-frontmatter מגדיר שמות לפי הסדר, כמחרוזת מופרדת ברווחים או כרשימת YAML. עם arguments: [issue, branch], $issue הוא הארגומנט הראשון ו-$branch הוא השני.

ארגומנטים ממופתחים משתמשים בציטוט בסגנון shell. /my-skill "hello world" second מרחיב את $0 ל-hello world ואת $1 ל-second. $ARGUMENTS תמיד מתרחב למחרוזת כפי שהוקלדה.

ערך ארגומנט שמכיל בעצמו טקסט כמו $1 או $ARGUMENTS מוכנס כטקסט מילולי ואינו מורחב. לדוגמה, אם הגוף מכיל Summarize $0 ומריצים /summarize "$ARGUMENTS from yesterday", קלוד מקבל Summarize $ARGUMENTS from yesterday. Claude Code עדיין מחליף משתני ${CLAUDE_*} אחרי שהוא מכניס את הארגומנטים.

כדי לכתוב $ מילולי לפני ספרה, לפני ARGUMENTS, או לפני שם ארגומנט מוצהר, כמו $1.00 בתוך משפט, בורחים בלוכסן הפוך: \$1.00. לוכסן לפני כל $ אחר נשאר כפי שהוא. רק לוכסן בודד מיד לפני האסימון בורח ממנו. לוכסן כפול כמו \\$1 משאיר את שני הלוכסנים, ו-$1 עדיין מתרחב לערך הארגומנט. הבריחה חלה רק על מצייני הארגומנטים האלה. לוכסן אינו מונע החלפה של משתנה ${CLAUDE_*} במקום שבו המשתנה חל.

#שרשור כמה מיומנויות בהודעה אחת (Stack several skills in one message)

בשורת Claude Code בטרמינל אפשר לשרשר כמה מיומנויות בתחילת הודעה אחת. דרך Agent SDK או claude -p, Claude Code טוען רק את המיומנות הראשונה, ושאר השורה הם הארגומנטים שלה. בשורת הטרמינל, /write-tests /fix-issue 123 טוען את שתי המיומנויות ומעביר את הטקסט 123 כ-$ARGUMENTS לכל אחת מהן.

Claude Code מרחיב את המיומנות הראשונה ועד חמש נוספות שאחריה. ההרחבה נעצרת באסימון הראשון שאינו מיומנות שניתנת להפעלה על ידי המשתמש בתוך השורה. אם משרשרים מיומנות שרצה כסוכן משנה מפוצל, כמו /code-review, או מיומנות שהארגומנטים שלה עשויים להתחיל בפקודה אחרת, כמו /loop, ההרחבה נעצרת שם. האסימון הזה וכל מה שאחריו הופכים לטקסט הארגומנטים של כל מיומנות שהורחבה.

#מחזור החיים של תוכן המיומנות (Skill content lifecycle)

כשאתה או קלוד מפעילים מיומנות, תוכן SKILL.md המעובד נכנס לשיחה כהודעה אחת ונשאר בה גם בתורות הבאים. ההתמדה חלה על ההוראות, לא על ההרשאות: הרשאת allowed-tools מתפנה כששולחים את ההודעה הבאה. Claude Code אינו קורא מחדש את קובץ המיומנות בתורות מאוחרים יותר, ולכן הנחיה שצריכה לחול לאורך כל המשימה נכתבת כהוראה מתמשכת ולא כצעד חד-פעמי.

כשקלוד מפעיל שוב מיומנות שהתוכן המעובד שלה זהה לעותק שכבר בהקשר, Claude Code מוסיף הערה קצרה שהמיומנות כבר טעונה, ולא עותק שני. כשהתוכן המעובד שונה, כי הארגומנטים השתנו או כי פקודת הקשר דינמי החזירה פלט חדש, Claude Code מצרף שוב את התוכן המלא.

כיווץ אוטומטי מעביר מיומנויות שהופעלו קדימה בתוך תקציב טוקנים. כשהשיחה מסוכמת כדי לפנות הקשר, Claude Code מצמיד מחדש את ההפעלה האחרונה של כל מיומנות אחרי הסיכום, ושומר את 5,000 הטוקנים הראשונים של כל אחת. המיומנויות שמצורפות מחדש חולקות תקציב משותף של 25,000 טוקנים. Claude Code ממלא את התקציב מהמיומנות שהופעלה לאחרונה, ולכן מיומנויות ישנות יותר יכולות ליפול לגמרי אחרי כיווץ אם הופעלו רבות באותו סשן.

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

#בחירת מיקום הטעינה של מיומנויות (Choose where skills load)

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

תיקיות מיומנות פועלות גם לפי הכללים הבאים:

• תיקיות עם קישור סימבולי (Symlinked folders): ערך <skill-name> במיקומי enterprise, personal או project יכול להיות קישור סימבולי (symlink) לתיקייה אחרת בדיסק. Claude Code קורא את SKILL.md מנתיב היעד וטוען את המיומנות פעם אחת גם אם כמה מיקומים מצביעים על אותו יעד. מיומנויות של תוספים מטפלות בקישורים סימבוליים באופן שונה.
• שם שמור synced: אל תקרא לתיקיית מיומנות בשם synced, בכל שילוב אותיות גדולות או קטנות. Claude Code משתמש בנתיב ~/.claude/skills/synced/ למיומנויות שהורדו מחשבון claude.ai, ומדלג על מיומנות מקומית שיצרת בשם זה במיקומי enterprise, personal ו-project.
• שם שמור anthropic-skills: מחוץ לתוסף, תיקיית מיומנות או קובץ פקודה ששמו anthropic-skills, או שמתחיל ב-anthropic-skills:, לא נטען. הפירוט בסעיף שמות שמורים למיומנויות מסונכרנות.
• תווים בשם: מחוץ לתוסף, תיקיית מיומנות אינה נטענת כאשר בשמה יש תו כמו רווח ברוחב אפס או <. הפירוט בסעיף תווים ששם מיומנות לא יכול להכיל.
• קובצי פקודה: קובץ Markdown בתיקיית .claude/commands/ הוא הפורמט הישן ועדיין פועל. הוא תומך באותם שדות frontmatter למעט name ו-paths. שם הפקודה שמוקלדת נקבע לפי הסעיף כיצד מיומנות מקבלת את שם הפקודה. עדיף להשתמש במיומנות עבור עבודה חדשה, שכן מיומנויות תומכות גם בקובצי עזר.
• תיקיית מיומנות כתוסף: הוספת קובץ .claude-plugin/plugin.json לתיקיית מיומנות אישית או של פרויקט מאפשרת ל-Claude Code לטעון אותה כתוסף בשם <name>@skills-dir, כך שניתן לצרף סוכנים, hooks ושרתי MCP. בתיקיית .claude/skills/ של פרויקט נדרש לאשר קודם את חלון ה-workspace trust. בשני המיקומים נדרש גם שמנהל המערכת לא חסם תוספים מתיקיית מיומנויות (skills-directory plugins).

#תווים ששם מיומנות לא יכול להכיל (Characters a skill name can't hold)

אם מיומנות או פקודה מותאמת חסרה בתפריט /, או שהתפריט אינו מציג את השדה name מה-frontmatter, בדוק את השם. Claude Code דוחה שם פקודה או שדה name שמכיל תווים כאלה:

• רווח ברוחב אפס או תו בקרה
• תו לשימוש פרטי או תו שלא הוקצה, למשל גליף מגופן אייקונים
• תו שמשנה את כיוון הטקסט סביבו
• רווח שאינו רווח רגיל אחד בין מילים, למשל רווח קשיח, שני רווחים ברצף, או רווח בתחילת השם או בסופו
• < או >

פקודה מותאמת או מיומנות אינה נטענת כאשר Claude Code דוחה את שם התיקייה או הקובץ שלה. שנה את שם התיקייה או הקובץ כדי להסיר את התווים. מיומנות עדיין נטענת כאשר התווים האלה נמצאים רק בשם תיקייה של מיומנות תוסף או בשדה name שלה:

• תיקייה בתוך skills/ של תוסף, או נתיב skills במניפסט: אין צורך לשנות את שם התיקייה. התווים האלה הופכים למקפים בשם הפקודה, ולכן מקלידים את הפקודה עם המקפים.
• שדה name ב-frontmatter: תפריט / אינו מציג את ערך name, והקלדתו אינה מפעילה את המיומנות. ערוך את שורת name: והסר את התווים.

כדי לגלות איזה שם נדחה, הפעל claude --debug מהמעטפת וחפש ביומן הדיבוג את [names]. בסשן אינטראקטיבי, הודעת עלייה גם מציינת ששמות נדחו. אחרי שינוי שם או עריכת name:, הפעל מחדש את הסשן, אלא אם הקובץ נמצא בתיקייה ש-Claude Code מאזין לשינויים בה.

#טעינת מיומנויות במונו-ריפו ובתת-תיקיות (Load skills in monorepos and subdirectories)

Claude Code טוען מיומנויות פרויקט מתיקיית .claude/skills/ בתיקייה שבה הפעלת אותו, ומכל תיקיית אב עד לשורש המאגר, כך שהפעלה בתוך packages/frontend/ עדיין קולטת מיומנויות שהוגדרו בשורש הפרויקט. בעת העברת הסשן באמצעות /cd בגרסה v2.1.246 ואילך, Claude Code מוסיף את מיומנויות הפרויקט של התיקייה החדשה.

בסשן הרץ בתוך git worktree מקושר שנוצר עם --worktree או git worktree add, Claude Code מחפש בתיקיות אב רק עד לשורש ה-worktree. בגרסה v2.1.277 ואילך, כאשר ב-checkout של ה-worktree אין תיקיית .claude/skills בשורש שלו, Claude Code טוען במקומה את מיומנויות הפרויקט של ה-checkout הראשי. מה ה-worktree חולק עם ה-checkout הראשי מפורט בתיעוד הרשמי בסעיף What worktrees share with the main checkout (נכון ל-24 באוקטובר 2026).

מיומנויות בתיקיית .claude/skills/ הנמצאת מתחת לתיקייה שבה התחלת אינן נטענות בעליית המערכת. הן נטענות בפעם הראשונה שקלוד קורא או עורך קובץ באותה תת-תיקייה, ונשארות זמינות לשארית הסשן. עד אז הן אינן מופיעות בתפריט / ולא ניתן להפעילן בשמן. כדי לטעון אותן מוקדם יותר, הרץ /add-dir עם נתיב תת-התיקייה, פעולה הדורשת Claude Code בגרסה v2.1.257 ואילך. סשן worktree שמתחילים מאפליקציית הדסקטופ מתואר באותו סעיף בתיעוד הרשמי, What worktrees share with the main checkout (נכון ל-24 באוקטובר 2026).

כאשר מיומנות מקוננת חולקת שם עם מיומנות אחרת, שתיהן נשארות זמינות. עם מיומנות deploy בשורש המאגר ומיומנות נוספת ב-apps/web/.claude/skills/:

• הפקודה /deploy מריצה את מיומנות השורש. Claude Code מציג לקלוד גם את הגרסאות המזוהות לפי תיקייה בצירוף הנחיה להפעיל את זו שהתיקייה שלה מכילה את הקבצים שהוא עובד עליהם, כך שהמיומנות המקוננת עדיין תחול על עבודה ב-apps/web/.
• הפקודה /apps/web:deploy מריצה את המיומנות המקוננת בפני עצמה. התיאור שלה מציין את התיקייה שעליה היא חלה.

#טעינת מיומנויות מתיקייה חיצונית לפרויקט (Load skills from a directory outside the project)

כאשר מוסיפים תיקייה באמצעות --add-dir או /add-dir, Claude Code טוען את המיומנויות מ-.claude/skills/ של אותה תיקייה, יחד עם .claude/commands/ ו-.claude/agents/ שלה. תיקיות שה-Agent SDK מוסיף באמצעות additionalDirectories ב-TypeScript או add_dirs ב-Python נטענות באותו אופן, כיוון שה-SDK מעביר אותן כ---add-dir. ההגדרה permissions.additionalDirectories בקובץ settings.json מעניקה גישה לקבצים בלבד ואינה טוענת אף אחד מאלה.

Claude Code מאזין לשינויים בתיקיית .claude/skills/ בתיקייה שמועברת עם --add-dir בעת ההפעלה, כמתואר בסעיף עריכת מיומנות במהלך סשן. הוא אינו מאזין לקובצי .claude/commands/ או .claude/agents/ של התיקייה שנוספה, ולכן יש להפעיל מחדש את הסשן לאחר שינוי קובץ שם.

טעינות אלו תלויות במקור ההגדרות project, המופעל כברירת מחדל. מדיניות strictPluginOnlyCustomization, מצב bare mode והדגל --safe-mode מגבילים אותן עוד יותר. הטבלה המלאה של מה תיקייה שנוספה טוענת, כולל CLAUDE.md והגדרות תוספים, מופיעה בתיעוד הרשמי בעמוד Additional directories grant file access, not configuration.

#הרצת מיומנות באותו שם מתיקייה שנוספה (Run a same-named skill from an added directory)

מיומנות בתיקייה שנוספה מקבלת קידומת כאשר שם התיקייה שלה מתנגש עם מיומנות enterprise, personal או project, או עם מיומנות בתיקייה שנוספה קודם. כדי להריץ אותה, הקלד /<prefix>:<skill-name> בשורת Claude Code. תפריט / מציג את המיומנות בשם עם הקידומת. מאין מגיעה הקידומת מפורט בסעיף כיצד מיומנות מקבלת את שם הפקודה. השם הזה דורש Claude Code בגרסה v2.1.309 ואילך.

לדוגמה, עם --add-dir ../cli ומיומנות verify גם בפרויקט וגם ב-../cli:

• /verify מריץ את מיומנות הפרויקט
• /cli:verify מריץ את המיומנות מ-../cli

#פתרון מיומנויות החולקות את אותו השם (Resolve skills that share a name)

כאשר שתי מיומנויות חולקות את אותו שם תיקייה או שם קובץ, המקור שממנו הגיעה כל אחת קובע איזו מיומנות תרוץ עם /name. אם השם נקבע בשדה name ב-frontmatter, הכללים מופיעים בסעיף כיצד מיומנות מקבלת את שם הפקודה. הטבלה מכסה את מיקומי enterprise, personal, project, nested, plugin ו-claude.ai, מיומנויות מובנות, פקודות מובנות, קובצי פקודה, ותיקיות שנוספו מחוץ לפרויקט:

#כיצד מיומנות מקבלת את שם הפקודה (How a skill gets its command name)

שם הפקודה שמקלידים נקבע לפי מיקום הקובץ, ובתיקיית מיומנות או במיומנות תוסף גם לפי שדה name. בתיקיית מיומנות אישית או של פרויקט, name קובע את הפקודה שתפריט / מציג ושמקלידים, אלא אם פקודה אחרת כבר משתמשת בשם. שם התיקייה גם מפעיל את המיומנות. במיומנות תוסף, name קובע את המקטע האחרון של הפקודה, וקידומת התוסף נשארת.

במיומנות תוסף, name מחליף את שם התיקייה במקטע האחרון של הפקודה, וקידומת התוסף נשארת. גם /fancy מפעיל את המיומנות, אלא אם פקודה אחרת כבר משתמשת בשם. אם name שכתבת כבר מתחיל בקידומת של התוסף עצמו, Claude Code אינו מוסיף את הקידומת שוב ב-v2.1.246 ואילך. לדוגמה, name: my-plugin:fancy עדיין הופך ל-/my-plugin:fancy. מ-v2.1.216 עד v2.1.245 Claude Code הכפיל את הקידומת כאשר name כבר נשא אותה.

בסשנים לא אינטראקטיביים השמות help ו-feedback אינם שמורים לפקודות המובנות שקיימות רק בטרמינל, ולכן מיומנות תוסף באחד השמות האלה שומרת שם על הפקודה הקצרה. כל שם אחר של פקודה מובנית שקיימת רק בטרמינל, כמו /login, נשאר שמור גם כשהפקודה אינה יכולה לרוץ בסשנים האלה.

ב-SKILL.md בשורש תוסף אין תיקיית מיומנות שממנה נלקח השם, ולכן name מספק את כל המקטע האחרון. בלי שדה name, Claude Code נופל חזרה לשם תיקיית התוסף.

#שימוש במיומנויות בסשנים של Cowork וענן (Use skills in Cowork and cloud sessions)

סשנים של Cowork וסשנים בענן, כולל משימות ענן מתוזמנות (cloud scheduled tasks), אינם קוראים את ~/.claude/skills/ במכונה שלך. סשנים של Cowork, אינטראקטיביים ומתוזמנים כאחד, טוענים את המיומנויות שהופעלו עבור חשבון claude.ai שלך, המסונכרנות בתחילת הסשן. ניתן לנהל אותן דרך Customize בסרגל הצד של אפליקציית הדסקטופ או מתוך הגדרות המיומנויות ב-claude.ai.

אם מיומנות קיימת אך ורק ב-~/.claude/skills/ במכונה שלך, Claude Code ידווח שהמיומנות לא נמצאה כאשר משימת ענן מתוזמנת תפעיל אותה, כיוון שכל הרצה מתחילה כסשן ענן נקי וחדש. כדי להפוך מיומנות אישית לזמינה בסשנים אלה:

• עבור סשנים של Cowork, סשנים בענן, ושרשורי ענן של פרויקט (cloud threads), הפעל את המיומנות עבור חשבון claude.ai שלך. בשרשור ענן של פרויקט, מיומנויות שנשמרו ב-git תחת .claude/skills/ של המאגר אינן זמינות. חלק מהסשנים בסביבה self-hosted אינם טוענים את מיומנויות החשבון.
• עבור סשנים בענן שאינם שרשורי פרויקט, אפשר לחלופין לשמור את המיומנות ב-git תחת .claude/skills/ של המאגר. תוספים המוגדרים בקובץ .claude/settings.json של המאגר ותוספים שהופעלו רק בהגדרות המשתמש שלך אינם נטענים בסשנים בענן.

הפעלה לחשבון claude.ai מעלה את המיומנות ל-claude.ai, וחלים עליה כללי ההעלאה. בהעלאות claude.ai, ב-Skills API ובאריזה עם package_skill.py מתוך anthropics/skills מותרים רק השישה: name, description, license, compatibility, metadata, allowed-tools. שדה שהמפרט אינו מתיר מפיל את האריזה או ההעלאה בשגיאה קשיחה, למשל Unexpected key(s) in SKILL.md frontmatter: argument-hint. Allowed properties are: allowed-tools, compatibility, description, license, metadata, name. תכונות גוף שקיימות רק ב-Claude Code, כמו הזרקת הקשר דינמי, אינן פועלות בצ'אט של claude.ai או דרך ה-API. Claude Code עצמו מקבל את כל השישה, ולכן frontmatter שעומד במפרט נטען בו בלי שינוי.

משימות מתוזמנות בדסקטופ (Desktop scheduled tasks) רצות מקומית במכונה שלך, ולכן הן כן טוענות מיומנויות מ-~/.claude/skills/.

#מיומנויות מסונכרנות מ-claude.ai (Skills synced from claude.ai)

סעיף זה חל עליך אם אתה משתמש בסשנים של Cowork או ענן, או מתחבר ל-Claude Code בטרמינל באמצעות חשבון claude.ai. בסשנים אלה, Claude Code טוען את המיומנויות שהופעלו עבור חשבון claude.ai שלך בלי צורך בהגדרה מצדך. מיומנויות אלו כוללות מיומנויות שיצרת או הפעלת בהגדרות claude.ai, מיומנויות שסופקו על ידי הארגון שלך שם, ומיומנויות מובנות של Anthropic כגון pdf ו-xlsx.

Claude Code מוריד מיומנות מסונכרנת מהחשבון שלך במקום לקרוא קובץ שכתבת במכונה שבה הסשן רץ, ולכן הוא מחיל עליה כללים ייחודיים שאינם חלים על מיומנויות מקומיות.

#היכן נטענות מיומנויות מסונכרנות (Where synced skills load)

בסשן Cowork או ענן, Claude Code טוען את המיומנויות שהופעלו עבור חשבון claude.ai שלך. אופן הבחירה אילו מיומנויות הסשנים האלה מקבלים מתואר בסעיף שימוש במיומנויות בסשנים של Cowork וענן.

בטרמינל שלך, Claude Code מסנכרן מיומנויות אלו בסשנים שבהם אתה מתחבר עם חשבון claude.ai. סנכרון בסשני טרמינל דורש Claude Code בגרסה v2.1.273 ואילך. בעת עליית הסשן, Claude Code מוריד את מיומנויות החשבון ברקע לתוך ~/.claude/skills/synced/, ולאחר מכן בודק שינויים מול claude.ai כל עוד הסשן רץ. כאשר בדיקה מזהה שמיומנות נוספה, נערכה או כובתה ב-claude.ai, Claude Code מוסיף, מעדכן או מסיר אותה בסשן הפעיל בלי צורך בהפעלה מחדש.

הבדיקות רצות בתדירות נמוכה יותר כשהסשן לא פעיל:

• בזמן שאתה או קלוד עובדים בסשן: בדיקה רצה בערך כל 10 דקות.
• בזמן שהסשן לא פעיל: בדיקה רצה בערך כל 40 דקות. כשאתה מקליד שוב בסשן, Claude Code בודק תוך כמה דקות אם הבדיקה האחרונה הייתה לפני יותר מ-10 דקות.

הסנכרון אינו מעכב את עליית הסשן, כי קלוד ממתין להורדה של מיומנות רק כאשר הוא מפעיל אותה. ריצה קצרה לא אינטראקטיבית יכולה להסתיים לפני שמסתיימת הורדה של מיומנות שנוספה זה עתה, ובמקרה כזה סשן מאוחר יותר מוריד אותה. כדי שריצה לא אינטראקטיבית תוריד את המיומנויות ותמתין לרשימה לפני שהיא עונה להנחיה, הגדר את CLAUDE_CODE_SYNC_SKILLS ל-1. לפני v2.1.273, סשני טרמינל הורידו אותן רק בריצה עם -p כשהמשתנה הזה מוגדר.

Claude Code מסנכרן רק בסשן שמתחבר עם חשבון claude.ai ושמושך דגלי תכונה (feature flags) מ-Anthropic. אין סנכרון בסשנים האלה:

• סשן שאינו משתמש בכניסה שנשמרה על ידי /login, למשל אימות במפתח API, או סשן שבו ANTHROPIC_AUTH_TOKEN, CLAUDE_CODE_OAUTH_TOKEN או סקריפט apiKeyHelper מספקים את האישור.
• סשן שאינו מושך דגלי תכונה, למשל סשן על Amazon Bedrock או סשן שבו הגדרת CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC.
• סשן ב-bare mode, או סשן שהופעל עם --safe-mode.
• סשן שבו הגדרות מנוהלות של הארגון נועלות מיומנויות למקורות תוסף, או סשן שהופעל עם רשימת --setting-sources שמשמיטה את user.

אם התחברת עם /login במהלך סשן, הפעל מחדש את Claude Code כדי שהסנכרון יתחיל.

מיומנויות שסשן קודם כבר סנכרן נשארות על הדיסק. Claude Code טוען אותן בסשנים מאוחרים יותר שמחוברים לאותו חשבון, גם כאשר אין גישה ל-claude.ai.

Claude Code מוריד מיומנויות מסונכרנות ואינו מעלה אותן. עריכה שלך או של קלוד בקובץ תחת ~/.claude/skills/synced/ אינה נשמרת בחשבון claude.ai, וסנכרון מאוחר יותר יכול לדרוס או להסיר אותה. כדי לשנות מיומנות מסונכרנת, עדכן אותה ב-claude.ai. הסנכרון הבא מוריד את הגרסה החדשה.

כדי לראות אילו מיומנויות סונכרנו, הרץ /skills. התפריט מציג אותן תחת claude.ai sync.

חלק ממיומנויות Anthropic, כמו pdf ו-xlsx, מסונכרנות תמיד. לשאר, הפעלה או כיבוי בהגדרות המיומנויות ב-claude.ai קובעים אם הן מסונכרנות.

כדי להפסיק סנכרון במכונה, הגדר syncClaudeAiSkills ל-false בהגדרות המשתמש. Claude Code מפסיק להוריד, ובהפעלה הבאה הוא מעביר את המיומנויות שכבר סונכרנו אל ~/.claude/skills/.trash/ ואינו טוען אותן עוד. הארגון יכול לכבות סנכרון לכולם על ידי כיבוי Skills ב-claude.ai. כדי להפסיק סנכרון ועדיין להשאיר את Skills פעיל, אפשר להגדיר את אותו מפתח בהגדרות המנוהלות.

אם הארגון מכבה את Skills ב-claude.ai, Claude Code מסיר את המיומנויות שהורדו והן מפסיקות להיטען. המיומנויות שהוסרו עוברות אל ~/.claude/skills/.trash/, ומשם אפשר לשחזר את הקבצים עד שסריקת השמירה (retention sweep) מוחקת אותן. אחרי שהארגון מפעיל שוב את Skills, Claude Code מוריד בסנכרון הבא את המיומנויות שהפעלת.

#כאשר שם של מיומנות מסונכרנת מתנגש עם פקודה אחרת (When a synced skill name matches another command)

אפשר להפעיל מיומנות מסונכרנת בשם הקצר /<name>, או בשם המלא /anthropic-skills:<name>. כאשר פקודה אחרת משתמשת בשם הקצר, /<name> מריץ את הפקודה האחרת, והמיומנות המסונכרנת רצה רק כ-/anthropic-skills:<name>. עם מיומנות מקומית deploy ומיומנות מסונכרנת deploy, הפקודה /deploy מריצה את המקומית ו-/anthropic-skills:deploy מריצה את המסונכרנת. לפני v2.1.269 למיומנות מסונכרנת היה רק השם הקצר.

בתפריט /, ב-/skills וב-/context, מיומנות מסונכרנת מופיעה בשם הקצר, או בשם המלא כל עוד פקודה אחרת משתמשת בשם הקצר. הרץ /skills בסשן. הערה מתחת לרשימה מסבירה כל מיומנות מסונכרנת שאיבדה את השם הקצר. אם אחת מהמיומנויות האישיות או מקובצי הפקודה ב-~/.claude/ משתמשת בשם, ההערה גם אומרת מה לשנות או למחוק כדי לפנות אותו.

מ-v2.1.269 עד v2.1.280 הרשימות האלה הציגו כל מיומנות מסונכרנת בשם המלא, ול-/skills לא הייתה הערה כזו. שני הדברים השתנו ב-v2.1.281.

הפקודה שתופסת את השם הקצר יכולה להיות כל אחד מאלה:

• פקודה מובנית או מיומנות מובנית, כולל כזו שאינה זמינה בסשן, למשל אחרי כיבוי מיומנויות מובנות.
• מיומנות בכל רמה מקומית, או קובץ ב-.claude/commands/.
• מיומנות של תוסף.
• הנחיית MCP (MCP prompt).

Claude Code מסמן מיומנויות מסונכרנות כדי שאפשר יהיה לראות מאין הגיעו. תפריט /skills ו-/context מקבצים אותן תחת claude.ai sync, ותפריט הפקודות / מסמן אותן כמגיעות מ-claude.ai.

בהשוואת שמות, Claude Code מתעלם מרישיות, מרווחים ומתווים בלתי נראים, ומתייחס לצורות תאימות כמו אותיות ברוחב מלא וגרסאות של מקף כאל המקבילה הפשוטה שלהן. לדוגמה, מיומנות מסונכרנת בשם Commit ומיומנות מקומית בשם commit נחשבות לאותו שם, ולכן /commit ממשיך להריץ את המיומנות המקומית.

שם שנבדל רק באות דומה מאלפבית אחר נחשב לשם שונה, והתווית claude.ai sync היא הדרך להבדיל ביניהם. הבדיקות והתוויות האלה דורשות Claude Code בגרסה v2.1.228 ואילך.

#שמות שמורים למיומנויות מסונכרנות (Names reserved for synced skills)

Claude Code שומר את השם anthropic-skills, וכל שם בתוך מרחב השם הזה כגון anthropic-skills:pdf, למיומנויות שמסונכרנות מ-claude.ai, כך שהשם המלא של מיומנות מסונכרנת אינו מריץ שום דבר אחר. השם שמור בכל סשן, גם בלי התחברות עם חשבון claude.ai.

• תיקיית מיומנות, שדה name ב-frontmatter, קובץ או תת-תיקייה ב-.claude/commands/, או תהליך עבודה שמור: הפריט אינו נטען. הודעת עלייה מציינת את הפריט הראשון שצריך לשנות את שמו או לערוך.
• תוסף בשם anthropic-skills: התוסף נטען. כאשר אחת המיומנויות שלו ומיומנות מסונכרנת נקראות שתיהן <name>, הפקודה /anthropic-skills:<name> מריצה את המיומנות המסונכרנת.
• שרת MCP בשם anthropic-skills: השרת מתחבר והכלים שלו עובדים, אך ההנחיות שלו אינן מופיעות כפקודות. שנה את שם השרת בהגדרת ה-MCP כדי להציג אותן.

#כיצד Claude Code מטפל ב-frontmatter של מיומנות מסונכרנת

Claude Code מחיל שני כללים על ה-frontmatter של מיומנות מסונכרנת:

• Claude Code מכבד את ה-frontmatter בכל סוג של סשן, ולכן הרשאת allowed-tools עוברת בזרימת ההרשאות הרגילה. אם הארגון מגדיר allowManagedPermissionRulesOnly, ההרשאה אינה חלה. הפירוט בסעיף כאשר חלים רק כללי הרשאה מנוהלים.
• Claude Code מנקה את טקסט התצוגה שהמיומנות מספקת, כמו התיאור. הוא מסיר תווי בקרה, ובטקסט שמגיע לקלוד, כמו התיאור, הוא גם מבריח סוגריים זוויתיים כדי שהטקסט לא יוכל לחקות את העיצוב הפנימי של Claude Code. הניקוי הזה דורש Claude Code בגרסה v2.1.228 ואילך.

#כיצד Claude Code מטפל בגוף של מיומנות מסונכרנת

מה ש-Claude Code עושה עם גוף מיומנות מסונכרנת תלוי במקום שבו הסשן רץ:

• בסשן ענן, הגוף שומר על ההתנהגות של מיומנות מקומית, כי הסשן רץ בקונטיינר מבודד.
• בסשן Cowork על שולחן העבודה, הגוף שומר על ההתנהגות של מיומנות מקומית, למעט זאת ש-Claude Code מחליף כל שורת פקודת ! במציין המיקום של disableSkillShellExecution, כפי שהוא עושה לכל מיומנות שאתה מספק שם.
• בכל סשן אחר במכונה שלך, Claude Code אינו מריץ פקודות !, אינו מצרף את הקבצים שמוזכרים בהפניות @ כפי שהוא עושה למיומנות מקומית, ואינו מחליף את המציינים ${CLAUDE_PROJECT_DIR} ו-${CLAUDE_SESSION_ID}, כך שההפניות @ ושני המציינים מגיעים לקלוד כטקסט מילולי. שורת פקודת ! מגיעה לקלוד כטקסט מילולי, או כמציין המיקום הזה כאשר disableSkillShellExecution פעיל. הטיפול הזה דורש Claude Code בגרסה v2.1.228 ואילך.

#עריכת מיומנות במהלך סשן (Edit a skill during a session)

Claude Code מאזין לשינויי קבצים בתיקיות מיומנויות, למעט ב-bare mode. כאשר מוסיפים, עורכים או מסירים מיומנות תחת ~/.claude/skills/, תחת .claude/skills/ של הפרויקט, או תחת .claude/skills/ בתוך תיקייה של --add-dir, Claude Code קולט את השינוי בתוך הסשן הנוכחי, בלי הפעלה מחדש.

אם יצרת תיקיית מיומנויות ברמה העליונה שלא הייתה קיימת כשהסשן התחיל, הרץ /reload-skills כדי לקלוט את המיומנויות ששמת שם. Claude Code עדיין אינו מאזין לתיקייה הזו, ולכן הרץ /reload-skills שוב אחרי כל שינוי מאוחר יותר שם.

זיהוי שינויים חי מכסה רק את טקסט SKILL.md. בתיקיית מיומנות שהיא גם תוסף, שינויים ב-hooks/, ב-.mcp.json, ב-agents/ וב-output-styles/ דורשים /reload-plugins כדי שייכנסו לתוקף.

#הסרת מיומנות (Remove a skill)

אופן ההסרה תלוי במקור המיומנות:

• מיומנות אישית או של פרויקט: מחק את תיקיית המיומנות, ~/.claude/skills/<skill-name>/ או .claude/skills/<skill-name>/. Claude Code מסיר אותה מ-/skills בסשן הנוכחי. תוכן שכבר נטען ממנה ממשיך לפי מחזור החיים של תוכן מיומנות.
• מיומנות ארגונית: מנהל מוחק את תיקיית המיומנות מתוך .claude/skills/ בתיקיית ההגדרות המנוהלות, לדוגמה /etc/claude-code/.claude/skills/<skill-name>/ ב-Linux.
• מיומנות של תוסף: השבת או הסר את התוסף שמספק אותה, מתפריט /plugin או עם /plugin uninstall <plugin-name>@<marketplace-name>. Claude Code פורק את מיומנויות התוסף כאשר השינוי נכנס לתוקף, או בהפעלה מחדש.
• מיומנות מסונכרנת מ-claude.ai: כבה את המיומנות עבור חשבון claude.ai שלך, באותו מקום שבו הפעלת אותה. Claude Code מסיר אותה מ-~/.claude/skills/synced/ בסנכרון הבא. אם מוחקים את התיקייה ידנית, הסנכרון הבא מוריד אותה שוב כל עוד המיומנות נשארת מופעלת ב-claude.ai.
• מיומנות מובנית: הגדר disableBundledSkills ל-true כדי לכבות את המיומנויות המובנות, או הגדר מיומנות אחת ל-"off" ב-skillOverrides כדי להסתיר אותה.

כדי להשאיר מיומנות אישית או של פרויקט, אבל למנוע מקלוד להפעיל אותה בעצמו, הגדר disable-model-invocation: true ב-frontmatter שלה, או "user-invocable-only" ב-skillOverrides כאשר אין רצון לערוך את הקובץ.

#אישור כלים מראש (Pre-approve tools for a skill)

השדה allowed-tools מאשר את הכלים הרשומים בתור שמפעיל את המיומנות, כדי שקלוד ישתמש בהם בלי לבקש אישור. ההרשאה מתפנה כששולחים את ההודעה הבאה, אף שתוכן המיומנות נשאר בהקשר. הפעלה נוספת מחילה אותה שוב לאותו תור. השדה אינו מגביל אילו כלים זמינים: כל כלי נשאר ניתן לקריאה, והגדרות ההרשאה שלך חלות על כלים שאינם ברשימה. כדי לאשר כלים לכל הסשן, הוסף כללי allow להגדרות ההרשאה.

אמון ב-workspace אינו חוסם את השדה. Claude Code מחיל allowed-tools של מיומנות פרויקט גם בריצת -p בתיקייה שמעולם לא אושרה. מיומנות יכולה להעניק לעצמה גישה רחבה לכלים, לכן עבור על allowed-tools של מיומנויות שנשמרו במאגר לפני שמריצים שם את Claude Code. כדי למנוע את השדה ממיומנויות מאגר בכל הארגון, ראה את הסעיף הבא.

---
name: commit
description: Stage and commit the current changes
disable-model-invocation: true
allowed-tools: Bash(git add *) Bash(git commit *) Bash(git status *)
---

השדה מקבל מחרוזת מופרדת ברווחים או בפסיקים, או רשימת YAML. אותו פורמט חל על disallowed-tools, שמסיר כלים מהמאגר הזמין של קלוד כל עוד המיומנות פעילה. מתאים למיומנות אוטונומית שלא אמורה לקרוא לכלים מסוימים, למשל AskUserQuestion בלולאת רקע. ההגבלה מתפנה בהודעה הבאה. כמו כללי deny, השדה אינו יכול להסיר את EndConversation כל עוד נשאר כלי אחר. לחסימת כלים בכל המיומנויות וההנחיות, הוסף כללי deny בהגדרות ההרשאה.

#כאשר חלים רק כללי הרשאה מנוהלים (When only managed permission rules apply)

כאשר הארגון מגדיר allowManagedPermissionRulesOnly בהגדרות המנוהלות, Claude Code מתעלם מ-allowed-tools במיומנויות פרויקט ובמיומנויות אישיות, ובשאר המקורות שמפורטים בערך ההגדרה. זה דורש Claude Code בגרסה v2.1.282 ואילך.

הכלים שמיומנות מושפעת מפרטת עוברים לפי כללי ההרשאה המנוהלים ולפי בקשת ההרשאה הרגילה. הרץ /status כדי לראות אילו מיומנויות בסשן כבר איבדו את ההרשאה הזו. פקודה מוזרקת במיומנות שאף כלל מנוהל אינו מאשר כפופה לבדיקות ההרשאה על פקודות מוזרקות.

#כאשר הגדרות מנוהלות נועלות hooks לתוספים (When managed settings lock hooks to plugins)

כאשר ההגדרות המנוהלות של הארגון מפרטות את hooks בתוך strictPluginOnlyCustomization, מיומנות אישית או של פרויקט שה-frontmatter שלה מגדיר hooks מאבדת את האישור מראש של allowed-tools. יש מיומנויות ששומרות על האישור. אילו, לפי התיעוד הרשמי בסעיף על strictPluginOnlyCustomization עבור hooks (נכון ל-24 באוקטובר 2026).

• בדיקה: הקלד /status בסשן. אם /status מציג Enterprise managed settings, שאל את מנהל המערכת אם strictPluginOnlyCustomization כולל את hooks.
• תיקון: הסר את hooks מה-frontmatter, כי ה-hooks אינם רצים תחת ההגדרה הזו. כדי להשאיר אותם, העבר את המיומנות לתוסף שמתקינים משוק.

#הזרקת הקשר דינמי (Inject dynamic context)

התחביר !`<command>` מריץ פקודות מעטפת לפני שתוכן המיומנות נשלח לקלוד. פלט הפקודה מחליף את מציין המיקום, וקלוד מקבל נתונים אמיתיים. ההחלפה רצה פעם אחת על הקובץ המקורי. הפלט מוכנס כטקסט פשוט ואינו נסרק שוב למצייני !`<command>`, ולכן פקודה אינה יכולה לפלוט מציין מיקום שסבב מאוחר יותר ירחיב.

הצורה בשורה מזוהה רק כאשר ! מופיע בתחילת שורה או מיד אחרי רווח לבן. אם ! בא אחרי תו אחר, כמו KEY=!`cmd`, המציין נשאר טקסט מילולי והפקודה אינה רצה.

לפקודות מרובות שורות השתמש בבלוק גדר שנפתח ב-```!:

## Environment
```!
node --version
git status --short
```

כדי לבקש חשיבה עמוקה יותר כשהמיומנות רצה, כלול ultrathink בכל מקום בתוכן המיומנות.

כדי לכבות את ההתנהגות למיומנויות ולפקודות מותאמות ממקורות user, project, plugin או תיקייה נוספת, הגדר "disableSkillShellExecution": true. כל פקודה מוחלפת ב-[shell command execution disabled by policy] במקום לרוץ. מיומנויות מובנות ומנוהלות אינן מושפעות. ההגדרה שימושית במיוחד בהגדרות מנוהלות, שם המשתמש אינו יכול לעקוף אותה.

Claude Code אינו מריץ את הפקודות האלה במכונה שלך כאשר הן מופיעות במיומנות שמסונכרנת מחשבון claude.ai, בלי קשר להגדרה. המגבלה דורשת Claude Code בגרסה v2.1.228 ואילך. מה קלוד מקבל במקום הפקודה בכל סוג סשן מתואר בסעיף כיצד Claude Code מטפל בגוף של מיומנות מסונכרנת.

#כיצד פקודות מוזרקות רצות (How injected commands run)

Claude Code בוחר את הכלי שמריץ את הפקודות המוזרקות לפי שדה shell ב-frontmatter ולפי הסביבה. shell מקבל bash (ברירת המחדל) או powershell. כל צירוף רץ דרך כלי Bash או כלי PowerShell, חוץ מצירוף אחד שמפיל את ההפעלה:

• shell: powershell, כשכלי PowerShell מופעל: הפקודות רצות דרך כלי PowerShell. הכלי פועל כברירת מחדל ב-Windows בלי Git Bash, וכברירת מחדל עם Git Bash לחשבונות claude.ai ו-Console. ב-Amazon Bedrock, ב-Agent Platform של Google Cloud, ב-Microsoft Foundry, וב-macOS, Linux ו-WSL נדרש CLAUDE_CODE_USE_POWERSHELL_TOOL=1. הערך 0 מכבה את הכלי.
• shell: bash כאשר bash אינו זמין: ההפעלה נכשלת לפני שפקודה כלשהי רצה. זה קורה ב-Windows בלי Git Bash. Claude Code מציג Skill <name> requires bash (`shell: bash` in frontmatter) but Git Bash was not found.
• כל צירוף אחר: הפקודות רצות דרך כלי Bash כאשר bash זמין. כאשר אינו זמין, הן רצות דרך כלי PowerShell.

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

• תיקיית עבודה: כל פקודה רצה בתיקיית העבודה הנוכחית של מעטפת הסשן. התיקייה זזה כאשר קלוד מריץ cd. בנתיבים שצריכים להיפתר באותו אופן בכל פעם השתמש ב-${CLAUDE_SKILL_DIR} או ב-${CLAUDE_PROJECT_DIR}.
• stderr: עם מעטפת bash ברירת המחדל, Claude Code ממזג stderr לתוך stdout. מה שהפקודה כותבת ל-stderr מופיע בטקסט המוזרק.
• זמן קצוב: כל פקודה רצה תחת זמן הקצוב של 2 דקות של כלי Bash. כאשר כלי Bash מעביר פקודה שחרגה מהזמן לרקע, המיומנות עדיין מעובדת. הטקסט המוזרק מדווח על ההעברה ומציין את משימת הרקע ואת הקובץ שאוסף את הפלט. כאשר הפקודה היא כזו שכלי Bash אינו מעביר אוטומטית לרקע, Claude Code הורג אותה בזמן הקצוב. הכישלון הזה מבטל את ההפעלה.
• גודל פלט: פלט מעבר לתקרת השורה של כלי Bash מגיע כנתיב קובץ ועוד תצוגה מקדימה קצרה, לא כטקסט קטום. התקרה וכל גבול ניתנים לכוונון, לפי הסעיף Output limits בתיעוד הרשמי.

כלי PowerShell מחיל את אותו זמן קצוב, אותה העברה לרקע ואותה תקרת פלט.

#כאשר פקודה מוזרקת נכשלת (When an injected command fails)

פקודה שנכשלה מבטלת את כל הפעלת המיומנות, לא רק את מציין המיקום שלה. קלוד אינו רואה את תוכן המיומנות באותה הפעלה. הביטול מציג Shell command failed for pattern "...". הודעת השגיאה כוללת את פלט הפקודה.

עם מעטפת bash ברירת המחדל, כל קוד יציאה שאינו אפס נחשב לכישלון. יש חריג אחד: Claude Code מתייחס לקוד יציאה 1 מפקודות חיפוש והשוואה כתוצאה רגילה ומזריק את הפלט שלהן. קוד יציאה 2 ומעלה נכשל גם בפקודות האלה.

אילו פקודות מקבלות את החריג תלוי במעטפת:

• מעטפת bash ברירת המחדל: הפקודות שמפורטות תחת Output limits בתיעוד הרשמי.
• shell: powershell, כאשר כלי PowerShell מופעל: קבוצה אחרת שכוללת grep ו-git diff ואינה כוללת find או diff.

עם מעטפת bash ברירת המחדל, הוסף || true לכל פקודה אחרת שצפויה לצאת בקוד שאינו אפס. סקריפט בדיקה שיוצא ב-1 כשהוא מוצא בעיות הוא דוגמה.

#כאשר אף פקודת מעטפת לא רצה (When no shell command was run)

No shell command in <name> was run אומר שאחת מפקודות המעטפת במיומנות מכילה תו שהכלי אינו מקבל. איך מוצאים ומסירים את התו מפורט בתיעוד הרשמי בסעיף השגיאה No shell command was run (נכון ל-29 באוקטובר 2026).

#בדיקות הרשאה על פקודות מוזרקות (Permission checks on injected commands)

פקודות מוזרקות אינן מבקשות הרשאה בזמן שהמיומנות מעובדת. Claude Code בודק כל אחת מול כללי ההרשאה שלך קודם. פקודה שכלל deny תואם לה מבטלת את ההפעלה עם Shell command permission check failed for pattern "...".

מחוץ ל-auto mode, כאשר בדיקת ההרשאה של פקודה מחזירה משהו שאינו allow, Claude Code מבטל את ההפעלה באותה שגיאה. זה כולל כלל שבדרך כלל היה שואל אותך. כדי שפקודה שאינה תואמת לא תבטל כאן את ההפעלה, אשר אותה מראש עם allowed-tools. אם הארגון מגביל כללי הרשאה להגדרות מנוהלות, ראה את הסעיף כאשר חלים רק כללי הרשאה מנוהלים. כללי deny ו-ask עדיין גוברים על allowed-tools.

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

#הרצה בסוכן משנה (Run skills in a subagent)

הוסף context: fork ל-frontmatter כאשר המיומנות צריכה לרוץ בבידוד. Claude Code מפעיל סוכן משנה חדש מהסוג שבשדה agent, ונותן לו את תוכן המיומנות כהנחיה. סוכן המשנה אינו רואה את היסטוריית השיחה, ולכן ההוראות צריכות לעמוד בפני עצמן.

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

סוכן המשנה המפוצל רץ ברקע: אתה ממשיך לעבוד בזמן שהוא רץ, והתוצאה מגיעה לשיחה כשהוא מסיים. הגדר background: false ב-frontmatter כדי לחכות לתוצאה בתור שהפעיל את המיומנות. ברירת המחדל של background היא true. השדה חל רק עם context: fork.

Claude Code מחכה לתוצאה, גם כשהמיומנות אינה מגדירה background: false, במקרים האלה:

• במצב לא אינטראקטיבי, עם הדגל -p או עם Agent SDK.
• כאשר CLAUDE_CODE_DISABLE_BACKGROUND_TASKS מוגדר ל-1, מה שמכבה גם את שאר תכונות משימות הרקע.
• כאשר מפעילים מיומנות מפוצלת בזמן שהפעלה קודמת של אותה מיומנות עדיין רצה.
• כאשר משימה מתוזמנת ברמת הסשן נורה והמיומנות היא ההנחיה שלה.

כאשר סוכן בתהליך עבודה דינמי מפעיל מיומנות מפוצלת, הסוכן הזה מחכה לתוצאה ומקבל אותה, גם כשהמיומנות אינה מגדירה background: false. לפני v2.1.295 Claude Code לא חיכה במקרה הזה, וכשהמיומנות רצה ברקע התוצאה הגיעה לשיחה הראשית במקום להגיע לאותו סוכן.

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

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

context: fork מתאים למיומנויות עם הוראות מפורשות. אם המיומנות מכילה הנחיות כמו "use these API conventions" בלי משימה, סוכן המשנה מקבל את ההנחיות אבל אין לו הנחיה לפעולה, והוא חוזר בלי פלט בעל משמעות.

מיומנויות וסוכני משנה עובדים יחד בשני כיוונים:

עם context: fork כותבים את המשימה במיומנות ובוחרים סוג סוכן שיבצע אותה. סוכני Explore ו-Plan המובנים עולים בלי CLAUDE.md ובלי מצב git, כדי לשמור על הקשר קטן. שים ב-SKILL.md את כל מה שהמשימה צריכה. מיומנות מפוצלת עם agent: Explore מתחילה עם התוכן הזה ועם הנחיית המערכת של הסוכן, ובלי קובצי CLAUDE.md שלך.

שדה agent קובע איזו תצורת סוכן משנה תשמש. האפשרויות כוללות סוכנים מובנים (Explore, Plan, general-purpose) או כל סוכן משנה מותאם מ-.claude/agents/. אם השדה הושמט, נעשה שימוש ב-general-purpose.

---
name: deep-research
description: Research a topic thoroughly
context: fork
agent: Explore
---

Research $ARGUMENTS thoroughly:

1. Find relevant files using Glob and Grep
2. Read and analyze the code
3. Summarize findings with specific file references

כשהמיומנות רצה נוצר הקשר מבודד חדש, סוכן המשנה מקבל את תוכן המיומנות כהנחיה, שדה agent קובע את סביבת הביצוע (מודל, כלים והרשאות), וסוכן המשנה מסכם את התוצאות ומחזיר אותן לשיחה הראשית כשהוא מסיים.

#הגבלת הגישה של קלוד למיומנויות (Restrict Claude's skill access)

כברירת מחדל קלוד יכול להפעיל כל מיומנות שאין בה disable-model-invocation: true. מיומנויות שמגדירות allowed-tools מעניקות לקלוד גישה לכלים האלה בלי אישור לכל שימוש, בתור שמפעיל את המיומנות. ההרשאה מתפנה בהודעה הבאה. הגדרות ההרשאה שלך עדיין קובעות את אישור הבסיס לשאר הכלים. כמה פקודות מובנות זמינות גם דרך כלי Skill, כולל /init ו-/security-review. פקודות מובנות אחרות, כמו /compact, אינן זמינות כך.

שלוש דרכים לשלוט באילו מיומנויות קלוד יכול להפעיל:

כיבוי כל המיומנויות על ידי דחיית כלי Skill ב-/permissions:

# Add to deny rules:
Skill

אישור או דחייה של מיומנויות מסוימות בכללי הרשאה:

# Allow only specific skills
Skill(commit)
Skill(review-pr *)

# Deny specific skills
Skill(deploy *)

תחביר ההרשאה: Skill(name) להתאמה מדויקת, Skill(name *) להתאמת קידומת עם כל ארגומנט.

הטבלה מראה מה כלל deny חוסם מעבר לשם שכתבת, לפי סוג השם בכלל:

לפני v2.1.260 Claude Code לא חסם מיומנות מקוננת שמופיעה בשם המלא שלה כאשר כלל ה-deny ציין רק את השם בלי קידומת.

Claude Code מתאים כלל allow רק לשם של המיומנות עצמה ולשם בקריאה של קלוד. כדי לאשר מיומנות מסונכרנת בלי בקשה, ציין אותה בתוך מרחב השם השמור:

• Skill(anthropic-skills:pdf) מאשר את מיומנות pdf המסונכרנת.
• Skill(anthropic-skills *) מאשר כל מיומנות מסונכרנת.
• Skill(anthropic *) אינו מכסה את anthropic-skills:pdf, כי קידומת שמחוץ למרחב השם אינה תואמת לשמות שבתוכו.

הסתרת מיומנות בודדת נעשית עם disable-model-invocation: true ב-frontmatter. זה מסיר את המיומנות מההקשר של קלוד לגמרי.

#נראות בלי לערוך את הקובץ (skillOverrides)

ההגדרה skillOverrides שולטת בנראות מתוך קובץ ההגדרות, בלי לערוך את SKILL.md. זה מתאים למיומנות שנמצאת במאגר משותף. תפריט /skills כותב את ההגדרה: סמן מיומנות, לחץ Space כדי לעבור בין המצבים, ואז Esc כדי לשמור ב-.claude/settings.local.json. מיומנות שאינה מופיעה בהגדרה נחשבת "on". מיומנויות של תוסף אינן מושפעות. מנהלים אותן דרך /plugin.

"off" מסתיר את המיומנות גם מרשימות הפקודות של לקוחות Remote Control ושל קוראי Agent SDK, בנוסף לתפריט / בטרמינל. הפעלה בשם המלא מחזירה את שגיאת skillOverrides במקום להריץ.

{
  "skillOverrides": {
    "legacy-context": "name-only",
    "deploy": "off"
  }
}

לחלק מהמיומנויות המובנות יש כינוי, למשל checkup עבור /doctor. אם רשומה תחת כינוי נמצאת בהגדרות מנוהלות או בקובץ שמועבר עם --settings, Claude Code מחיל אותה על המיומנות שמאחורי הכינוי. דרך כינוי אפשר רק להגביל עוד, ואם יש גם רשומה בשם המיומנות עצמו בהגדרות המנוהלות, הרשומה הזו קודמת. לפני v2.1.260 רשומה תחת כינוי לא הוחלה על המיומנות באף מקור הגדרות. בהגדרות user, project ו-local ההתאמה היא רק לשם המיומנות: רשומת review שם חלה על מיומנות בשם review, לא על /code-review המובנית דרך הכינוי /review.

#מיומנויות שלא בשימוש (Find unused skills)

כל מיומנות ברשימת המיומנויות מוסיפה להקשר בכל תור, גם אם קלוד לא משתמש בה. הרץ /skill-doctor כדי לראות מה כל מיומנות עולה וכמה היא בשימוש. בסשן אינטראקטיבי הדוח נפתח בלשונית Stats של מנהל /plugin. במצב לא אינטראקטיבי עם -p, Claude Code מדפיס אותו כטקסט.

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

/skill-doctor דורש Claude Code בגרסה v2.1.252 ואילך, ואינו זמין בסשן שמדלג על משיכת דגלי תכונה. הרצה מעל Remote Control מהטלפון או מהדפדפן מקבלת את התשובה Skill usage reports are not available on this connection. הרץ /skill-doctor בטרמינל של המכונה שבה הסשן רץ.

#מלכודת: התיאורים נחתכים ברשימה (Skill descriptions are cut short)

Claude Code טוען להקשר רשימה של שמות ותיאורים כדי שקלוד יידע מה זמין. הרשימה תמיד כוללת כל שם מיומנות, אבל כשיש הרבה מיומנויות Claude Code משמיט חלק מהתיאורים כדי להיכנס לתקציב התווים של הרשימה, וכך נעלמות מילות המפתח שקלוד צריך כדי להתאים לבקשה. התקציב הוא 1% מחלון ההקשר של המודל. כשהרשימה חורגת, Claude Code משמיט תיאורים החל מהמיומנויות שאתה מפעיל הכי מעט, כך שהמיומנויות שבשימוש הרב ביותר שומרות על הטקסט המלא.

שים את מקרה השימוש העיקרי בתחילת description. הטקסט המשולב של description ו-when_to_use נחתך ב-1,536 תווים ברשימה, בלי קשר לתקציב. את התקרה אפשר לשנות עם skillListingMaxDescChars. when_to_use הוא הקשר נוסף למתי קלוד צריך להפעיל את המיומנות, למשל ביטויי הפעלה או בקשות לדוגמה. הוא מצורף ל-description ברשימה ונספר בתקרה.

הרץ /doctor להערכה של עלות ההקשר של הרשימה ושל התורמים הגדולים. כדי למצוא מיומנויות שכדאי לכבות, הרץ /skill-doctor. כשהרשימה חורגת מהתקציב, Claude Code גם כותב אזהרה ליומן הדיבוג, הנראה עם --debug.

השורה Skills ב-/context מדווחת על גודל הרשימה אחרי החלת התקציב, ולכן היא תואמת את מה שהמודל מקבל. לפני v2.1.196 השורה ספרה את הטקסט המלא של כל תיאור, ויכלה להציג ערך גדול פי כמה מהתקציב שהוגדר.

כדי להעלות את התקציב, הגדר skillListingBudgetFraction (לדוגמה 0.02 הוא 2%) או את משתנה הסביבה SLASH_COMMAND_TOOL_CHAR_BUDGET למספר תווים קבוע. כדי לפנות תקציב לאחרות, הגדר רשומות בעדיפות נמוכה ל-"name-only" ב-skillOverrides, כך שהן מופיעות בלי תיאור.

#מלכודת: סוגריים זוויתיים בתיאור מוצגים כ-< ו-> (Angle brackets in a skill description)

Claude Code מציג < ו-> בשדות description ו-when_to_use כ-< ו->. כדי להציג מציין מקום כמו <branch>:

• סוגריים מרובעים: החלף את <branch> ב-[branch]. זה מוצג כפי שנכתב.
• argument-hint: העבר את מציין המקום לשורה argument-hint: <branch>. הוא מוצג אחרי שם הפקודה. אם מעלים את המיומנות ל-claude.ai או ל-Skills API, או אורזים אותה עם package_skill.py, בדוק קודם אם argument-hint מותר שם. השדה אינו בין השישה המותרים, וההעלאה או האריזה נכשלות בשגיאה קשיחה.

#מלכודת: קלוד מפסיק לעקוב אחרי מיומנות (Claude stops following a skill)

אם קלוד עוקב אחרי מיומנות בתשובה הראשונה ומפסיק בהמשך, התחל במקרה שמתאים:

• קלוד דילג על כלל שחייב להתקיים בכל פעם: העבר את הכלל ל-hook. Claude Code מריץ hook בכל פעם שהאירוע שלו מתרחש, למשל לפני כל עריכת קובץ, בין אם קלוד עוקב אחרי המיומנות ובין אם לא. כדי להשאיר את הכלל עם המיומנות, הגדר את ה-hook בשדה hooks ב-frontmatter. ה-hook חל מרגע הפעלת המיומנות ועד סוף הסשן. פורמט ההגדרה, האפשרות once והמגבלות על hooks של מיומנות מפורטים בתיעוד הרשמי על hooks במיומנויות ובסוכנים (נכון ל-29 באוקטובר 2026).
• קלוד דילג על הנחיה שהוא אמור להחיל לפי שיקול דעת: נסח אותה כך שתחול על כל המשימה, למשל "Run the tests after every edit" ולא "Run the tests". Claude Code מוסיף את תוכן המיומנות לשיחה בהפעלה ואינו קורא את הקובץ מחדש בתורות הבאים.
• השיחה כווצה: הפעל את המיומנות שוב כדי להחזיר את התוכן המלא. אחרי כיווץ Claude Code יכול לשמור רק את תחילת המיומנות שהופעלה, ולכן שים את ההוראות החשובות ביותר קרוב לראש SKILL.md.

#מלכודת: המיומנות לא מופעלת (Skill not triggering)

אם קלוד אינו משתמש במיומנות כשמצופה:

1. בדוק שהתיאור כולל מילות מפתח שמשתמשים אומרים בטבעיות.
2. ודא שהמיומנות מופיעה בתשובה ל-What skills are available?.
3. נסח מחדש את הבקשה כך שתתאים יותר לתיאור.
4. הפעל ישירות עם /skill-name אם המיומנות ניתנת להפעלה על ידי המשתמש.
5. אם גם /skill-name אינו מזוהה, בדוק אם Claude Code דחה את שם המיומנות, לפי הסעיף תווים ששם מיומנות לא יכול להכיל.
6. אם המיומנות מגדירה paths, בדוק שהקבצים שקלוד קורא, עורך או כותב נמצאים בתוך תיקיית העבודה הנוכחית של Claude Code. המיומנות אינה מופעלת עבור קבצים מחוץ לתיקייה הזו, למשל קבצים ב-git worktree אח, גם אם הוספת אותו עם /add-dir. כדי שהמיומנות תופעל עבור הקבצים האלה, הפעל את Claude Code בתוך ה-worktree הזה, או העבר את הסשן לשם עם /cd.

Claude Code קורא frontmatter רק כאשר --- הפותח הוא השורה הראשונה בקובץ. אחרת הוא מתייחס לכל הקובץ, כולל סימני ---, כתוכן המיומנות. אם ה-YAML בין הסימנים אינו מתפרש, המיומנות עדיין נטענת בלי שדות: /skill-name עדיין עובד, אבל קלוד אינו יכול להתאים מול description. הרץ עם --debug כדי לראות את שגיאת הפענוח.

אם המיומנות מגיעה מתוסף, אפשר למדוד באיזו תדירות היא מופעלת על פני הנחיות מציאותיות: כתוב מקרה הערכה עם grader של tool_used: Skill, והרץ claude plugin eval אחרי כל שינוי תיאור.

כדי למצוא קובצי SKILL.md שה-frontmatter שלהם אינו מתפרש, הרץ claude plugin validate על תיקיית המיומנויות, למשל claude plugin validate .claude/skills למיומנויות פרויקט או claude plugin validate ~/.claude/skills למיומנויות אישיות. זה דורש Claude Code בגרסה v2.1.233 ואילך.

#מלכודת: המיומנות מופעלת יותר מדי (Skill triggers too often)

אם קלוד מפעיל את המיומנות כשאינך רוצה:

1. הפוך את התיאור לספציפי יותר.
2. הוסף disable-model-invocation: true אם אתה רוצה רק הפעלה ידנית.

#מלכודת: תיקיות אישיות שנעלמו (Personal skills disappeared)

אם תיקיות שיצרת ב-~/.claude/skills/ נעלמו, חפש ב-~/.claude/skills/.trash/. סנכרון מ-claude.ai מוריד אל תת-התיקייה synced ואינו מזיז או מוחק תיקיות שיצרת.

לפני v2.1.280, קובץ בשם manifest.json בתוך ~/.claude/skills/ גרם ל-Claude Code להעביר את תיקיות המיומנות שהקובץ מנה אל תיקייה עם חותמת זמן תחת ~/.claude/skills/.trash/, והמיומנויות האלה הפסיקו להיטען.

כדי לשחזר, העבר את התיקייה מהתיקייה עם חותמת הזמן בחזרה אל ~/.claude/skills/. עשה זאת לפני שסריקת השמירה מוחקת רשומות בסל, כברירת מחדל 30 יום אחרי ההעברה לסל.

#הערכה ושיפור (Evaluate and iterate on a skill)

הפעלה של מיומנות אומרת שקלוד מצא אותה, לא שהיא עשתה את מה שהתכוונת. כדי לדעת שהיא עובדת, מודדים בנפרד אם קלוד מפעיל אותה על ההנחיות שבהן היא אמורה לרוץ, ואם הפלט תואם למה שציפית כשהיא רצה.

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

איך מכבים את המיומנות לריצה השנייה תלוי במקור שלה:

• מיומנות אישית או של פרויקט: הגדר אותה ל-"off" ב-skillOverrides.
• מיומנות שתוסף מספק: skillOverrides אינו חל על מיומנויות תוסף. השתמש ב-claude plugin eval, שחוזר על כל ריצה בלי שהתוסף טעון.

שני כלים ממכנים את ההשוואה. למיומנות שנשלחת בתוסף, claude plugin eval מריץ כל הנחיה בסשן מבודד עם התוסף ובלי התוסף, נותן ציון עם graders שאתה מגדיר או שהוא כותב עבורך, ויוצא בקוד שאינו אפס מתחת לסף כדי שאפשר יהיה לחסום איתו CI. לשיפור מיומנות בודדת בתוך שיחת Claude Code, תוסף skill-creator מריץ לולאה דומה עם פורמט evals/evals.json משלו. שני הפורמטים אינם ניתנים להחלפה.

#הרצת הערכות עם skill-creator (Run evals with skill-creator)

תוסף skill-creator ממכן את לולאת ההשוואה בתוך Claude Code. בהרחבת VS Code או באפליקציית הדסקטופ, התקן אותו משוק התוספים הרשמי לפי Install a plugin בתיעוד הרשמי. בטרמינל, הפעל את Claude Code עם claude, ואז הקלד בשורה שלו:

/plugin install skill-creator@claude-plugins-official

אם ההתקנה נכשלת, התאם את ההודעה ש-Claude Code מדווח:

• Marketplace "claude-plugins-official" not found: הוסף את השוק עם /plugin marketplace add anthropics/claude-plugins-official, ואז נסה שוב את ההתקנה.
• Plugin "<name>" not found in marketplace "claude-plugins-official": העותק המקומי של קטלוג השוק עשוי להיות לא מעודכן. רענן אותו עם /plugin marketplace update claude-plugins-official, ואז נסה שוב. אם הניסיון מדפיס את אותה הודעה, ראה Plugin not found in marketplace בתיעוד הרשמי.

אם סיכום ההתקנה מדווח Run /reload-plugins to apply., Claude Code מריץ את הטעינה מחדש עבורך. אם הטעינה מחדש מזהירה שההודעה הבאה תקרא מחדש את השיחה, הרץ /reload-plugins --force כדי שהמיומנויות של התוסף יהיו זמינות בסשן הנוכחי. אחר כך בקש מקלוד להעריך מיומנות קיימת, למשל evaluate my summarize-changes skill with skill-creator. התוסף מוביל אותך בכתיבת מקרי בדיקה ומריץ את הלולאה:

• מקרי בדיקה: שומר הנחיות, קובצי קלט והתנהגות צפויה ב-evals/evals.json בתוך תיקיית המיומנות.
• ריצות מבודדות: מפעיל סוכן משנה לכל מקרה בדיקה כדי שכל ריצה תתחיל בהקשר נקי, ורושם ספירת טוקנים ומשך.
• ציון: בודק כל טענה מול הפלט וכותב הצלחה או כישלון עם ראיות ל-grading.json.
• Benchmark: מאגד שיעור הצלחה, זמן וטוקנים להרצה עם המיומנות מול הרצה בלעדיה אל benchmark.json, כדי להשוות את שיפור שיעור ההצלחה מול עלות הטוקנים והזמן.
• השוואת גרסאות: מריץ A/B עיוור בין שתי גרסאות של המיומנות, כדי לאשר שעריכה היא שיפור לפני ששומרים אותה.
• כיוון התיאור: מייצר הנחיות שצריכות להפעיל והנחיות שלא צריכות להפעיל, מודד את שיעור הפגיעה, ומציע עריכות לתיאור כאשר המיומנות מופעלת על הבקשות הלא נכונות.
• מציג סקירה: פותח דוח HTML שבו בודקים כל פלט ורושמים משוב איכותי שהאיטרציה הבאה קוראת.

פורמט קובץ ההערכה וזרימת האיטרציה המלאה נמצאים ב-Evaluating skill output quality ב-agentskills.io. רקע על מצבי ה-benchmark וההשוואה נמצא בהכרזה על skill-creator.

#שיתוף מיומנויות (Share skills)

אפשר להפיץ מיומנויות בהיקפים שונים לפי הקהל:

• מיומנויות פרויקט: שמור את .claude/skills/ בבקרת גרסאות. מיומנויות פרויקט שנשמרו במאגר נטענות גם כשהמאגר משמש בערוץ Claude Tag.
• תוספים: צור תיקיית skills/ בתוסף.
• מנוהל: פרוס לכל הארגון דרך הגדרות מנוהלות.

#פלט חזותי (Generate visual output)

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

הדוגמה הרשמית היא סייר קוד (codebase-visualizer): עץ אינטראקטיבי עם תיקיות שנפתחות ונסגרות, גדלי קבצים, וצבע לפי סוג קובץ.

1. צור את תיקיית המיומנות:

   העתק

   mkdir -p ~/.claude/skills/codebase-visualizer/scripts

2. שמור SKILL.md בנתיב ~/.claude/skills/codebase-visualizer/SKILL.md. התיאור אומר לקלוד מתי להפעיל, וההוראות אומרות לו להריץ את הסקריפט המצורף. הנתיב משתמש ב-${CLAUDE_SKILL_DIR} כדי שייפתר נכון בהתקנה אישית, בפרויקט או בתוסף:

---
name: codebase-visualizer
description: Generate an interactive collapsible tree visualization of your codebase. Use when exploring a new repo, understanding project structure, or identifying large files.
allowed-tools: Bash(python3 *)
---

# Codebase Visualizer

Generate an interactive HTML tree view that shows your project's file structure with collapsible directories.

## Usage

Run the visualization script from your project root:

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/visualize.py .
```

This creates `codebase-map.html` in the current directory and opens it in your default browser.

## What the visualization shows

- **Collapsible directories**: Click folders to expand/collapse
- **File sizes**: Displayed next to each file
- **Colors**: Different colors for different file types
- **Directory totals**: Shows aggregate size of each folder

3. שמור את הסקריפט ב-~/.claude/skills/codebase-visualizer/scripts/visualize.py. לפי התיעוד הרשמי (נכון ל-5 בנובמבר 2026) הסקריפט סורק עץ תיקיות ויוצר קובץ HTML עצמאי עם סרגל סיכום (מספר קבצים, מספר תיקיות, גודל כולל ומספר סוגי קבצים), תרשים עמודות של 8 סוגי הקבצים הגדולים, ועץ שנפתח ונסגר עם סימון צבע לסוג הקובץ וגודל מצטבר לכל תיקייה. הוא דורש Python 3 ומשתמש רק בספריות מובנות. הוא מדלג על .git, node_modules, __pycache__, .venv, venv, dist, build ועל שמות שמתחילים בנקודה, כותב codebase-map.html, מדפיס את הנתיב המוחלט ופותח אותו בדפדפן.

כדי לבדוק, פתח את Claude Code בפרויקט כלשהו ובקש "Visualize this codebase." קלוד מריץ את הסקריפט, שמדפיס נתיב כמו Generated /path/to/codebase-map.html ופותח אותו בדפדפן. בסביבה בלי דפדפן, הנתיב המודפס מאשר שהסקריפט הצליח.

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

באותו דפוס של נתיב, אפשר לאשר מראש סקריפט מצורף בלי בקשת הרשאה. Claude Code מחליף את ${CLAUDE_SKILL_DIR} ואת ${CLAUDE_PROJECT_DIR} בשני מקומות: בתוכן ה-Markdown, ובכללי Bash ב-allowed-tools. במיומנות תוסף הוא מחליף באותם שני מקומות גם את ${CLAUDE_PLUGIN_ROOT} ואת ${CLAUDE_PLUGIN_DATA}.

---
name: render-chart
description: Render a chart from a CSV file
allowed-tools: Bash(${CLAUDE_SKILL_DIR}/scripts/render.sh *)
---

Run `${CLAUDE_SKILL_DIR}/scripts/render.sh <csv-file>` to render the chart.

אם המיומנות מותקנת ב-~/.claude/skills/render-chart/, שתי המופעים של ${CLAUDE_SKILL_DIR} מתרחבים לתיקייה הזו. כלל allowed-tools תואם אז לפקודה המדויקת שגוף המיומנות אומר לקלוד להריץ, והסקריפט רץ בלי בקשה.

${CLAUDE_SKILL_DIR} היא התיקייה שמכילה את SKILL.md. במיומנות תוסף זו תת-התיקייה של המיומנות בתוך התוסף, לא שורש התוסף. ${CLAUDE_PROJECT_DIR} הוא שורש הפרויקט, אותו נתיב ש-hooks ושרתי MCP מקבלים. ${CLAUDE_PLUGIN_ROOT} ו-${CLAUDE_PLUGIN_DATA} מוחלפים רק במיומנויות תוסף. ${CLAUDE_PLUGIN_DATA} היא תיקיית הנתונים המתמשכת של התוסף, שנשארת אחרי עדכון תוסף. ${CLAUDE_SESSION_ID} הוא מזהה הסשן הנוכחי. ${CLAUDE_EFFORT} הוא רמת ה-effort הנוכחית: low, medium, high, xhigh או max.

#להעמקה

כל אפשרויות ה-skills, המשתנים ודוגמאות ההגדרה.