תיעוד 4

הרחבת Claude Code

הבינו מתי להשתמש ב-CLAUDE.md, ב-Skills, בסוכני משנה, ב-hooks, ב-MCP ובתוספים.

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

[!NOTE]

לאופן שבו לולאת הסוכן המרכזית עובדת, ראו איך Claude Code עובד.

חדשים ב-Claude Code? התחילו ב-CLAUDE.md למוסכמות הפרויקט, ואז הוסיפו הרחבות אחרות כשעולים טריגרים ספציפיים.

#סקירה

הרחבות מתחברות לחלקים שונים של לולאת הסוכן:

CLAUDE.md מוסיף הקשר מתמיד ש-Claude רואה בכל סשן
סגנונות פלט קובעים את התפקיד, הטון ופורמט התשובה של Claude לכל תשובה בסשן
Skills מוסיפים ידע לשימוש חוזר ותהליכי עבודה שאפשר להפעיל
בינת קוד מחברת את Claude לשרת שפה לניווט ברמת סמלים ולשגיאות טיפוס בזמן אמת
MCP מחבר את Claude לשירותים ולכלים חיצוניים
סוכני משנה מריצים לולאות משלהם בהקשר מבודד, ומחזירים סיכומים
תהליכי עבודה דינמיים מריצים סוכני משנה רבים מסקריפט ש-Claude כותב, ומחזירים תוצאה אחת
הודעות בין סשנים מאפשרות ל-Claude להעביר הודעה מאחד הסשנים שלכם לאחר
Hooks מריצים את הסקריפט שלכם, בקשת HTTP, קריאה לכלי MCP, פרומפט או סוכן משנה כש-Claude Code מגיע לאירוע במחזור החיים
תוספים ו**מרקטפלייסים** אורזים ומפיצים את התכונות האלה

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

#התאם יכולות למטרה שלך

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

יכולת	מה היא עושה	מתי להשתמש בה	דוגמה
CLAUDE.md	הקשר קבוע שנטען בכל שיחה	מוסכמות פרויקט, כללי "תמיד עשה X"	"השתמש ב-`pnpm`, לא ב-`npm`. הרץ בדיקות לפני commit."
Output style	הנחיות שקובעות את התפקיד, הטון ופורמט התשובה של קלוד לשיחה שלמה	קול, אורך או פורמט שרוצים בכל תשובה, או שקלוד יעבוד כמשהו שאינו מהנדס תוכנה	סגנון Concise המובנה לתשובות קצרות יותר. סגנון מותאם שעונה על כל שאלה קודם בתרשים
Skill	הנחיות, ידע ותהליכי עבודה שקלוד יכול להשתמש בהם	תוכן לשימוש חוזר, מסמכי עזר, משימות שחוזרות על עצמן	`/deploy` מריץ את רשימת הבדיקות לפריסה. skill של תיעוד API עם דפוסי נקודות קצה
Subagent	הקשר ביצוע מבודד שמחזיר תוצאות מסוכמות	בידוד הקשר, משימות במקביל, עובדים מתמחים	משימת מחקר שקוראת קבצים רבים אבל מחזירה רק ממצאים מרכזיים
Dynamic workflow	סקריפט שקלוד כותב ומריץ subagents רבים ברקע	עבודה שגדלה מעבר לקומץ subagents, או ממצאים שרוצים לאמת זה מול זה	ביקורת על כל בסיס הקוד, עם קבוצה שנייה של סוכנים שמאמתת כל ממצא
Cross-session messaging	קלוד מעביר הודעה מאחת השיחות שלך לאחרת	שיחות שאתה מריץ בעצמך וצריכות את הממצאים זו של זו באמצע המשימה	שיחה אחת מזהירה אחרת ששינוי שהיא עשתה שובר את מה שהאחרת בונה עליו
Code intelligence	ניווט ואבחון של language server	שפות עם טיפוסים, בסיסי קוד גדולים שבהם `grep` איטי או לא מדויק	קפיצה להגדרה של סמל במקום לקרוא את כל הקובץ
MCP	חיבור לשירותים חיצוניים	נתונים או פעולות חיצוניים	שאילתה למסד הנתונים, פרסום ב-Slack, שליטה בדפדפן
Hook	סקריפט, בקשת HTTP, קריאת כלי MCP, פרומפט, או subagent שמופעלים על ידי אירועים	אוטומציה שחייבת לרוץ בכל אירוע תואם	הרצת ESLint אחרי כל עריכת קובץ
Artifact	פרסום פלט השיחה כדף אינטרנט פרטי ואינטראקטיבי	פלט שרוצים לראות או לשתף באופן חזותי ולא כטקסט במסוף	ציר זמן של אירוע שמתעדכן בזמן שקלוד חוקר

