4.2 פקודות סלאש הרצאה

אחת התכונות שהופכות את Claude Code מכלי צ'אט לסביבת עבודה אמיתית היא פקודות הסלאש - slash commands. אלה פקודות שמתחילות בתו / ומאפשרות לכם לשלוט בסשן, לנהל את הcontext, ולהפעיל זרימות עבודה שלמות במילה אחת. בהרצאה הקודמת כבר פגשנו כמה מהן (/clear, /compact, /context, /cost). בהרצאה הזו נכיר את הפקודות המובנות שכדאי לדעת, ואז נלמד את החלק החזק באמת: איך כותבים פקודת סלאש משלכם - פרומפט לשימוש חוזר ששמור כקובץ. זה בדיוק ההבדל בין מי שמקליד את אותן הוראות שוב ושוב לבין מי שבנה לעצמו tools.

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

פקודות מובנות שכדאי להכיר - built-in commands¶

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

ניהול context וסשן:

/clear              starts a new conversation with an empty context
/compact [prompt]   compresses the conversation into a summary to free up context
/context [all]      visually shows context window utilization
/rewind             reverts the conversation and/or code to an earlier point
/resume [session]   continues a previous conversation by ID or name
/export [filename]  exports the current conversation as text

מידע ועלויות:

/cost               alias for /usage - shows token usage and cost
/usage              detailed usage statistics for the session
/help               help and list of commands
/tasks              shows what's running in the background in the current session
/recap              generates a one-line summary of the current session

הגדרות ותצורה:

/model [model]      switches models and saves it as the default
/config             opens settings (theme, model, preferences)
/init               generates a CLAUDE.md file for the project
/memory             edit CLAUDE.md files
/agents             create and manage sub-agents
/mcp                manage MCP server connections
/add-dir <path>     adds a working directory to the current session

פקודות שימושיות נוספות:

/btw <question>     a quick side question without adding to the conversation history
/review [PR]        a quick review of a pull request on GitHub
/doctor             checks the health of the installation and settings

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

מה זו פקודה מותאמת אישית - custom commands¶

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

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

איפה שומרים - where they live¶

המיקום של הקובץ קובע מי יכול להשתמש בו:

Personal (all projects):   ~/.claude/skills/<name>/SKILL.md
Project (this project):    .claude/skills/<name>/SKILL.md

שם התיקייה הופך לפקודה שמקלידים. תיקייה בשם deploy-staging יוצרת את הפקודה /deploy-staging. הצורה הישנה, קובץ בודד ב-.claude/commands/deploy.md, יוצרת /deploy לפי שם הקובץ.

מבנה הקובץ - the SKILL.md format¶

לכל סקיל יש קובץ SKILL.md עם שני חלקים: כותרת YAML בין שני קווי --- (frontmatter) שאומרת ל-Claude מתי להשתמש בסקיל, ואחריה תוכן markdown עם ההוראות. הנה השדות המרכזיים ב-frontmatter, מאומתים מול התיעוד:

description                 what the skill does and when to use it (recommended)
name                        display name (default: folder name)
allowed-tools               tools Claude can use without asking for approval
disable-model-invocation    true = only you invoke it, not Claude automatically
argument-hint                hint for arguments in autocomplete
model                       model to use while the skill is active
context: fork               runs in a separate context of a sub-agent

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

$ARGUMENTS       all the arguments that were passed
$ARGUMENTS[0]    argument by index (starts from 0)
$0, $1           shorthand for $ARGUMENTS[0], $ARGUMENTS[1]

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

## Current changes

!`git diff HEAD`

השורה הזו מורצת מראש, ו-Claude רואה את ה-diff האמיתי במקום את הפקודה. זו הדרך לבנות פקודות ש"יודעות" מה קורה כרגע בפרויקט.

דוגמה מלאה - a real custom command¶

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

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

ונשמור את הקובץ הבא ב-~/.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 כשה-diff הנוכחי כבר משובץ בתוכן. עכשיו יש שתי דרכים להפעיל את הפקודה. אפשר להקליד אותה ישירות:

/summarize-changes

ואפשר פשוט לשאול משהו שתואם ל-description, ו-Claude יטען את הסקיל אוטומטית:

What did I change?

בשני המקרים Claude יחזיר סיכום קצר של השינויים ורשימת סיכונים.

דוגמה עם ארגומנטים - passing arguments¶

נבנה עוד פקודה, הפעם כזו שמקבלת ארגומנט. פקודה שמתקנת issue מ-GitHub לפי מספר. נשמור ב-.claude/skills/fix-issue/SKILL.md (שימו לב: הפעם ברמת הפרויקט, כי זה ספציפי לפרויקט):

