לדלג לתוכן

6.5 מיומנויות ופקודות מותאמות הרצאה

כשעובדים עם agent לאורך זמן, מגלים שיש זרימות עבודה שחוזרות על עצמן. בכל פעם שרוצים לפרוס, מדביקים לagent את אותה רשימת שלבים. בכל פעם שכותבים endpoint חדש, מזכירים את אותן מוסכמות. זה בזבזני ולא עקבי - לפעמים שוכחים שלב, לפעמים מנסחים אחרת. בהרצאה הזו נכיר את הtool שפותר את זה: מיומנויות - skills, ופקודות מותאמות - custom commands. הskill היא אריזה של זרימת עבודה או ידע לשימוש חוזר, שהagent מפעיל בעקביות. נבין את מבנה הקובץ, איך skill מתגלה ומופעלת, ואיך היא שונה מsub-agent ומ-CLAUDE.md.

מהי skill - what is a skill

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

מתי כדאי ליצור skill? כשאתם מוצאים את עצמכם מדביקים שוב ושוב את אותן הוראות, רשימת בדיקה או תהליך רב-שלבי. או כשקטע ב-CLAUDE.md גדל מ"עובדה" ל"תהליך". היתרון המרכזי על פני CLAUDE.md: תוכן הskill נטען רק כשמשתמשים בו. חומר עזר ארוך כמעט לא עולה בcontext עד הרגע שבו הוא נחוץ.

מבנה הקובץ - SKILL.md

כל skill היא תיקייה עם קובץ SKILL.md בתוכה. שם התיקייה הוא הפקודה שתקלידו. הקובץ בנוי משני חלקים: כותרת YAML בין קווי --- שאומרת ל-Claude מתי להשתמש בskill, ותוכן Markdown עם ההוראות עצמן.

הנה דוגמה מלאה. נניח שאנחנו רוצים skill שמסכמת שינויים לא-מקומיטים ומדגישה סיכונים. שומרים אותה ב-~/.claude/skills/summarize-changes/SKILL.md:

---
description: summarizes uncommitted changes and highlights risks. Use when the user asks what changed, wants a commit message, or asks to review the diff.
---

## Current changes

!`git diff HEAD`

## Instructions

Summarize the changes above in two or three bullet points, then list every risk you notice:
missing error handling, hardcoded values, or tests that need updating. If the diff is empty,
say there are no uncommitted changes.

שימו לב לשורה !`git diff HEAD`. זו תכונה חזקה שנרחיב עליה - הזרקת context דינמי. אבל קודם, מיקום הקבצים.

איפה skills חיות - where skills live

בדומה לsub-agents, המיקום קובע את הטווח:

מיקום נתיב חל על
אישי - personal ~/.claude/skills/<name>/SKILL.md כל הפרויקטים שלכם
פרויקט - project .claude/skills/<name>/SKILL.md הפרויקט הזה בלבד
תוסף - plugin <plugin>/skills/<name>/SKILL.md היכן שהתוסף מופעל

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

שדות הכותרת - frontmatter

כל השדות אופציונליים, אבל description מומלץ מאוד כדי ש-Claude ידע מתי להשתמש בskill. הנה השדות החשובים:

---
name: my-skill
description: what the skill does and when to use it
disable-model-invocation: true
allowed-tools: Bash(git add *) Bash(git commit *)
---
  • description: מה הskill עושה ומתי. זה מה ש-Claude קורא כדי להחליט אם לטעון אותה אוטומטית. שימו את מקרה השימוש העיקרי ראשון.
  • disable-model-invocation: אם true, רק אתם יכולים להפעיל את הskill (עם /name), ו-Claude לא יטען אותה לבד. שימושי לזרימות עם תופעות לוואי כמו /deploy או /commit - לא רוצים ש-Claude יחליט לפרוס כי הקוד "נראה מוכן".
  • allowed-tools: tools ש-Claude יכול להשתמש בהם בלי לבקש אישור כשהskill פעילה. זה לא מגביל אילו tools זמינים, אלא מאשר מראש את אלה שברשימה.

שני סוגי תוכן - content types

כדאי לחשוב על skill באחד משני אופנים:

  • תוכן ידע - reference: מוסיף ידע ש-Claude מיישם על העבודה הנוכחית. מוסכמות, סגנון, ידע תחום. זה רץ בתוך השיחה כדי שהמודל ישתמש בו לצד הcontext.
    ---
name: api-conventions
description: API design conventions in this codebase
---

When writing endpoints:
- Use RESTful conventions
- Return a consistent error format
- Include request validation
  • תוכן משימה - task: נותן ל-Claude שלבים לפעולה ספציפית, כמו פריסה או commit. אלה בדרך כלל דברים שתרצו להפעיל ישירות עם /name.

פקודות מותאמות - custom commands

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

לכן, מי שראה בעבר "custom commands" - זה אותו רעיון, וההמלצה היום היא להשתמש במבנה של skill.

העברת ארגומנטים - arguments

הskill יכולה לקבל ארגומנטים דרך ה-placeholder $ARGUMENTS. הנה skill שמתקנת issue לפי מספר:

---
name: fix-issue
description: fix an issue on GitHub
disable-model-invocation: true
---