Plugins הם שכבת האריזה. פלאגין אורז skills, hooks, subagents ושרתי MCP ליחידה אחת שניתן להתקין. ל-skills של פלאגין יש namespace (כמו /my-plugin:review) כדי שכמה פלאגינים יוכלו להתקיים יחד. השתמש בפלאגינים כשרוצים לעשות שימוש חוזר באותה הגדרה בכמה מאגרים, או להפיץ לאחרים דרך marketplace.

#בנה את ההגדרה לאורך זמן

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

טריגר	הוסף
קלוד טועה במוסכמה או בפקודה פעמיים	הוסף אותה ל-CLAUDE.md
אתה ממשיך לבקש מקלוד להיות קצר יותר, להסביר יותר, או לענות באותו פורמט	הגדר output style
אתה ממשיך להקליד את אותו פרומפט כדי להתחיל משימה	שמור אותו כ-skill להפעלה על ידי המשתמש
אתה מדביק את אותו playbook או הליך מרובה שלבים לצ'אט בפעם השלישית	תעד אותו כ-skill
אתה ממשיך להעתיק נתונים מלשונית דפדפן שקלוד לא רואה	חבר את המערכת הזו כ-שרת MCP
קלוד קורא קבצים רבים כדי למצוא איפה סמל מוגדר או נמצא בשימוש	התקן פלאגין code intelligence לשפה שלך
משימת צד מציפה את השיחה בפלט שלא תחזור להתייחס אליו	נתב אותה דרך subagent
אתה רוצה שמשהו יקרה בכל פעם בלי לבקש	כתוב hook
מאגר שני צריך את אותה הגדרה	ארוז אותה כ-plugin

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

#השווה יכולות דומות

חלק מהיכולות יכולות להיראות דומות. להסבר מעמיק יותר על הבחירה ביניהן, ראה Steering Claude Code: when to use CLAUDE.md, skills, hooks, and subagents בבלוג. כך מבדילים ביניהן.

#Skill מול Subagent

Skills ו-subagents פותרים בעיות שונות:

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

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

Skills יכולים להיות עזר או פעולה. skills של עזר מספקים ידע שקלוד משתמש בו לאורך השיחה (כמו מדריך הסגנון של ה-API). skills של פעולה אומרים לקלוד לעשות משהו מסוים (כמו /deploy שמריץ את תהליך הפריסה).

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

אפשר לשלב אותם. subagent יכול לטעון מראש skills מסוימים (שדה skills:). skill יכול לרוץ בהקשר מבודד באמצעות context: fork. ראה Skills לפרטים.

#CLAUDE.md מול Skill

שניהם שומרים הנחיות, אבל הם נטענים אחרת ומשרתים מטרות שונות.

היבט	CLAUDE.md	Skill
נטען	בכל שיחה, אוטומטית	לפי דרישה
יכול לכלול קבצים	כן, עם ייבוא `@path`	כן, עם ייבוא `@path`
יכול להפעיל תהליכי עבודה	לא	כן, עם `/<name>`
מתאים ל	כללי "תמיד עשה X"	חומר עזר, תהליכי עבודה שניתן להפעיל

שים את זה ב-CLAUDE.md אם קלוד צריך תמיד לדעת את זה: מוסכמות קוד, פקודות בנייה, מבנה הפרויקט, כללי "לעולם אל תעשה X".

שים את זה ב-skill אם זה חומר עזר שקלוד צריך לפעמים (תיעוד API, מדריכי סגנון) או תהליך עבודה שמפעילים עם /<name> (deploy, review, release).

כלל אצבע: שמור את CLAUDE.md מתחת ל-200 שורות. אם הוא גדל, העבר תוכן עזר ל-skills או פצל לקבצי .claude/rules/.

