5 שלב 3 — אוטומציה מלאה

Plugins Deep Dive — עולם התוספים

Skills, Hooks ו-Agents הם חלקים בודדים. Plugin אורז את כולם לחבילה אחת שלמה שמתקינים בפעולה אחת. בפרק הזה נלמד מה בדיוק יש בתוך Plugin, איך מגלים ומתקינים תוספים מה-Marketplace, מה ההבדל בין תוספים רשמיים לקהילתיים, איך בונים Plugin מותאם אישית מאפס עם Skills, Hooks ו-Agents, איך לנהל Plugin Data Persistence, איך לפתור קונפליקטים בין תוספים — ואיך לאבטח סביבת Plugins מלאה. עדכני למרץ 2026, גרסה 2.1.81.

מה יהיה לך בסוף הפרק הזה
מה תוכל/י לעשות אחרי הפרק הזה
דרישות קדם
🔗 הפרויקט שלך

בפרק הקודם (פרק 4: Skills) למדת לבנות Skills — פקודות /slash מותאמות אישית שמפעילים עם YAML Frontmatter ו-Markdown Body. בנית Skill עם Forked Context, למדת על User-Invoked לעומת Auto-Invoked, ויצרת ספריית פקודות מותאמות אישית. בפרק הזה תלמד לארוז Skills, Hooks, Agents ושרתי MCP ביחד כ-Plugin שלם — חבילה אחת שמתקינים בפעולה אחת ומשתפים עם אחרים. בפרק הבא (פרק 6: Git Worktrees) תלמד להריץ מספר Sessions של Claude Code במקביל, כל אחד על Branch נפרד — וה-Plugins שתבנה בפרק הזה ילוו אותך לכל Worktree.

מילון מונחים — פרק 5
מונח באנגלית הסבר בעברית
Plugin תוסף — חבילה שלמה שמוסיפה יכולת חדשה ל-Claude Code. כולל Skills + Hooks + Agents + MCP + Manifest
Marketplace חנות התוספים הרשמית — claude.com/plugins. מעל 9,000 תוספים נכון למרץ 2026
Manifest (plugin.json) קובץ הצהרה — מתאר את שם התוסף, גרסה, רכיבים, תלויות ודרישות מינימום
Verified Badge תג מאומת — מסמן תוספים רשמיים של Anthropic שעברו ביקורת אבטחה מלאה
Components רכיבים — Skills, Hooks, Agents, MCP Servers שמרכיבים את התוסף
Plugin Data Persistence שמירת נתוני תוסף — מנגנון לשמור מידע בין Sessions דרך ${CLAUDE_PLUGIN_DATA}
${CLAUDE_PLUGIN_DATA} משתנה סביבה (מגרסה 2.1.78) — מצביע על תיקיית אחסון יציבה לכל תוסף. שורד עדכונים ו-restarts
Inline Plugin תוסף מוטמע — מוגדר ישירות ב-settings.json, לא מ-Marketplace. מתאים לתוספים פנימיים
Hot Reload טעינה חמה — עדכון תוסף בלי restart. לא כל תוסף תומך, ברוב המקרים צריך restart אחרי התקנה
Managed Policies מדיניות מנוהלת ארגונית — Enterprise יכול להגביל אילו תוספים מותרים להתקנה
Last-Installed Wins כלל הקונפליקט — כששני תוספים רושמים את אותו שם /command, האחרון שהותקן מנצח
Internal Plugin Registry רשימת תוספים פנימית — רשימה מאושרת לשימוש ארגוני, מחליפה Marketplace בסביבה סגורה

מה זה Plugin — החבילה השלמה

מתחיל 10 דקות חינם מושג

Plugin (תוסף) הוא חבילה שלמה שמוסיפה יכולת חדשה ל-Claude Code. בעוד ש-Skill נותן לך פקודה בודדת, Hook נותן לך טריגר אחד, ו-Agent נותן לך עובד ספציפי — Plugin אורז את כולם יחד לחבילה קוהרנטית שמתקינים בפעולה אחת.

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

מערכת ה-Plugins הושקה בסוף 2025 כהרחבה טבעית של מערכת ה-Skills וה-Hooks. מאז, האקוסיסטם צמח במהירות מטורפת — מאות תוספים חדשים נוספו מדי שבוע. Anthropic פתחו Marketplace רשמי ב-claude.com/plugins, כולל תוספים רשמיים שלהם (עם Verified Badge) ותוספים קהילתיים. ב-v2.1.78 (פברואר 2026) התווסף מנגנון ${CLAUDE_PLUGIN_DATA} לשמירת נתונים בין Sessions — צעד שפתח את הדלת ל-Plugins עם זיכרון מצטבר, cache חכם, ומטריקות.

9,000+

תוספים זמינים ב-Marketplace של Claude Code נכון למרץ 2026. האקוסיסטם הושק בסוף 2025, וצומח במאות תוספים חדשים מדי שבוע. Claude Code הפך לפלטפורמה — לא רק כלי.

חשוב להבין: Plugin הוא לא Skill. הוא גם לא Hook. הוא גם לא Agent בודד. Plugin הוא חבילה שאורזת כמה מהרכיבים האלה ביחד, עם Manifest (קובץ plugin.json) שמצהיר מה בפנים, מהן התלויות, ומה גרסת Claude Code המינימלית הנדרשת. כשאתה מתקין Plugin, Claude Code קורא את ה-Manifest וטוען את כל הרכיבים בבת אחת — Skills הופכים ל-/commands, Hooks מתחילים לרוץ על אירועים, Agents הופכים לזמינים, ושרתי MCP מתחברים.

Plugin מול Skills, Hooks ו-Agents — מה ההבדל?

רכיב מה הוא נותן בפני עצמו בתוך Plugin
Skill פקודת /slash אחת קובץ .md ב-.claude/commands/ חלק מ-skills/ directory
Hook אוטומציה שרצה על אירוע הגדרה ב-settings.json חלק מ-hooks/ directory
Agent עובד עצמאי שמטפל במשימה קובץ .md ב-.claude/agents/ חלק מ-agents/ directory
MCP Server חיבור לשירות חיצוני הגדרת שרת ב-settings.json חלק מ-mcp/ directory
Plugin כל הנ"ל + config + manifest — הוא ה-Plugin עצמו

ה-Framework שכדאי לזכור:

מסגרת החלטה: "Plugin = Feature Pack"

Skill = ממשק המשתמש (מה שאתה מפעיל)
Hook = שכבת האוטומציה (מה שרץ אוטומטית)
Agent = העובדים (מי עושה את העבודה הכבדה)
MCP = החיבורים (מאיפה מגיע המידע)
Plugin = כל אלה ביחד, עטופים ב-Manifest, מוכנים להתקנה בקליק אחד.

השתמשו ב-Framework הזה כל פעם ששואלים אתכם "מה ההבדל בין Plugin ל-X?" — Plugin הוא לא X, הוא אריזה של X+Y+Z.

