📘 תיעוד 41

הרחבת Claude עם מיומנויות

צור, נהל ושתף מיומנויות (skills) כדי להרחיב את היכולות של Claude ב-Claude Code. כולל פקודות מותאמות אישית ומיומנויות מובנות (bundled skills).

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

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

הערה: לפקודות מובנות כמו help/ ו-compact/, ולמיומנויות מובנות כמו debug/ ו-code-review/, ראה את מדריך הפקודות (/docs/en/commands).

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

מיומנויות ב-Claude Code עוקבות אחר התקן הפתוח Agent Skills (בכתובת https://agentskills.io), אשר עובד על פני מספר כלי AI. Claude Code מרחיב את התקן עם תכונות נוספות כמו בקרת הפעלה, הרצה בסוכן משנה (subagent), והזרקת הקשר דינמי. ראה שימוש ב-frontmatter של מיומנות מחוץ ל-Claude Code כדי לדעת אילו שדות frontmatter הם חלק מהתקן ואילו הם הרחבות של Claude Code.

#מיומנויות מובנות

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

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

רוב המיומנויות המובנות זמינות בכל הפעלה (session). מעטות תלויות בתכונה ספציפית: workflow-authoring/, למשל, זמינה רק כאשר תהליכי עבודה דינמיים (dynamic workflows) מופעלים.

כדי לכבות מיומנויות מובנות, השתמש בהגדרה disableBundledSkills, אשר משביתה כל מיומנות מובנית למעט doctor/.

הערה: בדיקת ההתקנה של doctor/ נשארת ניתנת להקלדה גם כאשר disableBundledSkills מופעל, בגרסת Claude Code v2.1.205 ואילך. כדי להסתיר אותה, הגדר את משתנה הסביבה DISABLE_DOCTOR_COMMAND או רשומה ב-skillOverrides של "doctor": "off". לפני גרסה v2.1.205, הפקודה doctor/ הייתה פקודה מובנית (built-in command) ולא מיומנות מובנית (bundled skill).

מיומנויות מובנות מופיעות לצד פקודות מובנות במדריך הפקודות (/docs/en/commands), כשהן מסומנות כ-Skill בעמודת המטרה (Purpose).

#הרצה ואימות של האפליקציה שלך

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

/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 בשורש המאגר, או בתיקיית החבילה שנערכה במקרה של מונו-ריפו (monorepo), כדי שהרצות עתידיות וסוכנים אחרים יעקבו אחר אותם שלבים. בשורש המאגר, המיומנות המוקלטת מחליפה את /verify המובנית. תכונה זו דורשת את Claude Code בגרסה v2.1.200 ואילך.

Claude עורך את הקובץ המוקלט רק כאשר הוא הוביל הרצה לתוצאה שגויה, כגון פקודה שנכשלה או שלב חסר, כך שתוכל לבצע commit לקובץ ללא שינויי diff בכל הפעלה. לפני גרסה v2.1.205, המיומנות המובנית הורתה ל-Claude להוסיף כל דבר שנלמד בהרצה, מה שגרם להתנגשויות מיזוג תכופות.

#מתחילים

#יצירת המיומנות הראשונה שלך

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

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

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

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

שמור זאת בנתיב ~/.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 מריץ את הפקודה ומחליף את השורה בפלט שלה לפני ש-Claude רואה את תוכן המיומנות, כך שההוראות מגיעות כאשר ה-diff הנוכחי כבר מוטמע בתוכן.

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

תן ל-Claude להפעיל אותה אוטומטית על ידי שאילת שאלה שתואמת לתיאור:

What did I change?

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

/summarize-changes

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

#היכן מיומנויות נמצאות

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

כאשר מיומנויות חולקות את אותו השם, Claude Code פותר את ההתנגשות לפי המקור:

• על פני הרמות השונות, ארגוני עוקף אישי, ואישי עוקף פרויקט.
  • לדוגמה, עם מיומנות deploy הן ב-~/.claude/skills/ והן ב-.claude/skills/ של הפרויקט שלך, הפקודה /deploy תריץ את המיומנות האישית.
• מיומנות בכל אחת מהרמות הללו עוקפת גם מיומנות מובנית בעלת אותו שם, אך לא את הכינויים (aliases) של המיומנות המובנית.
  • לדוגמה, מיומנות code-review ב-.claude/skills/ של הפרויקט שלך מחליפה את /code-review המובנית, אך הקלדת הכינוי המובנה /review לעולם לא תריץ את המיומנות שלך.
• מיומנויות של תוספים משתמשות במרחב שמות של plugin-name:skill-name, כך שהן אינן יכולות להתנגש עם רמות אחרות.
  • לדוגמה, my-plugin/skills/deploy/SKILL.md הופך ל-/my-plugin:deploy ונטען לצד מיומנות deploy ב-.claude/skills/ של הפרויקט שלך.
• אם יש לך קבצים ב-.claude/commands/, הם פועלים באותו אופן, אך אם מיומנות ופקודה חולקות את אותו השם, המיומנות מקבלת עדיפות.
  • לדוגמה, כאשר קיימים גם .claude/commands/deploy.md וגם .claude/skills/deploy/SKILL.md, הפקודה /deploy מריצה את המיומנות.
• מיומנות או פקודה מכל אחד מהמקורות הללו עוקפת מיומנות המסונכרנת מחשבון ה-claude.ai שלך בעלת אותו שם.
  • לדוגמה, כאשר מיומנות deploy מופעלת ב-claude.ai ומיומנות נוספת קיימת ב-.claude/skills/ של הפרויקט שלך, הפקודה /deploy מריצה את זו של הפרויקט.

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

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

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

הקלדת /deploy מריצה את מיומנות שורש הפרויקט. הקלד את השם המפורש /apps/web:deploy כדי להריץ את הגרסה המקוננת באופן מפורש.

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

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

רשומה של <skill-name> במיקומים ארגוניים, אישיים או של פרויקט יכולה להיות קישור סמלי (symlink) לתיקייה במקום אחר בדיסק. Claude Code עוקב אחר הקישור הסמלי וקורא את SKILL.md מתיקיית היעד, ואם אותו יעד נגיש מיותר ממיקום אחד, Claude Code טוען את המיומנות פעם אחת בלבד. מיומנויות של תוספים מטפלות בקישורים סמליים בצורה שונה: ראה שיתוף קבצים בתוך זירת מסחר (marketplace) באמצעות קישורים סמליים (/docs/en/plugins-reference#share-files-within-a-marketplace-with-symlinks).

הערה: הוסף קובץ .claude-plugin/plugin.json לתיקיית מיומנות והיא תיטען כתוסף בשם <name>@skills-dir, כך שהיא תוכל לכלול סוכנים, הוקים (hooks), ושרתי MCP. בתיקיית .claude/skills/ של פרויקט, הדבר דורש אישור של תיבת הדו-שיח לאמון בסביבת העבודה (workspace trust dialog) תחילה.

#זיהוי שינויים בזמן אמת

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

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

#גילוי מתיקיות אב ומתיקיות מקוננות

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

מיומנויות בתיקיות .claude/skills/ מקוננות מתחת לתיקיית ההתחלה שלך אינן נטענות בעת ההפעלה. הן נטענות בפעם הראשונה ש-Claude קורא או עורך קובץ בתיקיית המשנה שמכילה אותן, ונשארות זמינות להמשך ההפעלה. לדוגמה, לאחר ש-Claude עורך קובץ תחת packages/frontend/, מיומנויות ב-packages/frontend/.claude/skills/ הופכות לזמינות. עד אז, מיומנויות אלו אינן מופיעות בהשלמה אוטומטית, ואינך יכול להפעיל אותן לפי שמן.

כדי לטעון מיומנויות של תיקיית משנה לפני ש-Claude קורא או עורך שם קובץ, הרץ את /add-dir עם הנתיב של אותה תיקיית משנה. תכונה זו דורשת את Claude Code בגרסה v2.1.257 ואילך.

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

#מיומנויות מתיקיות נוספות

הדגל --add-dir והפקודה /add-dir מעניקים גישה לקבצים ולא גילוי הגדרות (configuration discovery), אך מיומנויות ופקודות הן יוצאות מן הכלל: Claude Code טוען את .claude/skills/ ואת .claude/commands/ מכל תיקייה שנוספה באופן אוטומטי. חריגה זו חלה על --add-dir, על /add-dir, ועל תיקיות ש-Agent SDK מוסיף באמצעות additionalDirectories ב-TypeScript או add_dirs ב-Python, שה-SDK מעביר ל-Claude Code כ---add-dir.

ההגדרה permissions.additionalDirectories בקובץ settings.json מעניקה גישה לקבצים בלבד ואינה טוענת מיומנויות, פקודות או סוכני משנה, למרות שלאפשרות ב-TypeScript יש את אותו השם. ראה זיהוי שינויים בזמן אמת לגבי האופן שבו עריכות של מיומנויות נקלטות במהלך הפעלה.

Claude Code טוען מיומנויות, פקודות וסוכני משנה מתיקייה שנוספה רק כאשר מקור ההגדרות project מופעל, וזוהי ברירת המחדל. אם אתה מעביר את --setting-sources ב-CLI, או מגדיר את settingSources או setting_sources במפורש ב-SDK, כלול את project ברשימה. במצב --safe-mode, Claude Code אינו טוען אף אחד משלושתם. מדיניות מנוהלת של strictPluginOnlyCustomization ומצב bare מתייחסים לשלושתם באופן שונה:

• מיומנויות ב-.claude/skills/: מדיניות שנועלת מיומנויות מכבה אותן. מצב bare עדיין טוען אותן.
• פקודות ב-.claude/commands/: אותה נעילת מיומנויות מכבה אותן. מצב bare מדלג עליהן.
• סוכני משנה ב-.claude/agents/: הרשומה agents במדיניות מכבה אותם, ולא רשומת ה-skills שלה. מצב bare מדלג על כל תיקיית .claude/agents/, כולל זו של הפרויקט עצמו.

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

מלבד המפתחות enabledPlugins ו-extraKnownMarketplaces בקובצי .claude/settings.json ו-.claude/settings.local.json של תיקייה שנוספה, Claude Code אינו טוען הגדרות .claude/ אחרות, כגון סגנונות פלט (output styles), מתיקיות נוספות. ראה את טבלת החריגות לקבלת הרשימה המלאה של מה שנטען ומה שלא, ואת הדרכים המומלצות לשיתוף הגדרות בין פרויקטים.

הערה: קובצי CLAUDE.md מתיקיות שנוספו עם --add-dir אינם נטענים כברירת מחדל. כדי לטעון אותם, הגדר CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1.

#מיומנויות בהפעלות Cowork והפעלות ענן

הפעלות Cowork (בכתובת https://claude.com/product/cowork) והפעלות ענן, כולל רוטינות (routines), אינן קוראות את ~/.claude/skills/ במחשב שלך. הן הפעלות Cowork אינטראקטיביות והן הפעלות מתוזמנות טוענות את המיומנויות שמופעלות עבור חשבון ה-claude.ai שלך, המסונכרנות בתחילת ההפעלה: נהל אותן מתוך Customize בסרגל הצד של אפליקציית ה-Desktop או מהגדרות המיומנויות ב-claude.ai. הפעלות ענן טוענות בנוסף מיומנויות פרויקט שנשמרו ב-commit לתוך .claude/skills/ של המאגר המשוכפל.

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

• עבור הפעלות Cowork והפעלות ענן, הפעל את המיומנות עבור חשבון ה-claude.ai שלך.
• עבור הפעלות ענן, באפשרותך במקום זאת לשמור את המיומנות ב-commit לתוך .claude/skills/ של המאגר, או להפיץ אותה בתוסף המוצהר בקובץ .claude/settings.json של המאגר. תוספים המוצהרים במאגר מותקנים בתחילת ההפעלה: תוספים שמופעלים רק בהגדרות המשתמש שלך אינם מועברים.

משימות מתוזמנות באפליקציית שולחן העבודה (Desktop scheduled tasks) שונות: הן רצות מקומית במחשב שלך וטוענות מיומנויות מאותם המיקומים כמו כל הפעלה מקומית אחרת.

#מיומנויות המסונכרנות מ-claude.ai

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

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

#היכן נטענות מיומנויות מסונכרנות

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

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

1. הפעל את המיומנויות עבור חשבון ה-claude.ai שלך: הפעל כל מיומנות שאתה מעוניין בה עבור חשבון ה-claude.ai שלך, כפי שמתואר בחלק מיומנויות בהפעלות Cowork והפעלות ענן. Claude Code מוריד רק את המיומנויות שהפעלת, והוא זקוק להתחברות שלך ל-claude.ai כדי להוריד אותן.

2. הרץ את Claude Code במצב לא אינטראקטיבי עם סנכרון מופעל: Claude Code מוריד מיומנויות מסונכרנות רק כאשר אתה מריץ אותו במצב לא אינטראקטיבי עם הדגל -p ומגדיר את משתנה הסביבה CLAUDE_CODE_SYNC_SKILLS לערך 1. הפרומפט שאתה מעביר אינו משפיע על ההורדה.

CLAUDE_CODE_SYNC_SKILLS=1 claude -p "List the skills you have available"

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

3. ודא שהמיומנויות נטענות בהפעלה מקומית: התחל הפעלה אינטראקטיבית, ללא הגדרת CLAUDE_CODE_SYNC_SKILLS, והרץ את /skills. התפריט יציג את המיומנויות שהורדו תחת claude.ai sync. כל הפעלה מקומית שתתחיל לאחר מכן עם אותה התחברות ל-claude.ai תטען אותן מ-~/.claude/skills/synced/ גם כן.

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

Claude Code מדלג על מיומנות מסונכרנת ששמה תואם לכל פקודה אחרת, והפקודה האחרת היא זו שרצה. הפקודה האחרת יכולה להיות פקודה מובנית (built-in command), מיומנות מובנית (bundled skill), מיומנות בכל רמה מקומית, מיומנות של תוסף, קובץ ב-.claude/commands/, או פרומפט של MCP. בנוסף, Claude Code שומר את השמות של הפקודות המובנות והמיומנויות המובנות שלו גם כאשר הן אינן זמינות בהפעלה שלך, למשל לאחר שכיבית מיומנויות מובנות, ולכן הוא מדלג על מיומנות מסונכרנת עם אחד מהשמות הללו גם במקרה זה.

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

בעת השוואת שמות, Claude Code מתעלם מאותיות גדולות או קטנות, מרווחים ותווים בלתי נראים, ומתייחס לצורות תאימות כגון אותיות ברוחב מלא (fullwidth) וגרסאות שונות של מקפים כשקולות למקבילות הפשוטות שלהן, כך ש-Commit מסונכרן אינו יכול להיטען לצד commit מקומי. שם שנבדל רק באות בעלת מראה דומה מאלפבית אחר נחשב לשם שונה, והתווית claude.ai sync היא הדרך שבה תוכל להבדיל בין השניים.

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

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

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

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

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

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

#הסרת מיומנות

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

• מיומנות אישית או מיומנות פרויקט: מחק את תיקיית המיומנות, ~/.claude/skills/<skill-name>/ או .claude/skills/<skill-name>/. Claude Code מסיר אותה מ-/skills בהפעלה הנוכחית: תוכן ש-Claude Code כבר טען מתוכה פועל לפי מחזור החיים של תוכן מיומנות.
• מיומנות ארגונית (Enterprise): מנהל מערכת מוחק את תיקיית המיומנות מתוך .claude/skills/ בתוך תיקיית ההגדרות המנוהלות, לדוגמה /etc/claude-code/.claude/skills/<skill-name>/ בלינוקס.
• מיומנות תוסף: השבת או הסר את התקנת התוסף שמספק אותה, מתוך תפריט /plugin או באמצעות /plugin uninstall <plugin-name>@<marketplace-name>. Claude Code פורק את מיומנויות התוסף לאחר שתריץ /reload-plugins או תפעיל מחדש: ראה החלת שינויים בתוסף ללא הפעלה מחדש (/docs/en/discover-plugins#apply-plugin-changes-without-restarting).
• מיומנות המסונכרנת מ-claude.ai: כבה את המיומנות עבור חשבון ה-claude.ai שלך, באותו המקום שבו הפעלת אותה. Claude Code מסיר אותה מ-~/.claude/skills/synced/ בפעם הבאה שהוא מסנכרן את המיומנויות שלך. אם תמחק את התיקייה ידנית במקום זאת, הסנכרון הבא יוריד אותה שוב כל עוד המיומנות נשארת מופעלת ב-claude.ai.
• מיומנות מובנית (Bundled): הגדר את disableBundledSkills ל-true כדי לכבות כל מיומנות מובנית מלבד /doctor, או הגדר מיומנות ספציפית ל-"off" ב-skillOverrides כדי להסתיר אותה.

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

#הגדרת מיומנויות

מיומנויות מוגדרות באמצעות YAML frontmatter בחלק העליון של SKILL.md ותוכן ה-markdown שבא אחריו.

#סוגי תוכן של מיומנויות

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

תוכן עיון (Reference content) מוסיף ידע ש-Claude מיישם בעבודתך הנוכחית. מוסכמות, דפוסים, מדריכי סגנון וידע בתחום. תוכן זה רץ מוטמע (inline) כך ש-Claude יכול להשתמש בו לצד הקשר השיחה שלך.

---
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

תוכן משימה (Task content) מספק ל-Claude הוראות צעד אחר צעד עבור פעולה ספציפית, כמו פריסות (deployments), שמירות (commits) או יצירת קוד. לעיתים קרובות אלו פעולות שתרצה להפעיל ישירות באמצעות /skill-name במקום לתת ל-Claude להחליט מתי להריץ אותן. הוסף disable-model-invocation: true כדי למנוע מ-Claude להפעיל זאת אוטומטית. הדוגמה להלן מוסיפה 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

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

#פירוט שדות ה-frontmatter

מעבר לתוכן ה-markdown, באפשרותך להגדיר את התנהגות המיומנות באמצעות שדות YAML frontmatter בין סימוני --- בחלק העליון של קובץ ה-SKILL.md שלך:

---
name: my-skill
description: What this skill does
disable-model-invocation: true
allowed-tools: Read Grep
---

Your skill instructions here...

כל השדות הם אופציונליים. רק description מומלץ כדי ש-Claude ידע מתי להשתמש במיומנות.

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

שדות בוליאניים מקבלים yes, no, on, off, 1 ו-0 בכל שילוב של אותיות גדולות וקטנות, בנוסף ל-true ו-false. לפני גרסה v2.1.218, Claude Code זיהה רק true ו-false.

#שימוש ב-frontmatter של מיומנות מחוץ ל-Claude Code

Claude Code מקבל כל שדה בטבלה שלעיל. מחוץ ל-Claude Code, באפשרותך להשתמש רק בשדות המופיעים במפרט Agent Skills:

כאשר אתה מפעיל מיומנות אישית עבור הפעלות Cowork והפעלות ענן, כולל רוטינות, אתה מעלה אותה ל-claude.ai, ולכן אותם הכללים חלים.

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

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

הגבלת ה-frontmatter לששת השדות של המפרט מונעת את שגיאת המפתח הבלתי צפוי שלעיל. מפרט Agent Skills ודרישות ה-Skills API מגדירים את כל השאר שנתיבים אלו מאמתים. תכונות גוף ייחודיות ל-Claude Code בלבד, כגון הזרקת הקשר דינמי, אינן פועלות בצ'אט של claude.ai או דרך ה-API. Claude Code מקבל את כל ששת השדות, כך ש-frontmatter העוקב אחר המפרט נטען ב-Claude Code ללא שינויים.

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

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

הטבלה להלן מציגה מהיכן מגיע שם הפקודה עבור כל מבנה:

במיומנות תוסף, שדה ה-name ב-frontmatter מחליף את שם התיקייה במקטע האחרון של הפקודה, כך ש-my-plugin/skills/review/SKILL.md עם name: fancy הופך ל-/my-plugin:fancy. הפקודה הפשוטה /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, נשאר שמור גם כאשר הפקודה אינה יכולה לרוץ באותן הפעלות. מיומנות מסונכרנת בשם help או feedback עדיין מושמטת שם, מכיוון ש-Claude Code מדלג על מיומנות מסונכרנת ששמה תואם לפקודה מובנית כלשהי בין אם אותה פקודה יכולה לרוץ ובין אם לאו.

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

#החלפות מחרוזת זמינות

מיומנויות תומכות בהחלפת מחרוזות עבור ערכים דינמיים בתוכן המיומנות:

Claude Code מחליף את ${CLAUDE_SKILL_DIR} ואת ${CLAUDE_PROJECT_DIR} בשני מקומות: בתוכן ה-markdown של המיומנות, ובכללי Bash ב-frontmatter תחת allowed-tools. במיומנות תוסף, Claude Code מחליף את ${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 להריץ, כך שהסקריפט רץ ללא בקשת אישור.

החלפת ${CLAUDE_PROJECT_DIR} דורשת את Claude Code בגרסה v2.1.196 ואילך.

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

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

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

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

דוגמה לשימוש בהחלפות:

---
name: session-logger
description: Log activity for this session
---

Log the following to logs/${CLAUDE_SESSION_ID}.log:

$ARGUMENTS

#הוספת קבצים תומכים

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

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)

הפנה לקבצים תומכים מתוך SKILL.md כדי ש-Claude ידע מה כל קובץ מכיל ומתי לטעון אותו:

## Additional resources

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

טיפ: שמור על SKILL.md מתחת ל-500 שורות. העבר חומרי עיון מפורטים לקבצים נפרדים.

#שליטה במי מפעיל מיומנות

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

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

• user-invocable: false: רק Claude יכול להפעיל את המיומנות. השתמש בזה עבור ידע רקע שאינו פעולה מעשית כפקודה. מיומנות legacy-system-context מסבירה כיצד מערכת ישנה פועלת. Claude צריך לדעת זאת כאשר הדבר רלוונטי, אך /legacy-system-context אינה פעולה בעלת משמעות שמשתמשים צריכים לבצע.

דוגמה זו יוצרת מיומנות פריסה שרק אתה יכול להפעיל. אם תגדיר disable-model-invocation: true, Claude לא יוכל להריץ את המיומנות באופן אוטומטי:

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

Deploy $ARGUMENTS to production:

1. Run the test suite
2. Build the application
3. Push to the deployment target
4. Verify the deployment succeeded

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

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

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

#מחזור החיים של תוכן מיומנות

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

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

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

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

#אישור מראש של כלים עבור מיומנות

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

אמון בסביבת עבודה (Workspace trust) אינו חוסם שדה זה. Claude Code מחיל את ה-allowed-tools של מיומנות פרויקט בכל פעם שאתה או Claude מפעילים את המיומנות, כולל בהרצת -p בתיקייה שמעולם לא נתת בה אמון. מיומנות יכולה להעניק לעצמה גישה רחבה לכלים, ולכן בדוק את ה-allowed-tools של מיומנויות שנשמרו במאגר לפני שאתה מריץ שם את Claude Code.

מיומנות זו מאפשרת ל-Claude להריץ פקודות git ללא בקשת אישור בכל פעם שאתה מפעיל אותה:

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

כדי להסיר כלים ממאגר הכלים הזמינים של Claude בזמן שמיומנות פעילה, רשום אותם תחת disallowed-tools ב-frontmatter של המיומנות. ההגבלה מתנקה כאשר אתה שולח את ההודעה הבאה שלך. בדומה לכללי דחייה, השדה אינו יכול להסיר את EndConversation כל עוד נותר כלי אחר כלשהו. כדי לחסום כלים על פני כל המיומנויות והפרומפטים, הוסף כללי דחייה (deny rules) בהגדרות ההרשאות שלך.

#העברת ארגומנטים למיומנויות

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

מיומנות זו מתקנת תקלת GitHub לפי מספר. ממלא המקום $ARGUMENTS מוחלף בכל מה שמופיע אחרי שם המיומנות:

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

Fix GitHub issue $ARGUMENTS following our coding standards.

1. Read the issue description
2. Understand the requirements
3. Implement the fix
4. Write tests
5. Create a commit

כאשר אתה מריץ /fix-issue 123, Claude מקבל "Fix GitHub issue 123 following our coding standards..."

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

באפשרותך גם לשרשר (stack) מספר מיומנויות בתחילת הודעה אחת. הקלדת /write-tests /fix-issue 123 טוענת את שתי המיומנויות ומעבירה את הטקסט העוקב 123 כ-$ARGUMENTS לכל אחת מהן. לפני גרסה v2.1.199, רק המיומנות הראשונה נטענה וקיבלה את /fix-issue 123 כטקסט ארגומנט מילולי.

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

כדי לגשת לארגומנטים בודדים לפי מיקום, השתמש ב-$ARGUMENTS[N] או בקיצור $N:

---
name: migrate-component
description: Migrate a component from one language to another
---

Migrate the $ARGUMENTS[0] component from $ARGUMENTS[1] to $ARGUMENTS[2].
Preserve all existing behavior and tests.

הרצת /migrate-component SearchBar JavaScript TypeScript מחליפה את $ARGUMENTS[0] ב-SearchBar, את $ARGUMENTS[1] ב-JavaScript, ואת $ARGUMENTS[2] ב-TypeScript. אותה מיומנות באמצעות קיצור ה-$N:

---
name: migrate-component
description: Migrate a component from one language to another
---

Migrate the $0 component from $1 to $2.
Preserve all existing behavior and tests.

#דפוסים מתקדמים

#הזרקת הקשר דינמי

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

מיומנות זו מסכמת pull request על ידי משיכת נתוני PR חיים באמצעות ה-CLI של GitHub. הפקודות !`gh pr diff` ופקודות אחרות רצות תחילה, והפלט שלהן מוכנס לתוך הפרומפט:

---
name: pr-summary
description: Summarize changes in a pull request
context: fork
agent: Explore
allowed-tools: Bash(gh *)
---

## Pull request context
- PR diff: !`gh pr diff`
- PR comments: !`gh pr view --comments`
- Changed files: !`gh pr diff --name-only`

## Your task
Summarize this pull request...

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

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

עבור פקודות מרובות שורות, השתמש בבלוק קוד מגודר שנפתח ב-```! במקום בצורה המוטמעת:

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

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

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

טיפ: כדי לבקש חשיבה עמוקה יותר כאשר מיומנות רצה, כלול את המילה ultrathink בכל מקום בתוכן המיומנות. ראה שימוש ב-ultrathink עבור חשיבה עמוקה חד-פעמית (/docs/en/model-config#use-ultrathink-for-one-off-deep-reasoning).

#כיצד פקודות מוזרקות רצות

Claude Code בוחר את הכלי שמריץ את הפקודות המוזרקות של מיומנות מתוך המפתח shell ב-frontmatter של המיומנות ומהסביבה שלך. כל שילוב מריץ את הפקודות דרך כלי Bash או כלי PowerShell, למעט שילוב אחד שמכשיל את ההפעלה לחלוטין:

• shell: powershell, כאשר כלי ה-PowerShell מופעל: הפקודות רצות דרך כלי PowerShell.
• 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.

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

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

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

#כאשר פקודה מוזרקת נכשלת

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

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

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

• מעטפת ברירת המחדל bash: הפקודות המפורטות תחת מגבלות פלט (/docs/en/tools-reference#output-limits).
• shell: powershell, כאשר כלי ה-PowerShell מופעל: קבוצה שונה הכוללת את grep ו-git diff אך לא את find או diff.

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

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

כדי למנוע מפקודה ללא התאמה להתבטל כאן, אשר אותה מראש באמצעות allowed-tools. כלל ask או deny תואם עדיין מבטל את ההפעלה ללא תלות ב-allowed-tools. ראה ניהול הרשאות (/docs/en/permissions#manage-permissions).

#הרצת מיומנויות בסוכן משנה

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

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

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

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

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

מיומנות מפוצלת שרצה ברקע מחילה את העריכות שלה מחוץ לנקודות הבדיקה (checkpoints) של ההפעלה שלך, ולכן /rewind אינו מבטל אותן: השתמש ב-git כדי להחזיר אותן לקדמותן.

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

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

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

#דוגמה: מיומנות מחקר המשתמשת בסוכן Explore

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

---
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

כאשר מיומנות זו רצה:

1. נוצר הקשר מבודד חדש.
2. סוכן המשנה מקבל את תוכן המיומנות כפרומפט שלו ("...Research $ARGUMENTS thoroughly").
3. השדה agent קובע את סביבת ההרצה (מודל, כלים והרשאות).
4. סוכן המשנה מסכם את תוצאותיו ומחזיר אותן לשיחה הראשית שלך כאשר הוא מסיים.

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

#הגבלת הגישה של Claude למיומנויות

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

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

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

# הוסף לכללי הדחייה:
Skill

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

# אשר רק מיומנויות ספציפיות
Skill(commit)
Skill(review-pr *)

# דחה מיומנויות ספציפיות
Skill(deploy *)

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

הסתרת מיומנויות בודדות על ידי הוספת disable-model-invocation: true ל-frontmatter שלהן. הדבר מסיר את המיומנות מההקשר של Claude לחלוטין.

הערה: עם user-invocable: false, אינך יכול להפעיל את המיומנות, אך Claude עדיין יכול. כדי למנוע מ-Claude להפעיל אותה דרך כלי ה-Skill, הגדר disable-model-invocation: true.

#דריסת נראות של מיומנות מתוך ההגדרות

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

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

תפריט /skills מסמן את המצב "user-invocable-only" כ-user-only.

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

מיומנות שאינה מופיעה ב-skillOverrides מטופלת כ-"on". הדוגמה להלן מצמצמת מיומנות אחת לשמה בלבד ומכבה מיומנות אחרת לחלוטין:

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

מיומנויות תוסף אינן מושפעות מ-skillOverrides. נהל אותן דרך /plugin במקום זאת.

#איתור מיומנויות שאינן בשימוש

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

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

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

#הערכה ואיטרציה על מיומנות

לראות מיומנות מופעלת מעיד ש-Claude מצא אותה, אך לא שהיא ביצעה את מה שהתכוונת. כדי לדעת שמיומנות פועלת כראוי, מדוד שני דברים בנפרד: האם Claude מפעיל אותה בפרומפטים שבהם הוא אמור להפעיל אותה, והאם הפלט תואם לציפיות שלך כאשר הוא מפעיל אותה.

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

#הרצת הערכות (evals) באמצעות skill-creator

התוסף skill-creator (בכתובת https://github.com/anthropics/claude-plugins-official/tree/main/plugins/skill-creator) מאפשר אוטומציה של לולאת ההשוואה בתוך Claude Code. התקן אותו מזירת המסחר הרשמית:

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

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

• Marketplace "claude-plugins-official" not found: הוסף את זירת המסחר באמצעות /plugin marketplace add anthropics/claude-plugins-official, ואז נסה שוב את ההתקנה.
• התוסף לא נמצא בזירת המסחר: בדוק את שם התוסף.

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

• מקרי בדיקה (Test cases): שומר פרומפטים, קובצי קלט והתנהגות צפויה ב-evals/evals.json בתוך תיקיית המיומנות.
• הרצות מבודדות (Isolated runs): יוצר סוכן משנה עבור כל מקרה בדיקה כך שכל הרצה מתחילה בהקשר נקי, ומתעד כמות טוקנים ומשך זמן.
• מתן ציונים (Grading): בודק כל טענה (assertion) מול הפלט וכותב הצלחה (pass) או כישלון (fail) עם ראיות אל grading.json.
• מדד ביצועים (Benchmark): צובר אחוזי מעבר, זמן וטוקנים עבור עם מיומנות לעומת ללא מיומנות אל benchmark.json, כך שתוכל להשוות את השיפור באחוזי המעבר לעומת תקורה של טוקנים וזמן.
• השוואת גרסאות (Version comparison): מריץ בדיקת A/B עיוורת בין שתי גרסאות של המיומנות כדי שתוכל לוודא שעריכה היא אכן שיפור לפני ביצוע commit.
• כוונון תיאור (Description tuning): מייצר פרומפטים שאמורים להפעיל ושאינם אמורים להפעיל, מודד את שיעור הפגיעה, ומציע עריכות לתיאור כאשר המיומנות מופעלת בבקשות שגויות.
• מציג סקירה (Review viewer): פותח דו"ח HTML שבו אתה בודק כל פלט ומתעד משוב איכותני שהאיטרציה הבאה תקרא.

לגבי פורמט קובץ ההערכה ותהליך האיטרציה המלא, ראה הערכת איכות פלט מיומנות (בכתובת https://agentskills.io/skill-creation/evaluating-skills) באתר agentskills.io. לרקע על מצבי המדד וההשוואה, ראה את ההכרזה על skill-creator (בכתובת https://claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills).

#שיתוף מיומנויות

ניתן להפיץ מיומנויות בהיקפים שונים בהתאם לקהל היעד שלך:

• מיומנויות פרויקט: בצע commit של .claude/skills/ למערכת בקרת הגרסאות.
• תוספים: צור תיקיית skills/ בתוך התוסף שלך.
• מנוהל (Managed): פרוס ברחבי הארגון דרך הגדרות מנוהלות (/docs/en/managed-settings).

#יצירת פלט חזותי

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

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

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

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

שמור זאת בנתיב ~/.claude/skills/codebase-visualizer/SKILL.md. התיאור מציין ל-Claude מתי להפעיל מיומנות זו, וההוראות מורות ל-Claude להריץ את הסקריפט המצורף. נתיב הסקריפט משתמש ב-${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

שמור זאת בנתיב ~/.claude/skills/codebase-visualizer/scripts/visualize.py. סקריפט זה סורק עץ תיקיות ומייצר קובץ HTML עצמאי הכולל:

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

הסקריפט דורש Python 3 אך משתמש בספריות מובנות בלבד, כך שאין צורך בהתקנת חבילות:

#!/usr/bin/env python3
"""Generate an interactive collapsible tree visualization of a codebase."""

import json
import sys
import webbrowser
from html import escape
from pathlib import Path
from collections import Counter

IGNORE = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', 'dist', 'build'}

def scan(path: Path, stats: dict) -> dict:
    result = {"name": path.name, "children": [], "size": 0}
    try:
        for item in sorted(path.iterdir()):
            if item.name in IGNORE or item.name.startswith('.'):
                continue
            if item.is_file():
                size = item.stat().st_size
                ext = item.suffix.lower() or '(no ext)'
                result["children"].append({"name": item.name, "size": size, "ext": ext})
                result["size"] += size
                stats["files"] += 1
                stats["extensions"][ext] += 1
                stats["ext_sizes"][ext] += size
            elif item.is_dir():
                stats["dirs"] += 1
                child = scan(item, stats)
                if child["children"]:
                    result["children"].append(child)
                    result["size"] += child["size"]
    except PermissionError:
        pass
    return result

def generate_html(data: dict, stats: dict, output: Path) -> None:
    ext_sizes = stats["ext_sizes"]
    total_size = sum(ext_sizes.values()) or 1
    sorted_exts = sorted(ext_sizes.items(), key=lambda x: -x[1])[:8]
    colors = {
        '.js': '#f7df1e', '.ts': '#3178c6', '.py': '#3776ab', '.go': '#00add8',
        '.rs': '#dea584', '.rb': '#cc342d', '.css': '#264de4', '.html': '#e34c26',
        '.json': '#6b7280', '.md': '#083fa1', '.yaml': '#cb171e', '.yml': '#cb171e',
        '.mdx': '#083fa1', '.tsx': '#3178c6', '.jsx': '#61dafb', '.sh': '#4eaa25',
    }
    lang_bars = "".join(
        f'<div class="bar-row"><span class="bar-label">{ext}</span>'
        f'<div class="bar" style="width:{(size/total_size)*100}%;background:{colors.get(ext,"#6b7280")}"></div>'
        f'<span class="bar-pct">{(size/total_size)*100:.1f}%</span></div>'
        for ext, size in sorted_exts
    )
    def fmt(b):
        if b < 1024: return f"{b} B"
        if b < 1048576: return f"{b/1024:.1f} KB"
        return f"{b/1048576:.1f} MB"

    html = f'''<!DOCTYPE html>
<html><head>
  <meta charset="utf-8"><title>Codebase Explorer</title>
  <style>
    body {{ font: 14px/1.5 system-ui, sans-serif; margin: 0; background: #1a1a2e; color: #eee; }}
    .container {{ display: flex; height: 100vh; }}
    .sidebar {{ width: 280px; background: #252542; padding: 20px; border-right: 1px solid #3d3d5c; overflow-y: auto; flex-shrink: 0; }}
    .main {{ flex: 1; padding: 20px; overflow-y: auto; }}
    h1 {{ margin: 0 0 10px 0; font-size: 18px; }}
    h2 {{ margin: 20px 0 10px 0; font-size: 14px; color: #888; text-transform: uppercase; }}
    .stat {{ display: flex; justify-content: space-between; padding: 8px 0; border-bottom: 1px solid #3d3d5c; }}
    .stat-value {{ font-weight: bold; }}
    .bar-row {{ display: flex; align-items: center; margin: 6px 0; }}
    .bar-label {{ width: 55px; font-size: 12px; color: #aaa; }}
    .bar {{ height: 18px; border-radius: 3px; }}
    .bar-pct {{ margin-left: 8px; font-size: 12px; color: #666; }}
    .tree {{ list-style: none; padding-left: 20px; }}
    details {{ cursor: pointer; }}
    summary {{ padding: 4px 8px; border-radius: 4px; }}
    summary:hover {{ background: #2d2d44; }}
    .folder {{ color: #ffd700; }}
    .file {{ display: flex; align-items: center; padding: 4px 8px; border-radius: 4px; }}
    .file:hover {{ background: #2d2d44; }}
    .size {{ color: #888; margin-left: auto; font-size: 12px; }}
    .dot {{ width: 8px; height: 8px; border-radius: 50%; margin-right: 8px; }}
  </style>
</head><body>
  <div class="container">
    <div class="sidebar">
      <h1>📊 Summary</h1>
      <div class="stat"><span>Files</span><span class="stat-value">{stats["files"]:,}</span></div>
      <div class="stat"><span>Directories</span><span class="stat-value">{stats["dirs"]:,}</span></div>
      <div class="stat"><span>Total size</span><span class="stat-value">{fmt(data["size"])}</span></div>
      <div class="stat"><span>File types</span><span class="stat-value">{len(stats["extensions"])}</span></div>
      <h2>By file type</h2>
      {lang_bars}
    </div>
    <div class="main">
      <h1>📁 {escape(data["name"])}</h1>
      <ul class="tree" id="root"></ul>
    </div>
  </div>
  <script>
    const data = {json.dumps(data)};
    const colors = {json.dumps(colors)};
    function fmt(b) {{ if (b < 1024) return b + ' B'; if (b < 1048576) return (b/1024).toFixed(1) + ' KB'; return (b/1048576).toFixed(1) + ' MB'; }}
    function esc(s) {{ return s.replace(/[&<>"']/g, c => ({{"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}}[c])); }}
    function render(node, parent) {{
      if (node.children) {{
        const det = document.createElement('details');
        det.open = parent === document.getElementById('root');
        det.innerHTML = `<summary><span class="folder">📁 ${{esc(node.name)}}</span><span class="size">${{fmt(node.size)}}</span></summary>`;
        const ul = document.createElement('ul'); ul.className = 'tree';
        node.children.sort((a,b) => (b.children?1:0)-(a.children?1:0) || a.name.localeCompare(b.name));
        node.children.forEach(c => render(c, ul));
        det.appendChild(ul);
        const li = document.createElement('li'); li.appendChild(det); parent.appendChild(li);
      }} else {{
        const li = document.createElement('li'); li.className = 'file';
        li.innerHTML = `<span class="dot" style="background:${{colors[node.ext]||'#6b7280'}}"></span>${{esc(node.name)}}<span class="size">${{fmt(node.size)}}</span>`;
        parent.appendChild(li);
      }}
    }}
    data.children.forEach(c => render(c, document.getElementById('root')));
  </script>
</body></html>'''
    output.write_text(html)

if __name__ == '__main__':
    target = Path(sys.argv[1] if len(sys.argv) > 1 else '.').resolve()
    stats = {"files": 0, "dirs": 0, "extensions": Counter(), "ext_sizes": Counter()}
    data = scan(target, stats)
    out = Path('codebase-map.html')
    generate_html(data, stats, out)
    print(f'Generated {out.absolute()}')
    webbrowser.open(f'file://{out.absolute()}')

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

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

#פתרון בעיות

#המיומנות אינה מופעלת

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

1. בדוק שהתיאור כולל מילות מפתח שמשתמשים יגידו באופן טבעי
2. ודא שהמיומנות מופיעה ב-What skills are available?
3. נסה לנסח מחדש את בקשתך כדי שתתאים באופן מדויק יותר לתיאור
4. הפעל אותה ישירות באמצעות /skill-name אם המיומנות ניתנת להפעלה על ידי משתמש

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

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

#המיומנות מופעלת לעיתים קרובות מדי

אם Claude משתמש במיומנות שלך כאשר אינך מעוניין בכך:

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

#תיאורי המיומנות נחתכים

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

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

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

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

#משאבים קשורים

• ניפוי באגים בהגדרות שלך: אבחון מדוע מיומנות אינה מופיעה או אינה מופעלת
• הערכת איכות פלט מיומנות: פורמט קובץ ההערכה ותהליך האיטרציה באתר agentskills.io
• שיטות עבודה מומלצות לכתיבת מיומנויות: הנחיות כתיבה החלות על כל מוצרי Claude
• סוכני משנה: האצלת משימות לסוכנים ייעודיים
• תוספים: אריזה והפצה של מיומנויות יחד עם הרחבות אחרות
• הוקים: אוטומציה של תהליכי עבודה סביב אירועי כלים
• זיכרון: ניהול קובצי CLAUDE.md עבור הקשר קבוע
• פקודות: מדריך עבור פקודות מובנות ומיומנויות מובנות
• הרשאות: שליטה בגישה לכלים ולמיומנויות
• מיומנויות Claude Tag: מיומנויות פרויקט שנשמרו במאגר נטענות גם כאשר אותו מאגר נמצא בשימוש בערוץ Claude Tag