#CLAUDE.md מול Output style

שניהם נותנים לקלוד הנחיות קבועות. CLAUDE.md נושא את מה שקלוד צריך לדעת, ו-output style קובע איך קלוד עונה.

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

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

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

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

#CLAUDE.md מול Rules מול Skills

שלושתם שומרים הנחיות, אבל הם נטענים אחרת:

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

השתמש ב-CLAUDE.md להנחיות שכל שיחה צריכה: פקודות בנייה, מוסכמות בדיקות, ארכיטקטורת הפרויקט.

השתמש ב-rules כדי לשמור את CLAUDE.md ממוקד. rules עם frontmatter של paths נטענים רק כשקלוד עובד עם קבצים תואמים, וכך חוסכים הקשר.

השתמש ב-skills לתוכן שקלוד צריך רק לפעמים, כמו תיעוד API או רשימת בדיקות פריסה שמפעילים עם /<name>.

#Subagent מול Dynamic workflow

שניהם עושים עבודה מחוץ לשיחה הראשית. עם subagents, קלוד מחליט תור אחר תור מה רץ אחר כך. ב-workflow, הסקריפט מחליט:

Subagents הם עובדים שקלוד מפעיל, וכל אחד מחזיר סיכום לשיחה שהפעילה אותו
Dynamic workflows הם סקריפטים שקלוד כותב, שמריצים subagents רבים ברקע ומחזירים תוצאה אחת

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

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

כדי להעביר ממצא מאחת השיחות שלך לאחרת, בקש מהקלוד של השיחה הראשונה לשלוח אותו. קלוד מעביר אותו באמצעות cross-session messaging. Run agents in parallel משווה דרכים אחרות להריץ יותר מקלוד אחד בו זמנית, כולל שיחות שמוסרים ובודקים שוב מאוחר יותר.

#MCP מול Skill

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

היבט	MCP	Skill
מה זה	פרוטוקול לחיבור לשירותים חיצוניים	ידע, תהליכי עבודה וחומר עזר
מספק	כלים וגישה לנתונים	ידע, תהליכי עבודה, חומר עזר
דוגמאות	אינטגרציה עם Slack, שאילתות למסד נתונים, שליטה בדפדפן	רשימת בדיקות לסקירת קוד, תהליך deploy, מדריך סגנון API

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

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

Skills נותנים לקלוד ידע על איך להשתמש בכלים האלה ביעילות, וגם תהליכי עבודה שאפשר להפעיל עם /<name>. skill יכול לכלול את סכמת מסד הנתונים ודפוסי השאילתות של הצוות, או תהליך /post-to-slack עם כללי עיצוב ההודעות של הצוות.

#Hook מול Skill

Claude Code מריץ hook באירוע מחזור חיים. הוא טוען skill להקשר כדי שקלוד ייישם אותו.

היבט	Hook	Skill
רץ	פקודת shell, בקשת HTTP, קריאת כלי MCP, פרומפט LLM, או subagent	הנחיות שקלוד קורא ופועל לפיהן
מופעל על ידי	אירועי מחזור חיים כמו `PostToolUse` או `SessionStart`	הקלדה של `/<name>`, או התאמה של קלוד בין התיאור למשימה
דטרמיניזם	מופעל באירוע שלו בלי שקלוד מחליט	קלוד מפרש את ההנחיות. התוצאה יכולה להשתנות
עלות הקשר	אפס אלא אם ה-hook מחזיר פלט	התיאור נטען בכל שיחה. התוכן המלא נטען כשמשתמשים
מתאים ל	lint אחרי עריכות, חסימת פקודות לא בטוחות, לוגים, התראות	תהליכי עבודה שצריכים שיקול דעת, חומר עזר, משימות מרובות שלבים

השתמש ב-hook כשהפעולה חייבת לקרות באותו אופן בכל פעם ואין צורך שקלוד יחשוב. לדוגמה: עיצוב בשמירה, דחיית rm -rf /, שליחת הודעת Slack כששיחה מסתיימת.