דוגמה קונקרטית: נניח שאתם רוצים יכולת "ניהול קוד איכותי" (Code Quality) לפרויקט שלכם. בלי Plugin, תצטרכו ליצור ידנית: Skill ל-code review (קובץ .md ב-commands/), Hook שרץ אחרי כל עריכת קובץ ובודק lint (הגדרה ב-settings.json), Agent שמנתח dead code (קובץ .md ב-agents/), וחיבור MCP לשירות ניתוח סטטי כמו SonarQube (עוד הגדרה ב-settings.json). זה 4 קבצים שונים, 4 מקומות שונים, ו-4 שלבי הגדרה נפרדים.

עם Plugin של Code Quality — מתקינים דבר אחד (/plugin install code-quality-pro) וכל הרכיבים האלה מגיעים מוכנים, מתואמים ונבדקים. זו המהות של Plugins: מורכבות ← פשטות.

מתי צריכים Plugin ומתי מספיק Skill בודד?

זו שאלה חשובה שנחזור אליה שוב בהמשך הפרק. הכלל הפשוט:

⚡ עשה עכשיו 2 דקות

פתח את קובץ ה-.claude/settings.json של הפרויקט שלך (או ~/.claude/settings.json הגלובלי) ובדוק — יש לך כבר תוספים מוגדרים שם? חפש מפתח בשם "plugins". אם אין, מצוין — זו נקודת ההתחלה שלך. אם יש, ספור כמה תוספים מותקנים ורשום את שמותיהם — בהמשך הפרק נבדוק אם כולם באמת נחוצים.

ה-Marketplace — 9,000 תוספים ועולה

מתחיל 10 דקות חינם תרגול

ה-Marketplace הרשמי של Claude Code נמצא בכתובת claude.com/plugins והוא המקור הראשי לגילוי והתקנת תוספים. זה הכתובת הראשונה שצריך להכיר — מעין App Store של Claude Code. ה-Marketplace מנוהל על ידי Anthropic, וכל תוסף שעולה אליו עובר לפחות סריקה אוטומטית בסיסית של malware ובעיות אבטחה ברורות.

ניווט ב-Marketplace — קטגוריות

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

קטגוריה אחוז מה תמצאו שם מגמה
Development ~35% Linting, Code Review, Testing, Debugging, Refactoring הקטגוריה הגדולה ביותר, תחרותית
Productivity ~20% ניהול משימות, תבניות, אוטומציות יומיות, Workflow Builders צומחת מהר, אוטומציות Workflow
Content ~15% כתיבה, SEO, תרגום, בלוגים, סושיאל מדיה, Copywriting צומחת מהר, AI-native content
DevOps ~12% Docker, Cloud Deployment, CI/CD, Monitoring, Infrastructure יציבה, Cloud integrations
Data ~10% עיבוד CSV, SQL queries, ויזואליזציה, דוחות Analytics צומחת, Database + Analytics
Security ~4% סריקת פגיעויות, זיהוי Secrets, ביקורת Dependencies שוק פתוח — הזדמנות
Marketing ~2% ניתוח קמפיינים, כלי תוכן שיווקי, Email Marketing שוק פתוח — הזדמנות
Design ~2% עבודה עם Figma, ייצור CSS, אופטימיזציית UI, RTL שוק פתוח — הזדמנות

מה מוצג בדף של כל Plugin

כשנכנסים לדף של תוסף ספציפי ב-Marketplace, רואים:

שדה מה הוא אומר למה חשוב
Description תיאור מה התוסף עושה מבינים מה מקבלים — אם התיאור מעורפל, נזהרים
Author מי בנה — Anthropic, חברה ידועה, או מפתח עצמאי רמת אמון ואחריות
Install Count כמה משתמשים התקינו פופולריות = הרבה עיניים שבדקו את הקוד
Rating דירוג ממוצע מ-1 עד 5 שביעות רצון — מתחת ל-3.5 זה דגל אדום
Version גרסה נוכחית (Semantic Versioning) עדכניות — גרסה ישנה = אולי נטוש
Components אילו רכיבים כלולים (Skills, Hooks, Agents, MCP) מה בדיוק תקבלו בפועל
Verified Badge תג "מאומת" — רק לתוספים רשמיים של Anthropic רמת אבטחה מקסימלית, תמיכה מקצועית
Last Updated תאריך העדכון האחרון מפתח פעיל = תיקוני באגים ותאימות לגרסאות חדשות
💡 טיפ: שני מדדים שחשוב לבדוק לפני כל התקנה

Install Count + Last Update Date. תוסף עם 50,000 התקנות ועדכון אחרון מלפני שבוע — אמין הרבה יותר מתוסף עם 10 התקנות מלפני שנה. פופולריות גבוהה = הרבה עיניים שבדקו את הקוד. עדכון אחרון = המפתח פעיל ומתקן באגים. השילוב של שניהם נותן תמונה טובה על האמינות.

⚡ עשה עכשיו 5 דקות

גלוש ל-claude.com/plugins ועבור על הקטגוריות. בחר קטגוריה אחת שרלוונטית לעבודה שלך (Development אם אתה מפתח, Content אם אתה יוצר תוכן, Marketing אם אתה משווק). סנן לפי הכי פופולריים (Sort by: Most Popular) ורשום לעצמך את שמות 3 התוספים הראשונים — אלה יהיו המועמדים להתקנה. ליד כל שם כתוב: שם התוסף, Install Count, ו-Rating. אל תתקין עדיין — קודם נלמד איך לעשות את זה נכון ובטוח.

שלוש דרכי ההתקנה: Marketplace, GitHub, Inline

בינוני 12 דקות חינם תרגול

יש שלוש דרכים להתקין Plugin ב-Claude Code. כל אחת מתאימה למצב אחר. חשוב להכיר את כולן כי תשתמשו בכל אחת בהקשר שונה.

שיטה 1: מה-Marketplace — הכי פשוט

זו הדרך הכי ישירה. משתמשים בפקודה /plugin install עם שם התוסף:

📚 התקנה מה-Marketplace

/plugin install code-quality-pro

זה הכל. Claude Code יוריד את התוסף מה-Marketplace, יתקין את כל הרכיבים שלו (Skills, Hooks, Agents, MCP Servers), ויודיע לכם שההתקנה הסתיימה. אפשר גם לגלוש ל-Marketplace בדפדפן וללחוץ על כפתור Install ישירות — זה יפעיל את Claude Code אוטומטית.

מתי לבחור: כשיש Plugin מוכר ב-Marketplace שעושה בדיוק מה שצריך. זו ברירת המחדל — תמיד נסו קודם דרך ה-Marketplace.

שיטה 2: מ-GitHub — לתוספים שלא ב-Marketplace

