📘 תיעוד 49

הרחבת Claude באמצעות מיומנויות

צרו, נהלו ושתפו מיומנויות כדי להרחיב את היכולות של Claude ב-Claude Code. כולל פקודות מותאמות אישית ומיומנויות ארוזות.

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

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

[!NOTE]

לפקודות מובנות כמו /help ו-/compact, ולמיומנויות ארוזות כמו /debug ו-/code-review, ראו את הפניה לפקודות.

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

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

#מיומנויות ארוזות

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

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

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

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

[!NOTE]

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

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

#בדיקת ההגדרות עם /doctor

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

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

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

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

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

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

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

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

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

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

#הרצת הבדיקות לפני כל commit

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

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

#עבודה על פרויקטים של Claude API

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

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

#תחילת העבודה

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

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

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

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

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

2. כתיבת SKILL.md

כל מיומנות צריכה קובץ SKILL.md עם שני חלקים: YAML frontmatter בין סמני --- שאומר ל-Claude מתי להשתמש במיומנות, ותוכן markdown עם ההוראות ש-Claude עוקב אחריהן כשהמיומנות רצה. שם התיקייה, או name ב-frontmatter כשמגדירים אחד, הופך לפקודה שמקלידים, ו-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 אמור להגיב עם סיכום קצר של העריכה ורשימת סיכונים.

#בחרו מאיפה skills נטענים

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

תיקיות skill גם עוקבות אחרי הכללים האלה:

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

#טעינת skills ב-monorepos ובספריות משנה

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

בסשן שרץ ב-git worktree מקושר שיצרתם עם --worktree או git worktree add, Claude Code מחפש בספריות אב רק עד שורש ה-worktree. ב-Claude Code v2.1.277 או מאוחר יותר, כשל-checkout של ה-worktree אין ספריית .claude/skills בשורש שלו, Claude Code טוען במקום זאת את ה-skills של הפרויקט מה-checkout הראשי. ראו מה worktrees חולקים עם ה-checkout הראשי.

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

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

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

#טעינת skills מספרייה מחוץ לפרויקט

כשאתם מוסיפים ספרייה עם --add-dir או /add-dir, Claude Code טוען את ה-skills ב-.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 בהפעלה, כפי שעריכת skill במהלך סשן מתאר. הוא לא עוקב אחרי .claude/commands/ או .claude/agents/ של הספרייה שנוספה, אז הפעילו מחדש את הסשן אחרי שינוי קובץ שם.

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

#הרצת skill באותו שם מספרייה שנוספה

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

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

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

#פתרון skills שחולקים שם

כששני skills חולקים שם ספרייה או קובץ, המקור של כל אחד קובע איזה מהם /name מריץ. לשם שנקבע בשדה name ב-frontmatter, ראו איך skill מקבל את שם הפקודה שלו.

#שימוש ב-skills בסשני Cowork ובענן

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

אפשר להפעיל מיומנות מסונכרנת לפי השם הקצר שלה, /<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

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

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

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

#שמות שמורים למיומנויות מסונכרנות

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 של מיומנות מסונכרנת:

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

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

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

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

#עריכת מיומנות במהלך סשן

Claude Code עוקב אחרי תיקיות מיומנויות לשינויי קבצים, חוץ ממצב bare. כשאתה מוסיף, עורך או מסיר מיומנות תחת ~/.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 כדי להיכנס לתוקף.

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

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

• מיומנות אישית או של פרויקט: מחק את תיקיית המיומנות, ~/.claude/skills/<skill-name>/ או .claude/skills/<skill-name>/. Claude Code מוריד אותה מ-/skills בסשן הנוכחי. תוכן ש-Claude Code כבר טען ממנה עוקב אחרי מחזור החיים של תוכן מיומנות.
• מיומנות ארגונית: מנהל מוחק את תיקיית המיומנות מ-.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 כדי להסתיר אותה.

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

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

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

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

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

תוכן עזר מוסיף ידע ש-Claude מיישם על העבודה הנוכחית שלך. מוסכמות, תבניות, מדריכי סגנון, ידע תחומי. התוכן הזה רץ בתוך השורה כדי ש-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

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

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

הגדר skill באמצעות YAML frontmatter בין סמני --- בראש SKILL.md, וכתוב את הוראות ה-skill כ-Markdown אחרי ה---- הסוגר. שמות השדות הם מילים באותיות קטנות המופרדות במקפים, חוץ מ-when_to_use. קובץ פקודה ב-.claude/commands/ מקבל את אותם שדות חוץ מ-name ו-paths. הדוגמה הזו מגדירה ארבעה שדות:

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

Your skill instructions here...

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

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

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

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

כשאתה מפעיל skill אישי עבור חשבון claude.ai שלך, למשל כדי להשתמש בו ב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 בלי שינויים.

#איך skill מקבל את שם הפקודה שלו

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

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

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

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

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

#תווים ששם skill לא יכול להכיל

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$ARGUMENTS

#הוספת קבצי עזר

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

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)

[!TIP]

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

#שליטה במי שמפעיל skill

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

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

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

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

---
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 בעצמכם.

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

[!NOTE]

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

#איפה כותבים את שם ה-skill

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

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

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

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

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

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

אם Claude מפסיק לעקוב אחרי skill באמצע סשן, ראו Claude מפסיק לעקוב אחרי skill.