---
description: Fix a GitHub issue by number
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, המציין $ARGUMENTS מוחלף ב-123, ו-Claude מקבל "Fix GitHub issue 123 following our coding standards...". השדה disable-model-invocation: true חשוב כאן: הוא מונע מ-Claude להחליט לבד להריץ את הפקודה. לזרימות עבודה עם תופעות לוואי - פריסה, שליחת הודעות, קומיטים - זה בדיוק מה שרוצים. אתם לא רוצים ש-Claude יחליט לפרוס לפרודקשן רק כי הקוד נראה מוכן.

שליטה במי מפעיל - who invokes¶

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

disable-model-invocation: true: רק אתם מפעילים, ידנית עם /name. מתאים לפעולות עם תופעות לוואי כמו /commit או /deploy.
user-invocable: false: רק Claude מפעיל, אוטומטית. מתאים לידע רקע שלא הגיוני שהמשתמש יפעיל ישירות, למשל סקיל שמסביר איך מערכת ישנה עובדת.

ברירת המחדל היא ששניכם יכולים להפעיל. עוד יתרון של הצורה הידנית: כשמסמנים disable-model-invocation: true, ה-description לא נטען לcontext עד שאתם מפעילים את הסקיל - מה שחוסך context, בדיוק בקו של מה שלמדנו בהרצאה הקודמת.

הזרקת context מרובת שורות - multi-line injection¶

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

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

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

סקילים מקוננים ותוספים - nested and plugins¶

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

השנייה: תוספים - plugins. תוסף יכול לארוז ולהפיץ אוסף שלם של סקילים, יחד עם agents והוקים. סקילים של תוסף מקבלים namespace בצורת plugin-name:skill-name, כך שהם לא מתנגשים עם שמות אחרים. זו הדרך לחלק ולהפיץ פקודות בין צוותים. את התוספים מנהלים עם הפקודה /plugin.

עוד שדה שימושי בזמן פיתוח סקיל: argument-hint, שמציג רמז לארגומנטים בהשלמה האוטומטית, למשל [issue-number] או [filename] [format]. זה הופך פקודה מותאמת אישית לידידותית לשימוש - מי שמקליד /fix-issue רואה מיד שהיא מצפה למספר issue.

פרו-טיפ - allowed-tools¶

עוד שדה שימושי הוא allowed-tools, שנותן ל-Claude להשתמש בtools מסוימים בלי לבקש אישור בכל פעם, כל עוד הסקיל פעיל. למשל, פקודת commit שמריצה 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 *)
---

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

סקילים מובנים - bundled skills¶

מלבד הפקודות המובנות "הרגילות", ל-Claude Code יש גם סקילים מובנים (bundled skills). ההבדל: פקודות מובנות מריצות לוגיקה קבועה, ואילו סקילים מובנים מבוססי-פרומפט - הם נותנים ל-Claude הוראות מפורטות ונותנים לו לתזמר את העבודה עם הtools שלו. מפעילים אותם בדיוק כמו כל סקיל, עם / ואז השם. כמה שכדאי להכיר:

/code-review    code review of the changes
/run            launches and runs the application to see a change work
/verify         builds and runs to confirm a change does what's needed
/debug          assistance with systematic debugging
/doctor         checks the health of the installation and settings

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

ערבוב סקילים ותקציב תיאורים - stacking and budget¶

שני פרטים מתקדמים ששווה להכיר. הראשון: אפשר לערום כמה סקילים בתחילת הודעה אחת. הקלדה של /code-review /fix-issue 123 טוענת את שני הסקילים ומעבירה את הטקסט 123 כארגומנט לשניהם. זה מאפשר לשרשר זרימות עבודה במכה אחת.

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

סיכום¶

פקודות סלאש מתחילות ב-/ ושולטות בסשן. תפריט / מציג הכל: פקודות מובנות, סקילים ותוספים.
פקודות מובנות מרכזיות: /clear, /compact, /context, /rewind, /resume, /cost, /model, /config, /init, /memory, /agents, /mcp, /review, /doctor, ו-/btw לשאלת צד בלי לזהם context.
פקודות מותאמות אישית מוזגו לסקילים. שומרים קובץ SKILL.md ב-~/.claude/skills/<שם>/ (אישי) או .claude/skills/<שם>/ (פרויקט); שם התיקייה הופך לפקודה. הצורה הישנה .claude/commands/<שם>.md עדיין עובדת.
הקובץ בנוי מ-frontmatter (description, allowed-tools, disable-model-invocation, ועוד) ותוכן markdown. ארגומנטים דרך $ARGUMENTS, $0, $1; הזרקת context דינמי דרך !`command`.
דוגמה מעשית: /summarize-changes מזריקה git diff HEAD ומבקשת סיכום וסימון סיכונים; /fix-issue 123 מעבירה ארגומנט.
disable-model-invocation לפעולות עם תופעות לוואי, user-invocable: false לידע רקע, ו-allowed-tools למניעת בקשות אישור חוזרות.