לא כל Plugin נמצא ב-Marketplace. חלק נמצאים רק ב-GitHub — בין אם כי המפתח לא העלה אותם, בין אם כי אתם רוצים גרסה ספציפית, או שזה תוסף פנימי של צוות. ההתקנה נעשית דרך settings.json:

📚 התקנה מ-GitHub

פתחו את .claude/settings.json והוסיפו:

"plugins": ["https://github.com/user/my-awesome-plugin"]

Claude Code ישכפל את ה-repository, יקרא את ה-Manifest (plugin.json), ויתקין את כל הרכיבים. לעדכון — פשוט עשו git pull ב-repo.

מתי לבחור: כשהתוסף לא ב-Marketplace, כשצריכים גרסה ספציפית מ-branch מסוים, או כשעובדים עם תוסף פנימי של צוות ב-private repo.

שיטה 3: Inline ב-settings.json — לתוספים פנימיים/מותאמים

זו הדרך המתקדמת ביותר. במקום להתקין מחוץ, אתם מגדירים את רכיבי התוסף ישירות בקובץ ההגדרות. הדרך הזו מתאימה ל:

📚 התקנה Inline — דוגמה

ב-.claude/settings.json הוסיפו:

"plugins": ["/absolute/path/to/my-local-plugin"]

Claude Code ייקרא את ה-plugin.json מהנתיב המקומי וייטען את כל הרכיבים. שינוי בקבצי ה-Plugin יתעדכן ב-restart הבא.

Scope — היכן מותקן התוסף

מיקום ההתקנה קובע היכן התוסף יהיה זמין:

Scope קובץ ההגדרות זמין ב... מתי להשתמש
Project .claude/settings.json רק בפרויקט הספציפי הזה תוסף ספציפי לפרויקט (למשל code-style enforcer, deploy helper)
Global ~/.claude/settings.json בכל פרויקט שתפתחו תוסף שאתם רוצים תמיד (למשל git workflow helper, secret detector)
⚠ אזהרה: Restart נדרש אחרי התקנה

אחרי התקנת Plugin, צריך להפעיל מחדש את Claude Code (או לסגור ולפתוח את ה-session). חלק מהתוספים תומכים ב-Hot Reload — טעינה חמה בלי restart — אבל לא כולם. אם התקנתם Plugin ולא רואים את ה-Skills החדשות כשמקלידים /help, ה-Restart הוא הצעד הראשון לפתרון. זכרו: Settings concatenate (מערכים מתמזגים) — כך שתוסף ב-Project scope ותוסף ב-Global scope יפעלו שניהם יחד.

השוואה מהירה: שלוש השיטות

שיטה קושי עדכונים שיתוף מתאים ל...
Marketplace קל אוטומטיים ציבורי רוב המקרים
GitHub בינוני git pull ידני צוות / ציבורי תוספים פנימיים, גרסאות ספציפיות
Inline מתקדם ידניים לגמרי מקומי בלבד פיתוח, ניסויים, CI/CD
⚡ עשה עכשיו 5 דקות

התקן Plugin אחד מה-Marketplace. בחר את אחד מהשלושה שרשמת קודם, או נסה:
/plugin install code-review-helper
אחרי ההתקנה, הרץ /help ובדוק אם ה-Skills החדשות של התוסף מופיעות ברשימת הפקודות. אם לא מופיעות — עשה restart ובדוק שוב. רשום לעצמך: מה שם הפקודות החדשות שהתווספו?

Plugin Anatomy — מבנה, Manifest ורכיבים

בינוני 12 דקות חינם מושג + תרגול

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

מבנה התיקיות הטיפוסי

📚 מבנה Plugin טיפוסי

my-plugin/
├── plugin.json — Manifest: שם, גרסה, תיאור, רכיבים, תלויות
├── README.md — תיעוד למשתמשים (מה התוסף עושה, איך מתקינים)
├── skills/ — קבצי SKILL.md שהופכים ל-/commands
│ ├── review.md — Skill ל-Code Review
│ └── fix-lint.md — Skill לתיקון בעיות Lint
├── hooks/ — סקריפטים שרצים על אירועים
│ ├── post-edit-lint.sh — בדיקת Lint אחרי כל עריכה
│ └── pre-commit-check.sh — בדיקה לפני Commit
├── agents/ — קבצי Agent .md
│ └── code-analyzer.md — Agent שמנתח Dead Code
├── mcp/ — שרתי MCP: קוד + הגדרות
│ └── sonarqube-server/ — חיבור ל-SonarQube
└── config/ — הגדרות ברירת מחדל
    └── defaults.json — ערכי ברירת מחדל שהמשתמש יכול לדרוס

כל תיקייה אופציונלית. Plugin מינימלי יכול להכיל רק plugin.json ו-skills/. Plugin מורכב יכול להכיל את כל התיקיות, כולל mcp/ עם שרת MCP מלא. הכל תלוי במה שהתוסף עושה.

קובץ ה-Manifest — plugin.json לעומק

ה-Manifest הוא הלב של כל Plugin. הוא מצהיר מה יש בחבילה, מהן הדרישות, ואיפה כל רכיב נמצא. Claude Code קורא את הקובץ הזה כשמתקינים — ובלעדיו, אין Plugin.

📚 דוגמה מלאה: plugin.json

{
  "name": "code-quality-pro",
  "version": "2.3.1",
  "description": "Complete code quality suite: lint, review, dead code detection",
  "author": "devtools-team",
  "license": "MIT",
  "minClaudeCodeVersion": "2.1.60",
  "components": {
    "skills": ["skills/"],
    "hooks": ["hooks/"],
    "agents": ["agents/"],
    "mcp": ["mcp/"]
  },
  "dependencies": {
    "npm": ["eslint", "prettier"],
    "mcp": ["sonarqube-server"]
  },
  "config": {
    "strictMode": true,
    "maxIssuesPerFile": 20
  }
}

בוא נעבור על כל שדה חשוב:

שדה חובה? מה הוא עושה דוגמה
name כן שם ייחודי. זה מה שמשתמשים ב-/plugin install "code-quality-pro"
version כן גרסה סמנטית. שינוי Major = breaking changes "2.3.1"
description כן תיאור קצר שמופיע ב-Marketplace וב-/help "Code quality suite with lint, review, dead code detection"
minClaudeCodeVersion מומלץ גרסת Claude Code מינימלית. אם ישנה יותר — התקנה נכשלת "2.1.60"
components כן רשימת תיקיות שמכילות Skills, Hooks, Agents, MCP {"skills": ["skills/"]}
dependencies אופציונלי חבילות חיצוניות שצריכות להיות מותקנות {"npm": ["eslint"]}
config אופציונלי ערכי ברירת מחדל שהמשתמש יכול לדרוס {"strictMode": true}
מסגרת החלטה: "Plugin Component Map"

כשקוראים plugin.json, חשבו על כל Component כשכבה בארכיטקטורה:

Skills = שכבת ממשק → מה המשתמש מפעיל בידיים (/review, /fix-lint)
Hooks = שכבת אוטומציה → מה רץ לבד ברקע (PostToolUse, SessionStart)
Agents = שכבת עובדים → מי עושה עבודה כבדה (ניתוח dead code, security audit)
MCP = שכבת חיבורים → מאיפה מגיע מידע חיצוני (SonarQube, Datadog, GitHub API)

Plugin איכותי מחבר את כל השכבות: Skill מפעיל Agent, Agent משתמש ב-MCP לשלוף מידע, Hook מוודא שהתוצאה עומדת בסטנדרט.

⚡ עשה עכשיו 3 דקות

מצא את התוסף שהתקנת קודם ופתח את ה-plugin.json שלו. אם התקנת מ-Marketplace, חפש בתיקיית .claude/plugins/. קרא את ה-Manifest וזהה: כמה Skills יש? כמה Hooks? יש שרת MCP? מה ה-dependencies? מה ה-minClaudeCodeVersion? הבנה של Manifest היא המפתח לכתוב אחד בעצמך — וזה בדיוק מה שנעשה בהמשך הפרק.

תוספים חיוניים לפי קטגוריה — מה להתקין ולמה

בינוני 12 דקות חינם תרגול

מתוך 9,000+ תוספים, לא צריך להתקין הכל. ההפך — להתקין יותר מדי זו טעות (מאט את Claude Code, יוצר קונפליקטים, מבלבל). הנה המלצות לתוספים חיוניים לפי סוג העבודה שלכם, עם הסבר מה כל אחד עושה ולמי הוא מתאים.

Code Quality — איכות קוד

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

Git Workflow — תהליכי Git

משלבים Hooks (על פעולות Git) עם Skills (ליצירת PRs, Changelogs ו-Release Notes):

Content Creation — יצירת תוכן

עתירי Skills עם תבניות ומדריכי סגנון מובנים:

DevOps — תשתיות ותפעול

כוללים שרתי MCP שמתחברים ל-APIs של שירותי ענן:

Security — אבטחה

עתירי Hooks — בודקים כל עריקה וכל פקודה. חובה להתקין לפחות Secret Detector.

5-7

מספר התוספים עם Hooks פעילים שמומלץ לא לעבור. יותר מזה — תתחילו להרגיש איטיות. כל Hook שרץ על PostToolUse מוסיף overhead לכל פעולת עריקה של Claude. תעדיפו Skill-only plugins (שלא כוללים Hooks) כשאפשר.

💡 קטגוריה חשובה: תוספים בעברית

חפשו ב-Marketplace תוספים שמתמחים ב-Hebrew Content, SEO לשוק הישראלי, ותרגום טכני. הקטגוריה הזו עדיין קטנה — רוב התוספים באנגלית — אבל זו בדיוק ההזדמנות. אם תבנו תוסף איכותי בעברית (תוכן, SEO, משפטים, RTL), יש קהל שמחכה לו. עוד על זה בסעיף האקוסיסטם.

⚡ עשה עכשיו 8 דקות

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

שם התוסף קטגוריה למה אני צריך אותו יש Hooks?
למשל: secret-detector Security למנוע דליפת API keys כן

העמודה האחרונה חשובה: ספרו כמה מהתוספים שבחרתם כוללים Hooks. אם יותר מ-5 — שקלו לוותר על אחד (עדיפות ל-Skill-only plugins כשההבדל לא קריטי).

רשמי מול קהילתי — אמון, אבטחה ומדיניות

בינוני 10 דקות חינם מושג + אסטרטגיה

לא כל התוספים ב-Marketplace נוצרו שווים. יש הבדל מהותי בין תוספים רשמיים של Anthropic לבין תוספים קהילתיים. ההבדל הזה קריטי כי Plugin עם Hooks יכול להריץ קוד שרירותי על המחשב שלכם. כן, קראתם נכון — Hook הוא סקריפט Shell שרץ, וסקריפט Shell יכול לעשות כל דבר.

תוספים רשמיים (Official)

תוספים קהילתיים (Community)

מסגרת החלטה: "Plugin Trust Decision Tree"

השתמשו בעץ ההחלטות הזה לפני כל התקנה של תוסף קהילתי:

שאלה 1: האם יש Verified Badge?
→ כן: סמוך. זה רשמי של Anthropic.
→ לא: המשך לשאלה 2.

שאלה 2: כמה התקנות יש?
→ מעל 10,000: סביר לסמוך. המשך לשאלה 3 לוידוא.
→ 1,000-10,000: בדוק עם זהירות. המשך לשאלה 3.
→ מתחת ל-1,000: זהירות גבוהה. עבור לשאלה 4.
→ מתחת ל-100: סיכון. עבור ישירות לשאלה 4.

שאלה 3: מתי העדכון האחרון?
→ בחודש האחרון: טוב — המפתח פעיל.
→ 1-3 חודשים: סביר — בדוק אם יש issues פתוחים.
→ מעל 3 חודשים: חשוד — ייתכן נטוש. המשך בזהירות.

שאלה 4: האם קוד המקור פתוח?
→ כן: קרא את ה-Hook scripts לפני שמתקין. בדוק שאין curl לכתובות חשודות, אין גישה לקבצים רגישים (~/.ssh/, ~/.aws/), ואין network requests לא מוסברים.
→ לא: אל תתקין — Plugin עם Hooks סגורים הוא סיכון שאי אפשר להעריך.

⚠ אזהרה קריטית: Hooks = קוד שרץ על המחשב שלך

Plugin עם Hook יכול להריץ כל סקריפט Shell על המחשב שלכם. זה אומר שתוסף זדוני יכול לגנוב SSH keys, לקרוא .env עם סיסמאות, לשנות קבצים, או לשלוח מידע החוצה. תמיד בדקו את ה-Hook scripts של תוסף קהילתי לפני שמאשרים אותו. מגרסה 2.1.75, Claude Code מציג את מקור ה-Hook בהודעות ה-permission — שימו לב מאיפה מגיע הקוד ומה הוא עושה.

מדיניות לצוותים ולארגונים

בסביבה ארגונית, אי אפשר לתת לכל מפתח להתקין מה שבא לו. הפתרון:

⚡ עשה עכשיו 5 דקות

חזור לתוסף שהתקנת קודם. עבור על עץ ההחלטות למעלה ובדוק: (1) האם יש Verified Badge? (2) כמה התקנות? (3) מתי העדכון האחרון? (4) אם יש hooks/ directory — פתח את ה-scripts וקרא מה הם עושים. אם ה-Hook scripts נראים הגיוניים (formatting, lint checking) — מצוין. אם יש curl לכתובות לא מוכרות או גישה ל-~/.ssh/ — זה דגל אדום.

בניית Plugin משלכם — מאפס ועד הפצה

מתקדם 20 דקות חינם תרגול

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

מסגרת החלטה: "Plugin Creation Decision Tree"