#אישור מראש של כלים ל-skill

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

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

ה-skill הזה מאפשר ל-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 בזמן ש-skill פעיל, רשמו אותם ב-disallowed-tools ב-frontmatter של ה-skill. ההגבלה מתנקה כששולחים את ההודעה הבאה. כמו כללי deny, השדה לא יכול להסיר את EndConversation כל עוד נשאר כלי אחר. כדי לחסום כלים בכל ה-skills והפרומפטים, הוסיפו כללי deny בהגדרות ההרשאה.

#כשהגדרות מנוהלות נועלות hooks ל-plugins

כשההגדרות המנוהלות של הארגון מציינות את hooks ב-strictPluginOnlyCustomization, skill אישי או של פרויקט שה-frontmatter שלו מצהיר על hooks מאבד את האישור מראש של allowed-tools, מלבד ה-skills ששומרים אותו.

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

#כשרק כללי הרשאה מנוהלים חלים

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

הכלים ש-skill מושפע מציין עוברים דרך הכללים המנוהלים של הארגון ובקשת ההרשאה הרגילה. הריצו /status כדי לרשום כל skill ש-Claude Code התעלם מ-allowed-tools שלו עד כה בסשן. פקודה מוזרקת ב-skill שאף כלל מנוהל לא מתיר פועלת לפי בדיקות הרשאה על פקודות מוזרקות.

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

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

ה-skill הזה מתקן issue ב-GitHub לפי מספר. מציין המקום $ARGUMENTS מוחלף במה שמופיע אחרי שם ה-skill:

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

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

כדי לגשת לארגומנטים בודדים לפי מיקום, השתמשו ב-$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. אותו skill עם הקיצור $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.

#ערימת כמה skills בהודעה אחת

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

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

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

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

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

המיומנות הזו מסכמת בקשת משיכה על ידי שליפת נתוני PR חיים עם GitHub CLI. הפקודות !`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
```

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

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

[!TIP]

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

#איך פקודות מוזרקות רצות

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

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

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

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

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

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

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

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

#כשלא רצה פקודת מעטפת

No shell command in <name> was run אומר שאחת מפקודות המעטפת שלה מכילה תו שהכלי לא מקבל. כדי למצוא ולהסיר את התו, ראה את הפניה לשגיאות.

#בדיקות הרשאה על פקודות מוזרקות

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

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

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

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

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

[!NOTE]

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

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

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

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

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

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

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

[!WARNING]

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

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

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

#הגבלת הגישה של קלוד למיומנויות

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

[!NOTE]

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

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

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

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

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

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

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

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

לחלק מה-skills המצורפים יש כינויים, למשל checkup עבור /doctor. אם תגדירו רשומת skillOverrides תחת כינוי ב-הגדרות מנוהלות או בקובץ שאתם מעבירים עם הדגל --settings, Claude Code מחיל אותה על ה-skill שמאחורי הכינוי. אפשר רק להגביל skill עוד יותר דרך כינוי, אף פעם לא להפוך אותו לגלוי יותר, ואם תגדירו גם רשומה תחת השם של ה-skill עצמו בהגדרות מנוהלות, הרשומה הזו מקבלת קדימות. לפני v2.1.260, Claude Code לא החיל רשומה תחת כינוי על ה-skill באף מקור הגדרות.

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

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

#מציאת skills שאינם בשימוש

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

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

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

#הערכה ושיפור של skill

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

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

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

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

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

#הרצת evals עם 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 כדי להפוך את ה-skills של התוסף לזמינים בסשן הנוכחי. אחר כך בקשו מקלוד להעריך skill קיים, למשל evaluate my summarize-changes skill with skill-creator. התוסף מוביל אתכם בכתיבת מקרי בדיקה ומריץ את הלולאה:

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

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

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

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

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

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

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

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

צור את ספריית המיומנות:

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

שמור את זה ב-~/.claude/skills/codebase-visualizer/SKILL.md. ה-description אומר לקלוד מתי להפעיל את המיומנות הזו, וההוראות אומרות לקלוד להריץ את הסקריפט הארוז. נתיב הסקריפט משתמש ב-${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." קלוד מריץ את הסקריפט, שמדפיס את נתיב הקובץ שנוצר, למשל Generated /path/to/codebase-map.html, ופותח אותו בדפדפן. אם עובדים בסביבת headless שבה לא נפתח דפדפן, הנתיב המודפס מאשר שהסקריפט הצליח.

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

#פתרון בעיות

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

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

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

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

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

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

#מיומנות מופעלת יותר מדי

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

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

#קלוד מפסיק לעקוב אחרי מיומנות

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

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

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

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

הרץ /doctor להערכה של עלות ההקשר של הרשימה ושל התורמים הגדולים ביותר שלה. כדי למצוא מיומנויות שכדאי לכבות, הרץ /skill-doctor. כשהרשימה חורגת מהתקציב, Claude Code גם כותב אזהרה ללוג הדיבוג, שאפשר לראות עם --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.

#סוגריים זוויתיים בתיאור מיומנות מוצגים כ-< ו->

Claude Code מציג < ו-> בשדות description ו-when_to_use כ-< ו->. כדי להציג placeholder כמו <branch>, השתמש בסוגריים מרובעים או ב-argument-hint:

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

#מיומנויות אישיות נעלמו

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

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

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

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

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