📘 תיעוד 4

הרחבת Claude Code

להבין מתי להשתמש ב-CLAUDE.md, ב-Skills, ב-subagents, ב-hooks, ב-MCP וב-plugins.

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

הערה: לגבי אופן הפעולה של לולאת הסוכן הבסיסית, ראה כיצד Claude Code עובד.

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

#סקירה כללית

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

• CLAUDE.md מוסיף הקשר קבוע ש-Claude רואה בכל הפעלה
• Skills מוסיפים ידע לשימוש חוזר ותהליכי עבודה שניתן להפעיל
• Code intelligence מחבר את Claude לשרת שפה לצורך ניווט ברמת הסמלים ושגיאות טיפוסים בזמן אמת
• MCP מחבר את Claude לשירותים ולכלים חיצוניים
• Subagents מריצים לולאות משלהם בהקשר מבודד, ומחזירים סיכומים
• Dynamic workflows מריצים תתי סוכנים רבים מתוך סקריפט ש-Claude כותב, ומחזירים תוצאה אחת
• Cross-session messaging מאפשר ל-Claude להעביר הודעה מאחת ההפעלות שלך לאחרת
• Hooks מריצים את הסקריפט שלך, בקשת HTTP, קריאת כלי MCP, פרומפט, או תת סוכן כאשר Claude Code מגיע לאירוע במחזור החיים
• Plugins ו-marketplaces אורזים ומפיצים את היכולות הללו

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

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

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

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

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

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

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

#השוואה בין יכולות דומות

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

#Skill לעומת Subagent

מיומנויות ותתי סוכנים פותרים בעיות שונות:

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

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

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

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

#CLAUDE.md לעומת Skill

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

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

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

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

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

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

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

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

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

#Subagent לעומת Dynamic workflow

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

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

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

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

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

#MCP לעומת Skill

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

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

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

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

#Hook לעומת Skill

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

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

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

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

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

#הבן כיצד יכולות נערמות בשכבות

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

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

#שילוב יכולות

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

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

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

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

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

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

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

#הבן כיצד יכולות נטענות

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

#CLAUDE.md

מתי: תחילת ההפעלה

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

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

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

#Skills

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

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

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

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

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

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

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

#שרתי MCP

מתי: תחילת ההפעלה.

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

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

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

#Code intelligence

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

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

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

טיפ: הכלי LSP אינו פעיל עד שתתקין תוסף בינה לקוד עבור שפת התכנות שלך.

#Subagents

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

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

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

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

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

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

#Hooks

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

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

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

טיפ: הוקים הם אידיאליים עבור פעולות לוואי (כמו בדיקת lint, רישום ליומן) שאינן צריכות להשפיע על ההקשר של Claude.

#למידע נוסף

לכל יכולת יש מדריך משלה עם הוראות הגדרה, דוגמאות ואפשרויות תצורה.

• CLAUDE.md: שמירת הקשר הפרויקט, מוסכמות והוראות
• Skills: הענקת מומחיות בתחום ותהליכי עבודה לשימוש חוזר ל-Claude
• Subagents: העברת עבודה להקשר מבודד
• Dynamic workflows: הרצת תתי סוכנים רבים מתוך סקריפט אחד
• Cross-session messaging: מתן אפשרות ל-Claude לשלוח הודעות להפעלות האחרות שלך
• MCP: חיבור Claude לשירותים חיצוניים
• Hooks: אוטומציה של פעולות באמצעות הוקים
• Plugins: איגוד ושיתוף של ערכות יכולות
• Marketplaces: אירוח והפצה של אוספי תוספים