יש לך Skill בודד שעושה משימה אחת?
→ השאר אותו כ-standalone command file ב-.claude/commands/. אין צורך ב-Plugin.

יש לך 2+ Skills + Hook + אולי Agent שקשורים לאותו נושא?
→ כן, ארוז כ-Plugin. הרכיבים עובדים יחד ומשלימים זה את זה.

בונה לצוות?
→ Plugin עם team-specific config. הגדרות שמתאימות לסביבת הצוות (naming conventions, code standards, deploy targets).

בונה לעולם?
→ Plugin עם sensible defaults + config overrides. הגדרות ברירת מחדל שעובדות לכולם, עם אפשרות התאמה אישית.

צעד אחר צעד: בניית Plugin מאפס — "Project Health"

נבנה Plugin מלא בשם project-health שנותן כלי ניטור בריאות לכל פרויקט. הוא יכיל 2 Skills, 1 Hook, ו-1 Agent.

1

צרו את מבנה התיקיות

צרו תיקייה חדשה עם המבנה הבא:
mkdir -p project-health/{skills,hooks,agents,config}
כל תיקייה תכיל את הרכיבים המתאימים. ב-config/ נשמור הגדרות ברירת מחדל.

2

כתבו את ה-Manifest — plugin.json

צרו קובץ plugin.json בתיקייה הראשית:

{
  "name": "project-health",
  "version": "1.0.0",
  "description": "Project health monitoring: file stats, tech debt detection, size warnings",
  "author": "your-name-here",
  "minClaudeCodeVersion": "2.1.60",
  "components": {
    "skills": ["skills/"],
    "hooks": ["hooks/"],
    "agents": ["agents/"]
  },
  "config": {
    "maxFileLines": 500,
    "maxFunctionLines": 50
  }
}

3

צרו Skill 1: /health-check

צרו skills/health-check.md:

---
name: health-check
description: Scan the project and generate a comprehensive health report
model: sonnet
effort: medium
fork: true
---

# Project Health Check

Analyze the current project and produce a health report with these sections:

1. **File Statistics**: Total files, total lines of code, average file size
2. **TODOs**: Count of TODO/FIXME comments with file locations
3. **Large Files**: Files over 500 lines (configurable)
4. **Dependencies**: Count of dependencies, outdated ones if detectable
5. **Test Coverage**: Estimate based on test file count vs source files

Report format: Markdown table with emoji status indicators.
End with an overall health score: A/B/C/D/F.

4

צרו Skill 2: /tech-debt

צרו skills/tech-debt.md:

---
name: tech-debt
description: Identify technical debt: oversized files, long functions, unused imports
agent: debt-analyzer
fork: true
---

# Technical Debt Analysis

Use the debt-analyzer agent to scan the codebase for technical debt:
- Files larger than ${config.maxFileLines} lines
- Functions longer than ${config.maxFunctionLines} lines
- Unused imports and dead exports
- Duplicated code blocks (>10 lines identical)

For each finding, report: File | Issue | Severity | Suggested Fix.
End with total debt score and estimated hours to resolve.

5

צרו Hook: post-edit-size-check

צרו hooks/post-edit-size-check.sh:

#!/bin/bash
# Runs after every Edit/Write — warns if file exceeds 500 lines
FILE="$CLAUDE_TOOL_INPUT_FILE"
if [ -f "$FILE" ]; then
  LINES=$(wc -l < "$FILE")
  if [ "$LINES" -gt 500 ]; then
    echo "WARNING: $FILE has $LINES lines. Consider splitting."
  fi
fi

ה-Hook הזה רץ על PostToolUse של Edit ו-Write. כל פעם שClaude עורך קובץ, הוא בודק אם הקובץ חרג מ-500 שורות ומזהיר.

6

צרו Agent: debt-analyzer

צרו agents/debt-analyzer.md:

---
name: debt-analyzer
description: Specialized agent for technical debt analysis
model: sonnet
effort: high
disallowedTools: ["Write", "Edit"]
maxTurns: 15
---

You are a technical debt analyzer. You can read files and search code, but you CANNOT modify any files. Your job is analysis and reporting only.

שימו לב ל-disallowedTools — ה-Agent הזה יכול לקרוא קבצים אבל לא יכול לשנות אותם. זה מגן מפני שינויים לא רצויים במהלך ניתוח.

7

בדקו מקומית

התקינו מהנתיב המקומי: הוסיפו ל-.claude/settings.json:
"plugins": ["/path/to/project-health"]
הפעילו מחדש את Claude Code. בדקו ש-/health-check ו-/tech-debt מופיעים ב-/help. הריצו אותם ובדקו שהם עובדים. ערכו קובץ ובדקו שה-Hook מתריע אם הקובץ גדול.

8

הפיצו

לצוות: דחפו ל-GitHub repo פרטי ושתפו את ה-URL. כל חבר צוות מוסיף ל-settings.json.
לעולם: העלו ל-Marketplace דרך claude.com/plugins/submit. צריך: תיאור מפורט, README.md, ו-screenshot של הפלט.

⚡ עשה עכשיו 15 דקות

בנה את ה-Plugin "project-health" מהשלבים למעלה. לא חייב להיות מושלם — הגרסה הראשונה לעולם לא מושלמת. המטרה: Plugin עובד עם לפחות 2 Skills ו-1 Hook שאתה יכול להתקין מקומית. זה הדליבר המרכזי של הפרק הזה. אם נתקעת — תן ל-Claude Code לעזור: "Create a plugin.json manifest for a plugin called project-health with 2 skills and 1 hook"

Plugin Data Persistence — ${CLAUDE_PLUGIN_DATA}

מתקדם 8 דקות חינם מושג + תרגול

תוספים רבים צריכים לשמור נתונים בין Sessions: הגדרות משתמש, תוצאות cached, העדפות שנצברו, מטריקות. בלי מקום קבוע לשמור — כל מידע נעלם כשהמשתמש סוגר את Claude Code. זו בעיה אמיתית: Plugin שצריך להיזכר בהעדפות שלך, ב-cache של API calls, או בהיסטוריה של ממצאים קודמים — לא יכול לעבוד בלי persistence.

המשתנה ${CLAUDE_PLUGIN_DATA}

מגרסה v2.1.78 (פברואר 2026), Claude Code מספק את המשתנה ${CLAUDE_PLUGIN_DATA} שמצביע על תיקייה יציבה שמיוחדת לתוסף שלכם. זהו שינוי משמעותי שפתח את הדלת ל-Plugins חכמים עם זיכרון.

לתיקייה הזו יש תכונות חשובות:

מה לשמור שם?