Fix issue number $ARGUMENTS on GitHub according to our code standards.

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

כשמריצים /fix-issue 123, ה-placeholder מוחלף ב-123. אפשר גם לגשת לארגומנטים לפי מיקום עם $ARGUMENTS[0] או הקיצור $0, $1 וכן הלאה.

הזרקת context דינמי - dynamic context

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

---
name: pr-summary
description: summarize changes in a pull request
allowed-tools: Bash(gh *)
---

## PR context
- diff: !`gh pr diff`
- comments: !`gh pr view --comments`
- changed files: !`gh pr diff --name-only`

## Your task
Summarize the pull request...

כשהskill רצה, כל !`...` מורץ מיד, הפלט מוחלף במקום ה-placeholder, ו-Claude מקבל פרומפט מלא עם נתוני ה-PR האמיתיים. זו הכנה מקדימה, לא משהו ש-Claude מריץ. הוא רואה רק את התוצאה הסופית.

קבצי עזר - supporting files

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

my-skill/
├── SKILL.md          # main instructions (required)
├── reference.md      # detailed documentation - loaded when needed
└── scripts/
    └── helper.py     # a script to run, not to load

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

מחזור החיים של התוכן - content lifecycle

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

לכן, כתבו הוראות שאמורות לחול לאורך המשימה כהנחיות עומדות, לא כשלב חד-פעמי. אם הskill אומרת "עצב את הקוד ככה", זה יחול על כל הקוד מכאן והלאה. שימו לב גם לעלות: כל שורה בskill היא עלות context חוזרת, אז שמרו על הגוף תמציתי. אמרו מה לעשות, לא הרצאה על למה.

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

בקרת מי מפעיל - who invokes

ראינו את disable-model-invocation, אבל כדאי לראות את התמונה המלאה. שני שדות שולטים במי יכול להפעיל skill:

כותרת אתם מפעילים Claude מפעיל מתי נטען לcontext
(ברירת מחדל) כן כן התיאור תמיד בcontext, התוכן בהפעלה
disable-model-invocation: true כן לא התיאור לא בcontext, התוכן בהפעלה שלכם
user-invocable: false לא כן התיאור תמיד בcontext

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

skills מובנות - bundled skills

Claude Code מגיע עם skills מובנות שזמינות בכל סשן. כמה שכדאי להכיר:

/doctor        - checks the health of your settings
/code-review   - reviews the code of the changes
/debug         - helps debug issues
/run           - runs the app to see a change working
/verify        - builds and runs to verify the change does what it should

אלה skills מבוססות-פרומפט: הן נותנות ל-Claude הוראות מפורטות ומתזמרות את העבודה עם הtools שלו. skill שלכם עם אותו שם דורסת מובנית - למשל code-review ב-.claude/skills/ שלכם מחליף את המובנה. זו דרך נוחה להתאים התנהגות מובנית לצוות שלכם.

skill מול sub-agent - skill vs subagent

חשוב לא להתבלבל בין השניים. הskill רצה כברירת מחדל בתוך השיחה הראשית - התוכן שלה נכנס לcontext ומשפיע על הagent הנוכחי. הsub-agent, לעומת זאת, רץ בcontext מבודד ומחזיר סיכום.

הכלל: השתמשו בskill כשאתם רוצים פרומפט או זרימה לשימוש חוזר שתרוץ בcontext הנוכחי. השתמשו בsub-agent כשאתם רוצים לבודד עבודה רועשת. אגב, אפשר לשלב: skill עם context: fork בכותרת תרוץ דווקא בsub-agent מבודד.

סיכום

בהרצאה הזו למדנו:

  • מיומנות - skill היא אריזה של זרימת עבודה או ידע לשימוש חוזר, בקובץ SKILL.md. היתרון על CLAUDE.md: התוכן נטען רק כשמשתמשים בו, כך שחומר עזר ארוך כמעט לא עולה בcontext.
  • כל skill היא תיקייה עם SKILL.md. שם התיקייה הוא הפקודה. המבנה: כותרת YAML (מתי להשתמש) ותוכן Markdown (ההוראות).
  • מיקום קובע טווח: ~/.claude/skills/ (אישי), .claude/skills/ (פרויקט, נכנס ל-git). אישי גובר על פרויקט.
  • שדות מרכזיים: description (מתי להשתמש), disable-model-invocation: true (רק אתם מפעילים, לזרימות עם תופעות לוואי), ו-allowed-tools (אישור מראש לtools).
  • פקודות מותאמות מוזגו לskills: קובץ ב-.claude/commands/deploy.md וב-.claude/skills/deploy/SKILL.md שניהם יוצרים /deploy.
  • ארגומנטים מועברים דרך $ARGUMENTS (או $0, $1 לפי מיקום). הזרקת context דינמי עם !`<command>` מריצה פקודה מראש ומזריקה את הפלט לפרומפט.
  • אפשר לצרף קבצי עזר (תבניות, סקריפטים) לתיקיית הskill; שמרו את SKILL.md ממוקד.
  • הבחנה מsub-agent: הskill רצה בcontext הראשי ומשפיעה עליו; הsub-agent רץ מבודד ומחזיר סיכום.