השתמש ב-skill כשקלוד צריך להחליט איך ליישם את השלבים, או כשהתוכן הוא ידע ולא סקריפט. לדוגמה: רשימת בדיקות /release, מדריך הסגנון של ה-API, playbook לניפוי שגיאות.

שים מעקות בטיחות ב-hooks. הנחיה כמו "לעולם אל תערוך את .env" ב-CLAUDE.md או ב-skill היא בקשה, לא ערובה. hook מסוג PreToolUse שחוסם את העריכה הוא אכיפה. אם כלל חייב להתקיים בכל פעם, הפוך אותו ל-hook ולא להנחיית פרומפט.

פלט של hook מגיע להקשר. hook מסוג PostToolUse שמריץ את ה-linter מחזיר תוצאות כטקסט שקלוד קורא. skill בשם /fix-lint אומר לקלוד איך לפתור אותן.

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

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

קבצי CLAUDE.md הם מצטברים: כל הרמות תורמות תוכן להקשר של קלוד בו זמנית. קבצים מתיקיית העבודה ומעליה נטענים בהפעלה. תת תיקיות נטענות כשעובדים בהן. כשהנחיות סותרות, קלוד משתמש בשיקול דעת כדי ליישב ביניהן. ראה איך קבצי CLAUDE.md נטענים.
Skills ו-subagents דורסים לפי שם: כשאותו שם קיים בכמה רמות, הגדרה אחת מנצחת לפי עדיפות (managed > user > project ל-skills. managed > CLI flag > project > user > plugin ל-subagents). ל-skills של פלאגין יש namespace כדי למנוע התנגשויות. ראה גילוי skills והיקף subagent.
שרתי MCP דורסים לפי שם: local > project > user. ראה היקף MCP.
Hooks מתמזגים: כל ה-hooks הרשומים מופעלים לאירועים התואמים שלהם, בלי קשר למקור. ראה hooks.

#שלב יכולות

כל הרחבה פותרת בעיה אחרת: CLAUDE.md מטפל בהקשר שפועל תמיד, skills מטפלים בידע ובתהליכי עבודה לפי דרישה, MCP מטפל בחיבורים חיצוניים, subagents מטפלים בבידוד, ו-hooks מטפלים באוטומציה. הגדרות אמיתיות משלבות אותם לפי תהליך העבודה.

לדוגמה, אפשר להשתמש ב-CLAUDE.md למוסכמות הפרויקט, ב-skill לתהליך הפריסה, ב-MCP לחיבור למסד הנתונים, וב-hook להרצת lint אחרי כל עריכה. כל יכולת מטפלת במה שהיא הכי טובה בו.

תבנית	איך זה עובד	דוגמה
Skill + MCP	MCP מספק את החיבור. skill מלמד את קלוד איך להשתמש בו היטב	MCP מתחבר למסד הנתונים, skill מתעד את הסכמה ואת דפוסי השאילתות
Skill + Subagent	skill מפעיל subagents לעבודה במקביל	skill בשם `/audit` מפעיל subagents של אבטחה, ביצועים וסגנון שעובדים בהקשר מבודד
CLAUDE.md + Skills	CLAUDE.md מחזיק כללים שפועלים תמיד. skills מחזיקים חומר עזר שנטען לפי דרישה	CLAUDE.md אומר "עקוב אחרי מוסכמות ה-API שלנו", skill מכיל את מדריך הסגנון המלא של ה-API
Hook + MCP	hook מפעיל פעולות חיצוניות דרך MCP	hook שאחרי עריכה שולח התראת Slack כשקלוד משנה קבצים קריטיים

#להבין עלויות הקשר

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

#עלות הקשר לפי יכולת

לכל יכולת יש אסטרטגיית טעינה ועלות הקשר שונות:

יכולת	מתי זה נטען	מה נטען	עלות הקשר
CLAUDE.md	תחילת הסשן	התוכן המלא של כל קובץ שנטען בתחילת הסשן	בכל בקשה
סגנונות פלט	תחילת הסשן, ושוב כשאתם מחליפים סגנון	ההוראות המלאות של הסגנון הפעיל. כלום עבור סגנון Default	בכל בקשה
מיומנויות	תחילת הסשן + כשנעשה שימוש	תיאורים בהתחלה, התוכן המלא כשנעשה שימוש	נמוכה (תיאורים בכל בקשה)*
שרתי MCP	תחילת הסשן	שמות כלים. סכמות מלאות לפי דרישה	נמוכה עד שנעשה שימוש בכלי
בינת קוד	אחרי עריכות קבצים ולפי דרישה	אבחון אחרי עריכות. מיקומי סמלים בחיפוש	נמוכה. מפחיתה קריאות קבצים במקומות אחרים
סוכני משנה	כשנוצרים	הקשר חדש עם המיומנויות שצוינו, או שיחת ההורה עבור fork	מבודד מהסשן הראשי
Hooks	בהפעלה	כלום (רץ חיצונית)	אפס, אלא אם ה-hook מחזיר הקשר נוסף

*הגדירו disable-model-invocation: true ב-frontmatter של מיומנות כדי להשאיר את התיאור שלה מחוץ להקשר של Claude. עבור מיומנות שלא כתבתם, הגדירו skillOverrides בהגדרות כדי לעשות את אותו הדבר בלי לערוך את הקובץ שלה.

#להבין איך יכולות נטענות

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

#CLAUDE.md

מתי: תחילת הסשן

מה נטען: התוכן המלא של כל קובץ CLAUDE.md שנטען בתחילת הסשן (רמות managed, user ו-project).

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

טיפ

שמרו על CLAUDE.md מתחת ל-200 שורות. העבירו חומר עזר למיומנויות, שנטענות לפי דרישה. כדי לקבל הצעות קיצוץ ל-CLAUDE.md שנשמר במאגר, הריצו /doctor.

#מיומנויות

מיומנויות הן יכולות נוספות בערכת הכלים של Claude. הן יכולות להיות חומר עזר (כמו מדריך סגנון ל-API) או תהליכי עבודה להפעלה שאתם מפעילים עם /<name> (כמו /deploy). Claude Code כולל מיומנויות כלולות כמו /code-review, /batch ו-/debug שעובדות בלי הגדרה. אתם יכולים גם ליצור משלכם.

מתי: תלוי בהגדרת המיומנות. כברירת מחדל, תיאורים נטענים בתחילת הסשן והתוכן המלא נטען כשנעשה שימוש. עבור מיומנויות למשתמש בלבד (disable-model-invocation: true), שום דבר לא נטען עד שאתם מפעילים אותן.

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

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

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

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

טיפ

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

#שרתי MCP

מתי: תחילת הסשן.

מה נטען: שמות כלים והוראות שרת משרתים מחוברים. סכמות JSON מלאות נשארות דחויות עד ש-Claude צריך כלי מסוים.

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

טיפ

הריצו /mcp כדי לראות את מצב החיבור של כל שרת. הריצו /context all כדי לראות כמה טוקנים כל כלי MCP שנטען משתמש. Claude Code מתחבר מחדש לשרתים מרוחקים אוטומטית אם הם מתנתקים, ואתם יכולים לנתק שרתים שאתם לא משתמשים בהם באופן פעיל.

#בינת קוד

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

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

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

טיפ

כלי ה-LSP לא פעיל עד שאתם מתקינים תוסף בינת קוד לשפה שלכם.

#סוכני משנה

מתי: לפי דרישה, כשאתם או Claude יוצרים אחד למשימה.

מה נטען: הקשר חדש ומבודד שמכיל:

הנחיית המערכת של הסוכן עצמו, לא הנחיית המערכת של Claude Code
התוכן המלא של מיומנויות שרשומות בשדה skills: של הסוכן
CLAUDE.md וסטטוס git. סוכני Explore ו-Plan המובנים מתחילים בלי אף אחד מהם, וסוכן שההגדרה שלו מגדירה omitClaudeMd מתחיל בלי קבצי CLAUDE.md של המשתמש, הפרויקט והמקומי.
כל הקשר שסוכן ההובלה מעביר בהנחיה

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

עלות הקשר: מבודד מהסשן הראשי.

טיפ

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

#Hooks

מתי: בהפעלה. Claude Code מריץ hooks באירועי מחזור חיים מסוימים כמו ביצוע כלים, גבולות סשן, שליחת הנחיה, בקשות הרשאה ו-compaction. ראו Hooks לרשימה המלאה.

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

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