סוג נתון פורמט מומלץ דוגמה
הגדרות משתמש JSON config.json — העדפות שהמשתמש הגדיר (שפה מועדפת, severity threshold)
Cache של API JSON / SQLite תוצאות חיפוש פגיעויות שלא משתנות לעתים קרובות (refresh כל 24 שעות)
מטריקות מצטברות JSON כמה פעמים כל Skill הופעל, ממוצע זמן ריצה, כמה issues נמצאו
העדפות שנלמדו JSON / Plain Text סגנון כתיבה מועדף, naming conventions, language settings
היסטוריית ממצאים JSON רשימת issues שנמצאו בעבר — למעקב אם תוקנו או לא
📚 דוגמה: שימוש ב-${CLAUDE_PLUGIN_DATA} ב-Hook

#!/bin/bash
# Save scan results to plugin data directory
RESULTS_DIR="${CLAUDE_PLUGIN_DATA}/scan-results"
mkdir -p "$RESULTS_DIR"
echo "{\"timestamp\": \"$(date -Iseconds)\", \"issues\": $ISSUE_COUNT}" >> "$RESULTS_DIR/history.jsonl"

כל הרצה שומרת שורה חדשה עם timestamp ומספר issues. בהרצה הבאה, ה-Skill יכול לקרוא את ההיסטוריה ולהראות מגמה: "בשבוע האחרון, מספר ה-issues ירד מ-42 ל-18."

⚠ אזהרה למפתחי Plugins

תמיד השתמשו ב-${CLAUDE_PLUGIN_DATA} במקום לעשות hardcode לנתיבים. אם תכתבו /home/user/.my-plugin-data/, התוסף יישבר על כל מחשב שהנתיב שונה — macOS, Linux, Windows, Docker containers. המשתנה מבטיח תאימות אוניברסלית. זה גם מבטיח שהתוסף שלכם לא ידרוס נתונים של תוסף אחר — כל תוסף מקבל נתיב ייחודי.

ניהול, עדכון, השבתה ופתרון קונפליקטים

בינוני 10 דקות חינם תרגול

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

פעולות ניהול בסיסיות

פעולה איך עושים מתי להשתמש
רשימת תוספים בדיקת settings.json (Project + Global) או /help לראות מה מותקן — תמיד הצעד הראשון
עדכון Marketplace: אוטומטי. GitHub: git pull + restart כשגרסה חדשה יצאה או שיש bug fix
השבתה זמנית הוספת "disabled": true בהגדרות התוסף בדיקת ביצועים, debugging, או כשתוסף גורם לבעיות
הסרה מלאה מחיקת הרשומה מ-settings.json + מחיקת קבצים מ-.claude/plugins/ תוסף לא רלוונטי יותר
Downgrade GitHub: git checkout v1.2.3 לגרסה ספציפית כשגרסה חדשה שברה משהו

פתרון קונפליקטים

מה קורה כשיש לכם שני תוספים שמגדירים את אותה פקודה? למשל, שני תוספים שמייצרים /review?

📚 כלל הקונפליקט: Last-Installed Wins

אם שני תוספים רושמים את אותו שם /command, האחרון שהותקן מנצח. הראשון נדרס. הפתרון הנכון: לשנות את שם אחד מהם — למשל /review-security ו-/review-style — כדי להימנע מעמימות. בדקו אם ל-Plugin יש אפשרות rename/prefix בהגדרות שלו.

שימו לב: גם Hooks יכולים להתנגש. אם שני תוספים מגדירים Hook על PostToolUse של Edit — שניהם ירוצו, אבל הסדר לא מובטח. אם הסדר חשוב (למשל format לפני lint), עדיף לאחד את שני ה-Hooks ל-Plugin אחד מותאם.

ניטור ביצועים — Plugin Overhead

תוספים עם הרבה Hooks יכולים להאט את Claude Code. כל Hook שרץ על PostToolUse מוסיף overhead לכל פעולת עריקה. אם מרגישים איטיות:

מסגרת החלטה: "Plugin Overhead Budget"

חשבו על כל Plugin כעלות ביצועים:

Skill-only plugins (בלי Hooks) = עלות 0. הם טעונים רק כשמפעילים אותם. התקינו כמה שרוצים.
Plugins עם Hook אחד = עלות נמוכה. רץ רק על האירוע הרלוונטי.
Plugins עם 2+ Hooks על PostToolUse = עלות בינונית-גבוהה. רצים על כל עריקה.
Plugins עם Hooks + MCP Server = עלות גבוהה. תהליך רקע + network calls.

כלל אצבע: עד 5-7 תוספים עם Hooks פעילים הוא נקודת האיזון. מעל זה — בדקו אם באמת צריך את כולם פעילים כל הזמן. תוספים שמשתמשים בהם רק לעתים — השביתו בברירת מחדל והפעילו כשצריך.

⚡ עשה עכשיו 5 דקות

פתח את .claude/settings.json ו-~/.claude/settings.json ורשום את כל התוספים המותקנים. ליד כל אחד ציין: (1) מה הוא עושה, (2) האם הוא עם Hooks או רק Skills, (3) מתי השתמשת בו לאחרונה. אם יש תוסף שלא השתמשת בו חודש — השבת אותו ("disabled": true). אם יש תוסף שלא זוכר מה הוא עושה — בדוק את ה-plugin.json שלו, ואם עדיין לא ברור — הסר.

דפוסים מתקדמים — Plugins עם MCP, Agent Teams ו-Worktrees

מתקדם 10 דקות חינם מושג

תוספים מתקדמים לא מסתפקים ב-Skills ו-Hooks. הם משתמשים ביכולות מתקדמות של Claude Code — MCP Servers, Agent Teams, ו-Git Worktrees — כדי ליצור פתרונות עוצמתיים. הנה שלושה דפוסים מתקדמים שכדאי להכיר.

דפוס 1: Plugin עם שרת MCP מובנה

Plugin יכול לכלול שרת MCP שלם — תהליך רקע שמחבר את Claude Code לשירות חיצוני. למשל, Plugin ל-Project Management שמכיל:

שרתי MCP בתוך Plugin עוברים את אותן בדיקות Permission כמו שרתי MCP רגילים — Claude Code ישאל אישור להפעיל כלים חדשים. זו שכבת הגנה חשובה.

דפוס 2: Plugin שמנצל Agent Teams

Agent Teams (מפרק 2) מאפשרים מספר Agents שעובדים במקביל ומתקשרים ביניהם. Plugin יכול להגדיר team שלם:

ה-Skill מפעיל את ה-Team, וכל Agent מדווח ישירות ל-Lead שמרכז את הממצאים לדוח אחד. שימו לב: Agent Teams הוא עדיין Research Preview (צריך CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS כדי להפעיל), אבל Plugins שמשתמשים ב-Teams ייהנו מהיציבות כשהפיצ'ר ייצא למצב GA.

דפוס 3: Plugin שעובד עם Git Worktrees

ב-Claude Code 2026, נוסף תמיכה מובנית ב-Git Worktrees — היכולת להריץ sessions במקביל על branches שונים. Plugin יכול לנצל את זה:

הדפוס הזה יילמד לעומק בפרק הבא (פרק 6: Git Worktrees). לעת עתה, חשוב לדעת שזה קיים — Plugins יכולים לנצל worktrees למקביליות.

30

מספר ה-Agents המקסימלי שה-Skill המובנה /batch יכול להפעיל במקביל — כל אחד ב-Worktree נפרד, כל אחד פותח PR. זו ההקבלה הכי חזקה שזמינה ב-Claude Code כיום.

האקוסיסטם — לאן הולך שוק התוספים

מתחיל 8 דקות חינם מושג

אקוסיסטם התוספים של Claude Code הוא אחד מנועי הצמיחה המהירים בעולם ה-AI tools. Claude Code הגיע ל-$2.5 מיליארד קצב שנתי (annualized run-rate) עד פברואר 2026, וה-Plugins הם חלק משמעותי מהערך שהפלטפורמה מציעה.

טרנדים מרכזיים — מרץ 2026

ההזדמנות הישראלית

התוספים בעברית עדיין מעטים ב-Marketplace. זו הזדמנות אמיתית: ישראל היא מוקד טכנולוגי עם אלפי מפתחים ומשווקים שמשתמשים ב-Claude Code, אבל הכלים עדיין כמעט כולם באנגלית. מי שיגשר את הפער הזה ראשון — ייהנה מיתרון ראשון משמעותי (first-mover advantage).

💡 5 רעיונות לתוספים בעברית שחסרים ב-Marketplace

1. Hebrew SEO Analyzer — ניתוח SEO מותאם לעברית: מילות מפתח, כותרות, Meta Descriptions בעברית, בדיקת keyword cannibalization בעברית
2. Israeli Legal Compliance — בדיקת עמידה בתקנות פרטיות ישראליות, GDPR, חוק הספאם הישראלי, חוק שוויון ה-accessibility
3. Hebrew Technical Writer — תרגום documentation טכני לעברית תקנית, עם מאגר מונחים טכניים מקובלים בתעשייה הישראלית
4. Israeli Business Template Pack — תבניות חשבוניות מס, חוזים, הצעות מחיר, דוחות בעברית עם פורמט ישראלי (תאריכים, ח"פ, מע"מ)
5. RTL UI Helper — בדיקת תאימות RTL ב-CSS וב-HTML, זיהוי בעיות dir, פתרון בעיות mixed-direction, ווידוא שטפסים עובדים ב-RTL

Frameworks להחלטות — מתי להתקין, מתי לבנות, מתי לוותר

בינוני 6 דקות חינם מושג

עם 9,000+ תוספים זמינים, ההחלטה "מה להתקין" היא לא פשוטה. הנה שני Frameworks שיעזרו לכם לקבל החלטות חכמות.

מסגרת החלטה: "Install vs Build vs Skip"

שלב 1: מה אתה צריך?
הגדר בדיוק מה ה-Plugin צריך לעשות. "אני צריך X שעושה Y על Z."

שלב 2: יש ב-Marketplace?
→ כן, עם 10K+ התקנות ו-4+ rating: התקן. זה עובד.
→ כן, אבל rating נמוך או מעט התקנות: נסה, אבל תהיה מוכן לבנות בעצמך.
→ לא: המשך לשלב 3.

שלב 3: כמה מורכב לבנות?
→ Skill בודד (30 דקות): בנה בעצמך. לא שווה לחפש Plugin.
→ Plugin עם 2-3 Skills + Hook (2-3 שעות): בנה אם זה ליבת העבודה שלך.
→ Plugin מורכב עם MCP + Agents (יום+): שקול אם יש ROI. כמה זמן תחסוך לשבוע?

שלב 4: ROI Check
אם ה-Plugin חוסך X דקות ביום, ובניית Plugin לוקחת Y שעות:
ROI = Y * 60 / X = מספר ימים עד שהשקעה מחזירה את עצמה.
אם ROI > 30 ימים — שקול לדלג (Skip). אם ROI < 7 ימים — בנה מיד.

מסגרת החלטה: "Plugin Maturity Assessment"

לפני התקנת Plugin קהילתי, העריכו אותו לפי 5 מדדים:

מדד ירוק (3 נק') כתום (2 נק') אדום (1 נק')
התקנות 10,000+ 1,000-10,000 מתחת ל-1,000
עדכון אחרון חודש אחרון 1-3 חודשים מעל 3 חודשים
קוד פתוח כן, עם README כן, בלי תיעוד לא / סגור
Issues נסגרים בתוך שבוע נסגרים בתוך חודש פתוחים חודשים
Rating 4.0+ 3.0-4.0 מתחת ל-3.0

13-15 נקודות: התקן בלי היסוס.
9-12 נקודות: התקן עם זהירות (בדוק Hook scripts).
5-8 נקודות: שקול חלופה או בנה בעצמך.

שגרת עבודה עם Plugins

מתחיל 5 דקות חינם תרגול
שגרת עבודה — Plugins (בנוסף לשגרות מפרקים 1-4)
תדירות משימה זמן למה
יומי שימוש ב-Plugin Skills שמותקנים — הפעלת /commands רלוונטיות שוטף זה מה שהם שם בשביל
שבועי בדיקת עדכונים לתוספים מותקנים. עדכון אם יש גרסה חדשה 5 דקות תיקוני באגים ותאימות לגרסאות חדשות של Claude Code
שבועי בדיקה אם יש Plugin חדש ב-Marketplace שרלוונטי 10 דקות האקוסיסטם גדל בעשרות תוספים ביום
חודשי ביקורת אבטחה: בדיקת Hooks, הסרת תוספים לא בשימוש 15 דקות תוסף נטוש = סיכון אבטחה
חודשי ביצועים: בדיקה אם תוספים מאטים. השבתה/החלפה לפי הצורך 10 דקות Plugin Overhead Budget
רבעוני שדרוג Plugin מותאם אישית — הוספת Skills/Hooks חדשים 30 דקות התפתחות, התאמה לצרכים חדשים
רבעוני ריענון רשימת תוספים: מה שימושי, מה לא, מה חדש בשוק 20 דקות התייעלות ומניעת Plugin Bloat
טעות נפוצה: התקנת יותר מדי Plugins עם Hooks

הטעות: להתקין 15-20 תוספים כי "הם בחינם", בלי לבדוק כמה מהם כוללים Hooks. למה מפתה: כל Plugin נראה שימושי, ואין עלות כספית גלויה. מה לעשות במקום: הגבל ל-5-7 תוספים עם Hooks פעילים. תוספים שהם Skill-only (בלי Hooks) — התקן כמה שרוצה, כי הם לא מוסיפים overhead. בדוק עם /config את ה-latency — אם הוא עלה משמעותית, השבת תוספים אחד-אחד עד שמזהים את צוואר הבקבוק.

טעות נפוצה: התקנת Plugin קהילתי בלי לבדוק Hook Scripts

הטעות: להתקין Plugin פופולרי מה-Marketplace בלי לקרוא את קוד ה-Hook scripts שלו. למה מפתה: כי יש לו 10,000 התקנות ודירוג 4.5 — מה יכול להשתבש? מה לעשות במקום: תמיד פתח את תיקיית hooks/ של התוסף וקרא את הסקריפטים. חפש curl לכתובות לא מוכרות, גישה ל-~/.ssh/ או ~/.aws/, ו-network requests לא מוסברים. פופולריות לא שווה אבטחה.

טעות נפוצה: שכחה לעשות Restart אחרי התקנת Plugin

הטעות: להתקין Plugin ולצפות שהוא יעבוד מיד — ואז לחשוב שההתקנה נכשלה כשה-Skills לא מופיעים. למה מפתה: כי רוב הכלים המודרניים עובדים עם Hot Reload. מה לעשות במקום: אחרי כל התקנת Plugin, עשה restart ל-Claude Code (סגור ופתח מחדש). רק אז הרץ /help לוודא שה-Skills החדשות מופיעות. רוב ה-Plugins לא תומכים ב-Hot Reload.

תרגילים מעשיים

בינוני-מתקדם 45 דקות תרגול

תרגיל 1: בניית "Plugin Toolkit" אישי

🎯 תרגיל: בחר, התקן ובדוק 5 תוספים
  1. קח את הרשימה של 5 תוספים שבנית ב-Do-Now הקודם
  2. התקן כל אחד מהם בשיטה המתאימה (Marketplace, GitHub, או Inline)
  3. לכל תוסף: הרץ את ה-Skills שלו ובדוק שהם עובדים כמצופה
  4. לכל תוסף: בדוק אם יש Hooks — ואם כן, עשה פעולה שמפעילה אותם (למשל ערוך קובץ)
  5. רשום בטבלה: שם התוסף | מה עובד | מה לא | ציון 1-5
  6. הסר תוספים עם ציון מתחת ל-3. שמור את השאר

התוצאה: סט מותאם אישית של תוספים שבאמת עובדים בשבילך — לא bloat.

תרגיל 2: בניית Plugin מלא מאפס

🎯 תרגיל: Plugin ל-Project Health Check
  1. צור תיקיית Plugin בשם project-health עם המבנה המלא
  2. כתוב plugin.json עם שם, גרסה, תיאור, ו-components
  3. Skill 1: /health-check — סורק את הפרויקט ומחזיר דוח: כמה קבצים, שורות קוד, TODOs פתוחים, Dependencies ישנים
  4. Skill 2: /tech-debt — מזהה "חוב טכני": קבצים גדולים מדי, פונקציות ארוכות מדי, Imports שלא בשימוש
  5. Hook: post-edit-reminder — אחרי כל עריקת קובץ, בודק אם הקובץ גדל מעבר ל-500 שורות ומציע לפצל
  6. Agent: debt-analyzer — Agent read-only (disallowedTools: ["Write", "Edit"]) שמנתח חוב טכני
  7. התקן מקומית ובדוק שכל הרכיבים עובדים
  8. בונוס: העלה ל-GitHub repo ושתף עם חבר

התוצאה: Plugin מלא שנותן לך כלי ניטור בריאות לכל פרויקט — עם 2 Skills, 1 Hook, ו-1 Agent.

תרגיל 3: Reverse Engineering של Plugin פופולרי

🎯 תרגיל: ניתוח Plugin קיים
  1. בחר Plugin פופולרי מה-Marketplace (מעל 10,000 התקנות)
  2. פתח את קוד המקור שלו (רוב התוספים ב-open source)
  3. מפה את כל הרכיבים: כמה Skills? כמה Hooks? על אילו אירועים? יש Agents? MCP?
  4. קרא את ה-plugin.json — מה ה-minClaudeCodeVersion? מה ה-dependencies?
  5. קרא את ה-Hook scripts — מה הם עושים בדיוק? האם הם בטוחים?
  6. כתוב רשימה של 3 דברים שלמדת מהמבנה שלו שתוכל ליישם ב-Plugin שלך

התוצאה: הבנה עמוקה של איך Plugin מקצועי בנוי — learning by reading.

אם אתם עושים רק דבר אחד מהפרק הזה

אם אתם עושים רק דבר אחד מהפרק הזה 30 דקות

בנו Plugin אחד משלכם. לא חשוב כמה תוספים מהמדף תתקינו — אף אחד מהם לא יתאים בדיוק ל-Workflow שלכם. ה-Plugin שתבנו בעצמכם, עם 2-3 Skills ו-Hook אחד, ישנה את העבודה שלכם יותר מ-50 תוספים גנריים. זה כי אתם מכירים את העבודה שלכם, את הצרכים שלכם, ואת הבעיות שלכם — טוב יותר מכל מפתח Plugin בעולם. התחילו עם plugin.json, הוסיפו 2 Skills שחוסכים לכם זמן אמיתי, ו-Hook אחד שמגן עליכם. זה הכל.

בדוק את עצמך — 5 שאלות

בדוק את עצמך — 4 מתוך 5 = עברת
  1. למה Plugin עדיף על Skills + Hooks נפרדים כשצריך לשתף עם צוות? (רמז: חשוב על מה קורה כשחבר צוות חדש מצטרף)
  2. איך תבדוק אם Plugin קהילתי בטוח לפני שמתקינים אותו? (רמז: עץ ההחלטות — 4 שאלות)
  3. למה ${CLAUDE_PLUGIN_DATA} עדיף על hardcode לנתיב קבוע כמו /home/user/.my-data/? (רמז: חשוב על portability ועל קונפליקטים בין תוספים)
  4. מה ההשלכות של התקנת 15 תוספים עם Hooks פעילים? (רמז: Plugin Overhead Budget)
  5. למה "Last-Installed Wins" יכול להיות בעייתי, ומה הפתרון? (רמז: מה קורה כששני תוספים רושמים את אותו /command)

סיכום פרק 5

סיכום הפרק

Plugins הם השכבה שמחברת את כל מה שלמדתם עד עכשיו — Hooks, Agents, MCP ו-Skills — לחבילות שלמות שמתקינים בפעולה אחת. התובנה המרכזית: ה-Plugin הכי טוב הוא לא זה עם הכי הרבה התקנות, אלא זה שבנית בעצמך כי אתה מכיר את ה-Workflow שלך. למדנו שאבטחה היא לא אופציונלית (Hook scripts = קוד שרירותי על המחשב שלך), שניהול ביצועים הוא קריטי (Plugin Overhead Budget), ושהאקוסיסטם עדיין צעיר מספיק כדי שתהיו חלק ממנו כיוצרים — לא רק כצרכנים. בפרק הבא נעבור ל-Git Worktrees — שם ה-Plugins שבניתם ילוו אתכם לכל worktree אוטומטית.

צ'קליסט — סיכום פרק 5