10 שלב 4 — סיום ושילוב

Building Your Personal Toolkit — בניית ערכת הכלים האישית

הפרק האחרון. לאורך 9 פרקים למדת כל רכיב בנפרד — Hooks, Agents, MCP, Skills, Plugins, Worktrees, Memory, Security ו-Prompting מתקדם. עכשיו הגיע הזמן לחבר את הכל למערכת אחת שלמה: ערכת הכלים האישית שלך. לא אוסף אקראי של פיצ'רים — אלא ארכיטקטורה מתוכננת שמותאמת בדיוק לדרך שאתה עובד. זה ה-Capstone של כל הקורס.

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

בפרק הקודם (פרק 9: Advanced Prompting) למדת לשלוט ב-Claude Code ברמה הגבוהה ביותר — Plan Mode, אופטימיזציית Context, Effort Levels, שרשור סשנים ופרומפטינג מתקדם בעברית. עכשיו אתה יודע לדבר עם Claude Code בצורה מדויקת ויעילה. בפרק הזה — הפרק האחרון בקורס — תחבר את הכל. כל רכיב שלמדת ב-9 הפרקים הקודמים מתאחד למערכת אחת שלמה — ערכת הכלים האישית שלך. זהו ה-Capstone Deliverable של הקורס כולו. בקורס הבא (Course 4: Production & SDK) תיקח את ערכת הכלים הזו ותרחיב אותה לסביבת Production — עם Agent SDK ב-Python ו-TypeScript, GitHub Actions, Docker, Remote Control ופריסה בענן.

מילון מונחים — פרק 10
מונח באנגלית הסבר בעברית
Toolkit ערכת כלים — מערכת שלמה של רכיבי Claude Code (Hooks, Skills, Agents, MCP, Rules, Memory) שמותאמת אישית לזרימת העבודה שלך
Workflow Map מפת זרימת עבודה — מסמך שממפה כל משימה חוזרת לרכיב Claude Code המתאים לה, עם Priority Score
Command Library ספריית פקודות — אוסף מאורגן של Skills ב-.claude/commands/ עם שמות עקביים ותיקיות לפי תחום
Toolkit Manifest מסמך TOOLKIT.md שמתעד את כל רכיבי ערכת הכלים — גרסאות, תלויות, עלויות ולוח זמנים לעדכון
Toolkit Layers שכבות ערכת הכלים — 7 שכבות מ-Foundation (CLAUDE.md) דרך Automation (Hooks) ועד Security (Permissions + Sandbox)
Dependency Graph גרף תלויות — מפת הקשרים בין רכיבים: מה תלוי במה, מה צריך לרוץ לפני מה
ROI (Return on Investment) החזר השקעה — כמה זמן חסכת לעומת כמה זמן השקעת בבניית הרכיב. נוסחה: שעות_חיסכון_שבועי × 52 ÷ שעות_בנייה
Sunset הסרת רכיב שכבר לא בשימוש — חשוב כי רכיבים מתים מוסיפים עומס קוגניטיבי וצורכים Context
Morning Ritual דפוס של SessionStart Hook שמכין את סביבת העבודה אוטומטית בכל פתיחת סשן — Git Status, משימות, הקשר אתמול
Quality Pipeline שרשרת Skills שרצה לפני כל PR — בדיקות, ביקורת קוד, אבטחה, והריצה לסביבת Staging
Maturity Model מודל בשלות — 4 רמות מ-Ad-hoc (Level 1) עד Self-maintaining (Level 4). משמש למדידת התקדמות ה-Toolkit

The Toolkit Mindset — מחשיבת משתמש לחשיבת אדריכל

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

בתשעה פרקים למדת רכיבים בודדים: Hooks שאוכפים סטנדרטים בצורה דטרמיניסטית (פרק 1), Agents שמבצעים משימות מורכבות בהקשר מבודד (פרק 2), MCP שמחבר לשירותים חיצוניים — דאטאבייסים, דפדפנים, APIs (פרק 3), Skills שעוטפים תהליכים בפקודת /slash אחת (פרק 4), Plugins שמארזים הכל ביחד כחבילה להפצה (פרק 5), Worktrees שמאפשרים פיתוח מקבילי בבידוד מלא (פרק 6), Memory ששומר על הקשר בין סשנים דרך CLAUDE.md, Rules ו-Auto-Memory (פרק 7), Security שמגן על הכל עם Sandbox, Permissions ו-Network Isolation (פרק 8), ו-Advanced Prompting שמייעל את התקשורת עם Plan Mode, Effort Levels ו-Context Optimization (פרק 9).

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

Toolkit = Designed System, not a Random Collection — ערכת כלים אישית היא מערכת שלמה שמותאמת בדיוק לדרך שאתה עובד. לא אוסף אקראי של פיצ'רים שהפעלת פעם — אלא ארכיטקטורה מתוכננת שבה כל רכיב משרת מטרה ברורה ועובד בשיתוף עם השאר.

ה-Power Users הכי טובים של Claude Code לא מתחילים מאפס בכל סשן. הם פותחים טרמינל ונכנסים לסביבה שכבר מכירה את העבודה שלהם: CLAUDE.md שמכיל את כל ההקשר, Hooks שמפרמטים קוד ומונעים טעויות אוטומטית, Skills שמוכנים להפעלה מיידית, Agents שיודעים בדיוק מה לבדוק, ו-MCP Servers שמחוברים לכל מה שצריך. זה לא מקרי — זו ערכת כלים שנבנתה לאורך זמן ושמשתפרת כל שבוע.

שבע שכבות של Toolkit — The Toolkit Layers

כל Toolkit בנוי מ-7 שכבות, מהיסוד ועד ההגנה. כל שכבה בונה על מה שמתחתיה — ויחד הן יוצרות מערכת שלמה:

שכבה רכיב תפקיד פרק
1. Foundation CLAUDE.md + .claude/rules/ + Auto-Memory הקשר וידע — מה Claude יודע על הפרויקט שלך 7
2. Automation Hooks (Command + HTTP) אכיפה אוטומטית — מה שקורה תמיד, בלי לבקש 1
3. Commands Skills / Custom Commands זרימות עבודה לפי דרישה — /slash לכל תהליך חוזר 4
4. Intelligence Custom Agents עובדים מתמחים — סוכנים עם כלים, מודל ו-Effort מותאמים 2
5. Connectivity MCP Servers חיבור לעולם החיצון — מסדי נתונים, דפדפנים, APIs 3
6. Isolation Git Worktrees פיתוח מקבילי ובטוח — כל סשן בסביבה מבודדת 6
7. Security Permissions + Sandbox מעטפת הגנה — Guard Rails לכל מה שלמעלה 8

כל שכבה בונה על מה שמתחתיה. Hooks (שכבה 2) יכולים לאכוף כללים שמוגדרים ב-CLAUDE.md (שכבה 1). Skills (שכבה 3) יכולים להפעיל Agents (שכבה 4) שמשתמשים ב-MCP (שכבה 5) בתוך Worktree מבודד (שכבה 6). ו-Security (שכבה 7) עוטפת את הכל — מגבילה מה כל רכיב יכול לעשות ואילו קבצים הוא יכול לגשת אליהם.

7 → 1

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

חשוב: אין חובה לבנות את כל 7 השכבות ביום אחד. ערכת כלים טובה גדלה אורגנית. אולי תתחיל עם CLAUDE.md + Hook אחד + Skill אחד. אחרי שבוע תוסיף Agent. אחרי חודש תחבר MCP Server. הרעיון הוא שיש לך תכנית — אתה יודע מה כל שכבה עושה ומתי להוסיף אותה. זו בדיוק ההבחנה בין משתמש לאדריכל: משתמש מוסיף דברים כשנזכר, אדריכל מוסיף דברים כשהם נדרשים.

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

פתח מסמך ריק (קובץ טקסט, Notion, Google Docs — מה שנוח). כתוב את 7 השכבות ולצד כל אחת רשום: "יש לי" או "חסר". עבור על הרכיבים שבנית ב-9 הפרקים הקודמים. כמה שכבות כבר מוכנות? כמה עדיין צריכות עבודה? זה מצב הפתיחה שלך לפרק הזה.

עיצוב אוטומציית זרימת העבודה שלך

בינוני 20 דקות חינם מעשי

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

הנה מטריצת ההחלטות המרכזית — היא מתבססת על שני צירים: תדירות (יומי / שבועי / לפי צורך) ומורכבות (פשוט / מורכב):

פשוט (3-5 צעדים) מורכב (6+ צעדים)
יומי Hook — פורמט קוד, Lint, בדיקות Git Skill — Code Review, כתיבת תוכן, בדיקות
שבועי Skill — דוחות שבועיים, Cleanup Agent — ביקורות מעמיקות, Refactoring, ניתוח
לפי צורך פרומפט ידני — משימות חד-פעמיות MCP + Agent — שאילתות DB, בדיקות דפדפן, API חיצוני

הכלל פשוט: משימה שחוזרת לעתים קרובות ופשוטה = Hook (אוטומטי לחלוטין). משימה שחוזרת לעתים קרובות אבל מורכבת = Skill (הפעלה ידנית עם פקודה). משימה שבועית ומורכבת = Agent (סוכן מתמחה). משימה שדורשת שירותים חיצוניים = MCP. ומשימה חד-פעמית? פרומפט ידני — אם תחזור על עצמה, תהפוך אותה ל-Skill.

מיפוי התלויות — Dependency Graph

אחרי שמיפית את המשימות ושייכת כל אחת לרכיב, השלב הבא הוא לצייר את התלויות. שאל את עצמך:

כשאתה מבין את התלויות, אתה יכול לבנות בצורה חכמה: להתחיל מהרכיבים שאין להם תלויות (CLAUDE.md, Hooks בסיסיים), ואז להוסיף שכבות שבונות על מה שכבר קיים. זה סדר הבנייה הטבעי — וזו הסיבה שהקורס בנוי בסדר הזה.

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

צור מסמך בשם workflow-map.md. רשום את 10 המשימות שאתה מבצע הכי הרבה ב-Claude Code. לכל משימה כתוב: (1) תיאור קצר, (2) תדירות (יומי/שבועי/חודשי), (3) מורכבות (פשוט/מורכב), (4) הרכיב המתאים (Hook/Skill/Agent/MCP/פרומפט ידני), (5) תלויות (מה צריך שיעבוד כדי שזה יעבוד). זהו ה-Blueprint לערכת הכלים שלך — שמור אותו, נחזור אליו בסוף הפרק.

דוגמאות מייצגות — Workflow Map בפעולה

הנה Workflow Map של שי, Tech Lead בסטארטאפ ישראלי עם צוות של 6 מפתחים:

# משימה תדירות זמן ידני רכיב תלויות
1 פורמט קוד אחרי עריכה יומי ×30 30 שניות Hook Prettier
2 Code Review לפני PR יומי ×3 20 דקות Skill כללים ב-CLAUDE.md
3 הרצת בדיקות לקבצים שהשתנו יומי ×5 5 דקות Skill Vitest
4 ביקורת אבטחה שבועית שבועי ×1 2 שעות Agent OWASP rules
5 Deploy ל-Staging יומי ×2 15 דקות Skill Docker, Tests
6 Debug באג מדיווח לקוח שבועי ×3 45 דקות Agent + MCP Error Logs, DB
7 כתיבת Release Notes שבועי ×1 30 דקות Skill Git Log
8 Refactoring קוד ישן שבועי ×1 3 שעות Agent Architecture Docs
9 סנכרון תיעוד API שבועי ×2 20 דקות Skill Source Code
10 חסימת force push ל-main לפי צורך 0 (מניעה) Hook אין

שי חישב Priority Score וגילה שמשימות 1 (Auto-Format), 2 (Code Review) ו-5 (Deploy) הן בעדיפות הגבוהה ביותר — תדירות גבוהה כפול חיסכון זמן משמעותי. הוא התחיל עם שלושתן, ותוך שבוע היה לו Toolkit בסיסי שחסך שעה ביום. בשבוע השני הוסיף משימות 3, 4 ו-10. תוך חודש — כל 10 המשימות הפכו לרכיבי Toolkit.

תיעדוף חכם — מה לבנות קודם

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

Priority Score = Frequency × Time Saved × Error Risk
תדירות גבוהה × חיסכון זמן גדול × סיכון שגיאות גבוה = עדיפות ראשונה. משימה שרצה פעם בחודש, חוסכת דקה, ואין בה סיכון — אפשר לדחות.

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

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

מה הטעות: להתלהב ולנסות לבנות 10 Skills, 5 Hooks, 3 Agents ו-2 MCP Servers ביום אחד — וביום השני לא לגעת בכלום כי הכל מרגיש שבור. למה מפתה: כי אחרי 9 פרקים אתה מכיר את כל הרכיבים ומרגיש שאפשר. מה לעשות במקום: בנה 3 רכיבים בשבוע הראשון (לפי Priority Score). השתמש בהם שבוע שלם. רק אחרי שמאומתים — הוסף 3 נוספים. Toolkit טוב גדל אורגנית, לא בבנג גדול.

בניית ספריית פקודות — Reusable Command Libraries

בינוני 15 דקות חינם מעשי

ספריית פקודות (Command Library) היא אוסף מאורגן של Skills בתיקיית .claude/commands/ שמכסה את זרימות העבודה הנפוצות שלך. זה לא סתם כמה קבצים בתיקייה — זה מבנה מתוכנן עם כללי שמות עקביים, ארגון לפי תחום, ותיעוד ברור. בפרק 4 (Skills) למדת ליצור פקודות בודדות — עכשיו אתה בונה ספרייה שלמה.

ארגון לפי תחום — Directory Structure

המבנה המומלץ:

📚 מבנה ספריית פקודות

.claude/commands/
  content/
    write-blog.md       # /content-write-blog
    write-social.md     # /content-write-social
    write-email.md      # /content-write-email
  dev/
    test.md             # /dev-test
    review.md           # /dev-review
    deploy.md           # /dev-deploy
  data/
    report.md           # /data-report
    explore.md          # /data-explore
    clean.md            # /data-clean
  util/
    check-branch.md     # /util-check-branch
    cost-estimate.md    # /util-cost-estimate

שים לב לכלל השמות: [תחום]-[פעולה]. כל פקודות התוכן מתחילות ב-content-, כל פקודות הפיתוח ב-dev-, וכל פקודות הנתונים ב-data-. כשמקלידים / ב-Claude Code ומתחילים להקליד content, כל הפקודות הרלוונטיות צצות. זה לא סתם אסתטיקה — זה ארגון שחוסך זמן חיפוש ומאפשר Discovery טבעי.

מודל הבשלות — Command Library Maturity Model

רמה תיאור דוגמה
Level 1: Ad-hoc יוצרים פקודות לפי צורך, בלי מבנה 3 קבצי MD בתיקייה שטוחה, שמות לא עקביים
Level 2: Organized ארגון לפי תחום, שמות עקביים, תיעוד תיקיות content/, dev/, data/ עם כללי שמות
Level 3: Interconnected פקודות קוראות אחת לשנייה, משתפות Agents /dev-deploy קורא ל-/dev-test לפני Deploy
Level 4: Self-maintaining Hooks מאמתים פקודות, Memory עוקב אחרי שימוש Hook שמתריע כש-Skill לא הופעל חודש שלם

רוב המשתמשים נמצאים ב-Level 1-2. המטרה שלנו בפרק הזה היא להגיע לפחות ל-Level 2, ואידיאלית ל-Level 3. Level 4 הוא יעד לטווח ארוך — ונגיע אליו בסעיף של Toolkit Patterns מתקדמים.

פקודות פרמטריות — Parameterized Commands

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

📚 פקודה פרמטרית

/dev-deploy staging — מפרוס לסביבת Staging

/dev-deploy production — מפרוס לסביבת Production (עם בדיקות נוספות)

אותו Skill, התנהגות שונה. בגוף ההוראות תכתוב: "If the argument is 'production', run full test suite and require manual approval before deploying. If 'staging', run quick tests and deploy immediately."

Shared Utilities — פקודות עזר משותפות

צור פקודות עזר קטנות ש-Skills אחרים משתמשים בהן. זו הבסיס ל-Level 3 (Interconnected):

Self-Documenting Commands — פקודות שמתעדות את עצמן

כל Skill צריך להיות מתועד עצמאית — בלי שיצטרכו לקרוא את הקוד כדי להבין מה הוא עושה. איך?

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

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

פתח את תיקיית .claude/commands/ בפרויקט שלך (אם אין — צור). ארגן את ה-Skills שיצרת ב-9 הפרקים הקודמים לתיקיות לפי תחום. אם עדיין אין לך Skills — צור לפחות 3 מהתבנית הזו: (1) Skill ל-Code Review עם הכללים שלך, (2) Skill לכתיבת תוכן בעברית, (3) Skill ל-Git Summary יומי. שנה את שמות הקבצים כך שיתחילו בתחילית התחום (content-, dev-, data-). לכל Skill הוסף הערת עלות וגרסה.

Version Control לתיקיית .claude/

בינוני 10 דקות חינם מעשי

תיקיית .claude/ מכילה את ערכת הכלים שלך: הגדרות, פקודות, סוכנים, כללים, וזיכרון. היא צריכה להיות תחת Version Control — ב-Git, ביחד עם שאר הפרויקט. בפרק 7 (Memory) למדת איך CLAUDE.md נושא ידע בין סשנים. עכשיו אנחנו מבטיחים שהידע הזה — וכל הרכיבים שמלווים אותו — שמורים ומגובים.

למה? כי ערכת כלים שלא נגבית היא ערכת כלים שמסוכנת. דמיין שעדכנת Skill, משהו נשבר, ואין לך את הגרסה הקודמת. או שחבר צוות חדש מצטרף ולא מקבל את ה-Skills שהצוות בנה. Version Control פותר את שתי הבעיות:

מה לשים ב-Git ומה לא

קובץ / תיקייה ב-Git? למה
settings.json כן הגדרות הרשאות, Hooks, MCP — הצוות צריך אותם
commands/*.md כן כל ה-Skills — זה הליבה של ה-Toolkit
agents/*.md כן הגדרות סוכנים — שיתוף עם הצוות
rules/*.md כן כללי קוד ופרויקט — חיוניים לעקביות
memory/ תלוי אם מכיל מידע רגיש — לא. אם לא — כן. בדוק תוכן לפני Commit
TOOLKIT.md כן תיעוד ה-Toolkit — חיוני לצוות ולתחזוקה
worktrees/ לא תיקיית עבודה זמנית — כל מכונה יוצרת Worktrees שונים
⚠ טעות נפוצה: Commit של מידע רגיש ל-Git

מה הטעות: עשיית git add . על תיקיית .claude/ בלי לבדוק אם memory/ מכיל API Keys, Tokens, סיסמאות, או פרטי חיבור לדאטאבייס שנשמרו אוטומטית. למה מפתה: כי רוצים לשתף הכל עם הצוות ו-git add . זה מהיר. מה לעשות במקום: תמיד הגדר .gitignore עם .claude/memory/, .claude/settings.local.json ו-.claude/worktrees/ לפני ה-Commit הראשון. בדוק עם git diff --staged לפני כל Commit. בפרק 8 (Security) למדת את העקרונות — כאן הם חלים על Git.

📚 .gitignore מומלץ לתיקיית .claude/

# .gitignore entries for .claude/
.claude/memory/ # May contain sensitive auto-saved info
.claude/settings.local.json # Personal preferences
.claude/worktrees/ # Temporary worktree sessions

Branching Your Toolkit — ניסויים בטוחים

רוצה לנסות Agent חדש? Skill עם גישה חדשה? Hook מורכב? אל תעשה את זה ב-main. בפרק 6 (Worktrees) למדת לעבוד ב-Branches מבודדים — השתמש באותו עיקרון גם ל-Toolkit:

  1. git checkout -b toolkit/new-deploy-agent
  2. ערוך את Agent ב-.claude/agents/deploy-agent.md
  3. בדוק שהכל עובד — הפעל, בדוק, תקן
  4. אם מרוצה — git merge בחזרה ל-main
  5. אם לא — git branch -D toolkit/new-deploy-agent ושום דבר לא נפגע

הגישה הזו אומרת ש-Toolkit שלך לעולם לא נשבר ב-main. ניסויים קורים ב-Branch, ורק מה שעובד מגיע ל-Production.

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

ודא שתיקיית .claude/ שלך מכילה .gitignore מתאים. אם עדיין לא עשית git add לתיקייה — עשה עכשיו (חוץ מ-memory/ אם מכיל מידע רגיש). עשה Commit ראשון עם ההודעה: "Add Claude Code toolkit: commands, agents, rules, settings". מהרגע הזה, כל שינוי ב-Toolkit נשמר בהיסטוריה של Git.

שיתוף ערכת הכלים עם הצוות

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

ערכת כלים אישית היא חזקה. ערכת כלים צוותית היא כפל כוח. כשכל הצוות משתמש באותם Skills, Agents ו-Hooks — הפרודוקטיביות מכפילה את עצמה. כל חבר צוות חדש שמצטרף מקבל לא רק את הקוד, אלא את כל התהליכים האוטומטיים שהצוות בנה.

שלוש שיטות שיתוף

שיטה יתרון חיסרון מתאים ל-
Commit .claude/ ל-Repo הכי פשוט — git pull וזה שם צמוד לפרויקט אחד צוותים שעובדים על פרויקט אחד
Plugin הכי נייד — מתקינים עם פקודה אחת צריך לארוז ולתחזק כ-Plugin כלים שרלוונטיים לכמה פרויקטים
Template Repo הכי גמיש — כל פרויקט חדש מתחיל עם Toolkit צריך לסנכרן עדכונים ידנית ארגונים עם הרבה פרויקטים דומים

לרוב הצוותים, השיטה הראשונה (Commit ל-Repo) היא הבחירה הנכונה. היא פשוטה, לא דורשת תחזוקה נפרדת, וכל git pull מעדכן את ה-Toolkit. אם יש לך כלים שרלוונטיים לכמה פרויקטים — אז Plugin הוא הדרך. למדת לבנות Plugins בפרק 5 — עכשיו אתה יודע למה כדאי לבנות אותם.

הגדרות צוות לעומת הגדרות אישיות — Global vs Project

זה חשוב ולעתים גורם לבלבול. בפרק 8 (Security) למדת על ההיררכיה של הגדרות ואיך Enterprise managed policies עובדים. אותו עיקרון חל כאן:

⚠ טעות נפוצה: כפיית העדפות אישיות על הצוות

מה הטעות: שמים Vim Mode, Theme אישי, או keybindings מותאמים ב-.claude/settings.json של הפרויקט — ומכריחים את כל הצוות לעבוד עם ההגדרות שלך. למה מפתה: כי settings.json אחד לפרויקט נראה פשוט יותר מלנהל הפרדה. מה לעשות במקום: ב-.claude/settings.json שמים רק הגדרות צוות (Hooks, כללי אבטחה, MCP Servers). העדפות אישיות (Vim Mode, Theme, keybindings) שמים ב-~/.claude/settings.json — הגדרות גלובליות שרק אצלך.

Team Onboarding — קליטת חבר צוות חדש

כשחבר צוות חדש מתחיל, הוא מקבל:

  1. git clone — את הקוד ואת תיקיית .claude/ עם כל ה-Toolkit
  2. CLAUDE.md — ההקשר המלא של הפרויקט (Tech Stack, Architecture, Conventions)
  3. TOOLKIT.md — תיעוד של כל ה-Skills, Agents ו-Hooks הזמינים
  4. .claude/rules/ — כללי הקוד שנאכפים אוטומטית
  5. .claude/commands/ — כל הפקודות המוכנות לשימוש

Claude Code של החבר החדש מיד יודע: מה ה-Tech Stack, מה הסטנדרטים, אילו פקודות זמינות, ומה אסור לעשות. זמן ההכשרה נחתך דרמטית. במקום שבוע של "איך עובדים פה?" — יום אחד עם Toolkit מוכן.

80%

הפחתה בזמן Onboarding כשיש Toolkit צוותי מתועד. חבר צוות חדש שמקבל .claude/ מסודר עם Skills ו-CLAUDE.md מקיף מתחיל לייצר ערך ביום הראשון במקום אחרי שבוע. (דוגמאות מייצגות, מבוסס על משוב צוותי פיתוח, 2026)

Plugin Packaging — אריזה להפצה

אם ה-Toolkit שלך שימושי מעבר לפרויקט אחד, שקול לארוז אותו כ-Plugin (למדת על Plugins בפרק 5). Plugin יכול לכלול Skills, Agents, Hooks ו-MCP Servers — כחבילה אחת שמתקינים עם פקודה אחת. עם יותר מ-9,000 Plugins במארקטפלייס של Claude Code נכון למרץ 2026, יש קהל רחב לכלים שימושיים.

למשל: אם בנית Toolkit מצוין לצוות שיווק בעברית — ארוז אותו כ-Plugin בשם hebrew-marketing-toolkit. כל משווק דיגיטלי ישראלי שמשתמש ב-Claude Code יוכל להתקין אותו בפקודה אחת ולקבל Skills לכתיבת תוכן, SEO Audit, ומעקב מתחרים — מוכן לשימוש.

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

כתוב רשימה של 3 דברים מה-Toolkit שלך שיכולים לעזור לאחרים מחוץ לצוות. האם כדאי לארוז אותם כ-Plugin? אם כן — רשום ב-TOOLKIT.md תחת "Future: Plugin Packaging". לא צריך לעשות את זה עכשיו — רק לתכנן.

The Complete Integration — 7 שכבות בפעולה

מתקדם 15 דקות ~$1 לבנייה מעשי

לפני שנצלול לתוך 3 Toolkits ספציפיים (שיווק, פיתוח, נתונים), בוא נראה איך כל 7 השכבות מתחברות ב-settings.json אחד. זהו ה-Capstone Demo של הקורס — קובץ הגדרות אחד שמדגים את הכל:

📚 settings.json — כל 7 השכבות ביחד

{
  "permissions": {
    "allow": [
      "Read", "Write", "Edit", "Glob", "Grep",
      "Bash(npm test*)", "Bash(npm run*)", "Bash(git *)",
      "mcp__playwright__*", "mcp__github__*"
    ],
    "deny": [
      "Bash(rm -rf *)", "Bash(git push --force*)"
    ]
  },

  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "npx prettier --write \"$CLAUDE_FILE_PATH\" 2>/dev/null || true"
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": "echo \"$CLAUDE_TOOL_INPUT\" | grep -qE 'git push.*(--force|-f).*main' && exit 1 || exit 0"
      }
    ],
    "SessionStart": [
      {
        "command": "git status --short && echo '---' && cat TODO.md 2>/dev/null || echo 'No TODO.md found'"
      }
    ],
    "PostCompact": [
      {
        "command": "cat .claude/rules/critical-context.md 2>/dev/null || true"
      }
    ]
  },

  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic/mcp-playwright"]
    }
  }
}

בואו נפרק את הקובץ הזה לפי שכבות:

שכבה מה ב-settings.json מה ב-תיקיית .claude/
1. Foundation — CLAUDE.md + rules/*.md + memory/
2. Automation hooks.PostToolUse, hooks.PreToolUse, hooks.SessionStart, hooks.PostCompact —
3. Commands — commands/dev/*, commands/content/*
4. Intelligence — agents/security-reviewer.md, agents/test-runner.md
5. Connectivity mcpServers.playwright —
6. Isolation worktree.sparsePaths (optional) worktrees/ (auto-generated)
7. Security permissions.allow, permissions.deny rules/security-policy.md

שים לב: settings.json מטפל בשכבות 2, 5 ו-7 (Hooks, MCP, Security). תיקיית .claude/ מטפלת בשכבות 1, 3 ו-4 (Foundation, Commands, Agents). ושכבה 6 (Isolation) היא היברידית — הגדרות ב-settings.json ותיקיות עבודה שנוצרות אוטומטית. כשכל החלקים במקום, אתה פותח סשן ומקבל: הקשר מלא (שכבה 1), פורמט אוטומטי (שכבה 2), פקודות מוכנות (שכבה 3), סוכנים מתמחים (שכבה 4), דפדפן מחובר (שכבה 5), בידוד לפיתוח מקבילי (שכבה 6), והגנה מלאה (שכבה 7).

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

פתח את .claude/settings.json שלך. בדוק: האם יש לך לפחות Hook אחד? Permission rule אחד? MCP Server אחד? אם חסר — הוסף מה-דוגמה למעלה. הנה המינימום: Hook של Auto-Format (PostToolUse), חסימת force-push (PreToolUse), ו-Morning Ritual (SessionStart). שלושה Hooks אלה הם הבסיס שכל Toolkit צריך.

Real Toolkit: אוטומציית שיווק דיגיטלי

מתקדם 15 דקות ~$2-3 לבנייה מעשי

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

שכבה 1: Foundation — CLAUDE.md

📚 CLAUDE.md לצוות שיווק

# Marketing Team — Toolkit Context

## Brand Voice
- Tone: Professional but approachable. Never salesy or aggressive
- Hebrew: formal-casual (פורמלי-מזדמן). Always "אתה" not "אתם"
- English terms: use Hebrew explanation on first mention

## Content Calendar
- Blog: 3 posts/week (Mon, Wed, Fri) — 800-1200 words Hebrew
- Social: 5 posts/week — 1 per platform per day
- Newsletter: Weekly, Thursday morning

## SEO Requirements
- Target: 3 Hebrew keywords per blog post
- Meta description: 150-160 chars Hebrew
- H2 tags must contain at least 1 target keyword

## Target Audience
- Primary: Israeli SMB owners, ages 30-55
- Secondary: Marketing managers in Israeli tech companies
- Pain points: limited budget, time constraints, Hebrew content scarcity

שכבה 2: Automation — Hooks

שכבה 3: Commands — Skills

פקודה תיאור מודל עלות משוערת
/content-blog מחולל פוסט בלוג בעברית — 800-1200 מילים, SEO-optimized Sonnet ~$0.15
/content-social פוסט לרשתות חברתיות — מותאם לפלטפורמה (FB/IG/LinkedIn/X) Sonnet ~$0.08
/seo-audit ניתוח SEO של URL — מילות מפתח, Meta Tags, מבנה, מהירות Sonnet ~$0.20
/competitor-check בדיקת פעילות אחרונה של מתחרה — תוכן חדש, קמפיינים, שינויים Sonnet ~$0.25
/campaign-report דוח מדדי קמפיין שבועי — עם טבלאות וגרפים בטקסט Sonnet ~$0.15

שכבה 4: Intelligence — Agents

שכבה 5: Connectivity — MCP

~15

קבצי הגדרה בסך הכל: 5 Skills ב-commands/, 3 Agents ב-agents/, settings.json עם Hooks ו-MCP, CLAUDE.md עם ההקשר, ו-TOOLKIT.md עם התיעוד. זה כל מה שצריך כדי להפוך צוות שיווק לצוות שעובד עם AI בכל שלב.

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

אם אתה עובד בשיווק דיגיטלי — התחל לבנות את ה-Toolkit הזה. צור CLAUDE.md עם Brand Voice ו-Content Calendar. צור Skill אחד (מתוך 5) — /content-blog הוא המקום הטוב להתחיל כי הוא הכי נפוץ. אם אתה לא בשיווק — קפוץ ל-Toolkit הבא (Full-Stack או Data) או התאם את המבנה לתחום שלך.

Real Toolkit: פיתוח Full-Stack

מתקדם 15 דקות ~$3-5 לבנייה מעשי

ערכת הכלים של מפתח Full-Stack היא אולי המורכבת ביותר — כי מפתח נוגע בכל שכבה של המערכת: Frontend, Backend, Database, Deployment, Testing, ו-Security. הנה Toolkit שמכסה את הכל.

CLAUDE.md — ההקשר הטכני

📚 CLAUDE.md למפתח Full-Stack

# Full-Stack Project Context

## Tech Stack
- Frontend: Next.js 15 + React 19 + Tailwind CSS 4
- Backend: Next.js API Routes + Supabase
- Database: PostgreSQL (via Supabase)
- Deployment: Vercel
- Testing: Vitest + Playwright
- Language: TypeScript (strict mode)

## Architecture
- App Router (not Pages Router)
- Server Components by default, Client Components only when needed
- All API routes return { data, error } format
- Database access only through Supabase client (never raw SQL in app code)

## Testing Requirements
- Unit tests for all utility functions
- Integration tests for API routes
- E2E tests for critical user flows
- Minimum 80% coverage for new code

## Deployment Pipeline
- Lint -> Type Check -> Test -> Build -> Deploy to Preview -> Smoke Test -> Promote to Prod

Hooks — אכיפה אוטומטית

אירוע פעולה למה
PostToolUse (Write/Edit) Prettier + ESLint על כל קובץ שנערך קוד מפורמט ונקי תמיד, אוטומטית
PreToolUse (Bash) חסימת git push --force ל-main מניעת הרס של ההיסטוריה ב-Production Branch
SessionStart הרצת tsc --noEmit — Type Check וידוא שהפרויקט מתקמפל לפני שמתחילים לעבוד
PostCompact הזרקה מחדש של API Endpoints ו-DB Schema אחרי Compaction, המידע הקריטי לא נאבד (למדת על זה בפרק 9)

Skills — זרימות עבודה

פקודה תיאור מודל Fork
/dev-test הרצת בדיקות רק לקבצים שהשתנו — Vitest עם --changed Sonnet כן
/dev-review Code Review עם פוקוס על אבטחה + ביצועים + נגישות Opus כן
/dev-deploy Pipeline מלא: Lint → Test → Build → Deploy → Smoke Test Sonnet לא
/dev-migrate Database Migration עם Rollback Plan מובנה Opus כן
/dev-api-doc יצירת תיעוד API אוטומטי מתוך הקוד Sonnet כן

Agents — עובדים מתמחים

MCP — חיבורים חיצוניים

.claude/rules/ — כללים מפורטים

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

אם אתה מפתח Full-Stack — קח את המבנה הזה והתאם אותו ל-Tech Stack שלך. החלף Next.js ב-Framework שאתה משתמש בו, Supabase ב-Database שלך, Vercel ב-Hosting שלך. התחל עם CLAUDE.md + Hook אחד (Auto-Format) + Skill אחד (/dev-review). הוסף שכבות בהדרגה.

Real Toolkit: ניתוח נתונים

מתקדם 12 דקות ~$2-3 לבנייה מעשי

ערכת כלים לאנליסט נתונים ממוקדת ב-SQL, דוחות, ויזואליזציה ואיכות נתונים. זה התחום שבו ה-ROI של Toolkit הוא הגבוה ביותר — כי עבודת נתונים מלאה במשימות חוזרות: אותו סוג שאילתות, אותו סוג דוחות, אותם בדיקות איכות.

CLAUDE.md — הקשר הנתונים

📚 CLAUDE.md לאנליסט נתונים

# Data Analysis Context

## Data Sources
- Primary: PostgreSQL (production-replica, read-only)
- Secondary: CSV exports from Google Analytics, Mixpanel
- Reference: Google Sheets with KPI definitions

## Common SQL Patterns
- Always use CTEs (WITH) instead of subqueries
- Date ranges: use BETWEEN with explicit timezone (Asia/Jerusalem)
- Aggregations: always include row count alongside averages

## Report Templates
- Weekly: KPI dashboard, funnel metrics, cohort analysis
- Monthly: Executive summary, trend analysis, recommendations

## Data Quality Rules
- NULL threshold: report if any column has more than 5% NULLs
- Duplicate check: always verify primary key uniqueness
- Outlier detection: flag values more than 3 standard deviations from mean

Hooks — הגנה על נתונים

Skills — עבודת נתונים

פקודה תיאור מודל
/data-report דוח שבועי מתוך שאילתות סטנדרטיות — מפורמט כ-Markdown עם טבלאות Sonnet
/data-explore ניתוח חקירתי (EDA) על טבלה — מבנה, התפלגות, חריגים, מתאמים Sonnet
/data-clean Pipeline ניקוי נתונים — NULLs, Duplicates, Outliers, פורמט, ונרמול Sonnet
/data-viz יצירת קוד ויזואליזציה — Python (matplotlib/plotly) או SQL Charts Sonnet
/data-query מתרגם שפה טבעית (עברית/אנגלית) לשאילתת SQL מותאמת ל-DB שלך Opus

Agents — מומחי נתונים

MCP — חיבורי נתונים

💡 חישוב ROI ל-Toolkit

זמן בנייה: 4-8 שעות (בנייה ראשונית של כל הרכיבים). חיסכון שבועי: 5-15 שעות (בהתאם לנפח העבודה). Break-even: תוך שבוע-שבועיים. אחרי שבועיים — כל שעה שנחסכת היא רווח נטו. על פני שנה, Toolkit שחוסך 10 שעות שבועיות = 520 שעות — 13 שבועות עבודה. זה לא הפרזה — זה חשבון פשוט.

בדיקה ואיטרציה על ערכת הכלים

בינוני 10 דקות חינם מעשי

ערכת כלים היא לא פרויקט שמסיימים ושוכחים. היא מערכת חיה שמשתנה ומשתפרת — כמו קוד. הגישה הנכונה היא: בנה, בדוק, שפר, חזור. בזה, Toolkit לא שונה מקוד Production — הוא צריך בדיקות, Feedback Loop, ותחזוקה שוטפת.

אסטרטגיית בדיקות

לכל רכיב ב-Toolkit, הגדר מה מצב הצלחה נראה. זו טבלת "Definition of Done" שלך:

רכיב Definition of Done איך לבדוק
Hook Auto-Format כל קובץ TS שClaude עורך צריך לצאת מפורמט ערוך קובץ → הרץ Prettier → 0 שגיאות
Skill /dev-review הפלט כולל לפחות 3 קטגוריות: אבטחה, ביצועים, קריאות הפעל על קובץ לדוגמה → בדוק מבנה הפלט
Agent security-reviewer מזהה Hardcoded Secret בקוד בדיקה הכנס Secret מכוון לקובץ → בדוק שהAgent מדווח
MCP Playwright צילום מסך מתקבל תוך 10 שניות בקש צילום של google.com → מדוד זמן

לולאת המשוב — The Feedback Loop

  1. שבוע 1: השתמש ב-Toolkit שבנית כל יום. רשום כל נקודת חיכוך: "ה-Skill לא נתן את מה שרציתי", "ההוק איטי מדי", "חסר לי Skill ל-X"
  2. שבוע 2: תקן את 3 נקודות החיכוך הגדולות ביותר. הוסף Skills חדשים שהתגלו כנחוצים
  3. שבוע 3: חזור על הלולאה. המטרה: אפס נקודות חיכוך
  4. כל חודש: Review מלא — מה עובד, מה לא, מה חדש ב-Claude Code שאפשר לשלב

מה למדוד — Toolkit Metrics

מדד איך למדוד מה אומר
תדירות שימוש Session Logging Hook שרושם כל הפעלת Skill אילו Skills באמת שימושיים — ואילו "מתים"
שיעור כשלון Error Logging — כמה פעמים Agent/Hook נכשל מה צריך תיקון דחוף
צריכת Context /context לפני ואחרי הפעלת Skill אילו Skills "אוכלים" יותר מדי Context — שקול fork: true
זמן ביצוע תיעוד זמן הפעלה של כל Skill מה איטי מדי ואולי צריך מודל קל יותר (Sonnet במקום Opus)
עלות חודשית דשבורד העלויות ב-claude.ai האם ה-ROI חיובי? אם עולה יותר ממה שחוסך — משהו לא נכון

Sunset — הסרת רכיבים מיותרים

זה קריטי ולעתים מוזנח: אם Skill לא הופעל חודש שלם — הסר אותו. רכיבים "מתים" מוסיפים עומס קוגניטיבי (כשמחפשים פקודה), צורכים Context (ב-Auto-Invoke Skills, כפי שלמדת בפרק 4), ומסבכים תחזוקה. Less is more. Toolkit עם 8 Skills שעובדים מצוין עדיף על Toolkit עם 25 Skills שרובם מיושנים.

שדרוג עם גרסאות חדשות

Claude Code מתעדכן לפחות פעמיים בשבוע — מגרסה 2.1.0 בינואר 2026 ועד גרסה 2.1.81 במרץ 2026, נשלחו 81 עדכונים בשלושה חודשים. כשיוצא עדכון, שאל: "האם הפיצ'ר החדש משפר רכיב קיים ב-Toolkit?" למשל:

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

צור קובץ toolkit-feedback.md. כתוב 3 סעיפים: "מה עובד טוב", "מה צריך שיפור", "מה חסר". זה הבסיס ללולאת המשוב שלך. עדכן את הקובץ בסוף כל שבוע עבודה.

Toolkit Patterns מתקדמים

מתקדם 15 דקות ~$1-3 לבנייה מעשי

עכשיו שיש לך את הבסיס — בוא נדבר על דפוסים (Patterns) מתקדמים. אלה שילובים של כמה רכיבים שביחד יוצרים יכולות שאף רכיב לא יכול לספק לבד. כאן כל מה שלמדת ב-9 הפרקים הקודמים מתחבר לתמונה שלמה.

Pattern 1: The Morning Ritual — טקס הבוקר

SessionStart Hook שמכין את סביבת העבודה אוטומטית. שכבות מעורבות: Foundation (Memory) + Automation (Hook) + Connectivity (MCP).

📚 The Morning Ritual

הנה מה שקורה כשאתה פותח סשן Claude Code בבוקר:

  1. Git Status: בודק מה השתנה מאתמול — Commits חדשים, PRs פתוחים, Issues שהוקצו לך
  2. Calendar Check: טוען את המשימות להיום מ-Google Sheets (דרך MCP) או מ-TODO.md
  3. Memory Recall: מזכיר לך מה עבדת עליו אתמול (דרך Auto-Memory, פרק 7) — "אתמול עבדת על Migration של טבלת Users, הגעת לשלב הבדיקות"
  4. Suggestion: מציע במה להתחיל — "יש PR שמחכה ל-Review כבר 2 ימים. תרצה לטפל בזה?"

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

Pattern 2: The Quality Pipeline — צינור איכות

שרשרת Skills שרצה לפני כל Pull Request. שכבות מעורבות: Commands (Skills) + Intelligence (Agents) + Automation (Hooks).

📚 Quality Pipeline Flow

/submit-pr → מפעיל בסדר:

  1. /dev-test — הרצת בדיקות לקבצים שהשתנו. אם נכשל — עוצר
  2. /dev-review — Code Review אוטומטי. אם יש Severity: Critical — עוצר
  3. /security-check — ביקורת אבטחה (פרק 8). אם יש פגיעות — עוצר
  4. /dev-deploy staging — Deployment ל-Staging. אם נכשל — עוצר
  5. אם הכל עבר — פותח PR אוטומטית עם סיכום של כל הבדיקות

פקודה אחת — /submit-pr — מחליפה 30 דקות של בדיקות ידניות. זה Level 3 של ה-Maturity Model: פקודות שקוראות אחת לשנייה.

Pattern 3: The Content Machine — מכונת התוכן

אורקסטרציה שלמה ליצירת תוכן. שכבות מעורבות: כל 7 השכבות.

  1. Brief: מקבל נושא וקהל יעד
  2. Research: WebSearch מוצא מאמרים רלוונטיים ומגמות (Connectivity)
  3. Outline: Plan Mode יוצר מתווה מפורט (Advanced Prompting, פרק 9)
  4. Draft: content-writer Agent כותב את הטיוטה (Intelligence)
  5. Review: content-reviewer Agent בודק Brand Voice, SEO, ואיכות (Intelligence + Foundation)
  6. Publish: Deployment Skill מפרסם לאתר (Commands + Automation)

כל הצינור הזה כ-Skill אחד: /content-pipeline "נושא: טרנדים בשיווק דיגיטלי 2026, קהל: בעלי עסקים קטנים". מטיוטה לפרסום בפקודה אחת.

Pattern 4: The Debug Detective — הבלש

כשמדווחים על באג. שכבות מעורבות: Connectivity (MCP) + Intelligence (Agent) + Commands (Skill).

📚 The Debug Detective

/investigate-bug "User can't login after password reset"

  1. קורא Error Logs (דרך MCP) — מזהה את ה-Error הרלוונטי
  2. מזהה קבצי קוד רלוונטיים — Auth Module, Password Reset Flow
  3. משגר Debug Agent שמנתח את הקוד ומשחזר את הבעיה
  4. מציע Fix עם Test Case — "שנה שורה 42 ב-auth.ts, הנה הבדיקה שמוודאת שזה עובד"

מדיווח על באג לתיקון מוצע — בפקודה אחת.

Pattern 5: The Learning System — מערכת שלומדת

זה ה-Pattern הכי מתקדם — ערכת כלים שמשפרת את עצמה. שכבות מעורבות: Automation (Hooks) + Intelligence (Agent) + Foundation (Memory).

ה-Toolkit לא רק עובד בשבילך — הוא מלמד אותך איך לשפר אותו. זה Level 4 של ה-Maturity Model: Self-maintaining.

💡 Tip: שילוב Patterns

ה-Patterns לא בלעדיים — אפשר לשלב אותם. למשל: Morning Ritual (Pattern 1) מתחיל את היום, Quality Pipeline (Pattern 2) רץ לפני כל PR, Content Machine (Pattern 3) מייצרת תוכן, Debug Detective (Pattern 4) מטפל בבאגים, ו-Learning System (Pattern 5) מנתח את הכל בסוף השבוע. ביחד, הם יוצרים מערכת שמכינה, מגינה, מייצרת, מתקנת, ולומדת — Toolkit שלם שמשתפר בכל שבוע.

Pattern Anti-Patterns — מה לא לעשות

בעודך בונה Patterns מתקדמים, היזהר מהטעויות הנפוצות:

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

בחר Pattern אחד מתוך 5 שהכי רלוונטי לעבודה שלך. כתוב Skill ראשוני שמיישם אותו — לא צריך שיהיה מושלם, רק שיעבוד. אם בחרת Morning Ritual — צור SessionStart Hook שמציג Git Status ואת ה-TODO שלך. אם בחרת Quality Pipeline — צור Skill בשם /submit-pr שמפעיל /dev-test ואז /dev-review ברצף. התחל קטן, שפר עם הזמן.

The Toolkit Manifest — השרטוט הסופי

בינוני 15 דקות חינם מעשי

כל Toolkit צריך Manifest — מסמך TOOLKIT.md שמתעד את כל הרכיבים, הקשרים ביניהם, עלויות ולוח זמנים לעדכון. בלי Manifest, ערכת הכלים הופכת לקופסה שחורה שרק אתה מבין. עם Manifest, כל אחד — כולל אתה בעוד 3 חודשים — יכול להבין מה יש, למה זה שם, ואיך זה עובד.

המבנה המומלץ

📚 TOOLKIT.md Template

# My Claude Code Toolkit
## Last Updated: 2026-03-23
## Owner: [Your Name]

## Components

### Hooks (X active)
| Hook | Event | What it does | Depends on |
|------|-------|-------------|------------|
| auto-format | PostToolUse | Runs Prettier on every edited file | Prettier installed |
| block-force-push | PreToolUse | Blocks git push --force to main | None |
| session-logger | SessionStart | Logs session start to audit file | None |

### Skills (X commands)
| Command | Description | Model | Fork | Est. Cost |
|---------|-------------|-------|------|-----------|
| /dev-review | Code review with security focus | Opus | Yes | ~$0.30 |
| /dev-test | Run tests for changed files | Sonnet | Yes | ~$0.10 |
| /content-blog | Hebrew blog post generator | Sonnet | Yes | ~$0.15 |

### Agents (X defined)
| Agent | Purpose | Model | Effort | Tools | Read-only? |
|-------|---------|-------|--------|-------|-----------|
| security-reviewer | OWASP audit | Opus | High | Read, Grep, Glob | Yes |
| test-runner | Run and report tests | Haiku | Low | Bash, Read | Yes |

### MCP Servers (X connected)
| Server | What it provides | Auth required |
|--------|-----------------|--------------|
| Playwright | Browser testing, screenshots | No |
| PostgreSQL | Database access (read-only) | Connection string |

### Rules (X files)
| File | Scope | What it enforces |
|------|-------|-----------------|
| typescript-style.md | *.ts, *.tsx | Strict TS rules |
| api-guidelines.md | */api/* | API design standards |

## Architecture Diagram
[How components connect — which Skills use which Agents, which Hooks depend on what]

## Cost Estimate
- Light usage (~20 skill invocations/day): ~$3-5/day
- Heavy usage (~50 skill invocations/day): ~$8-12/day
- Monthly range: $60-250 depending on usage

## Review Schedule
- Weekly: Check feedback log, fix friction points
- Monthly: Full review — sunset unused, add new
- Quarterly: ROI assessment, alignment check, Claude Code changelog review
- Per Claude Code release: Evaluate new features for integration

ה-Manifest הזה הוא לא תיעוד בשביל תיעוד. הוא כלי עבודה:

Review הרבעוני — The Quarterly Toolkit Audit

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

עדכן את ה-Manifest אחרי כל Quarterly Audit. שנה את התאריך ב-"Last Updated" וכתוב סעיף קצר על מה השתנה ולמה.

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

צור קובץ TOOLKIT.md בתיקיית .claude/. העתק את התבנית למעלה ומלא אותה עם הרכיבים שבנית לאורך הקורס. לא צריך שיהיה מושלם — אפילו Manifest חלקי עדיף על שום Manifest. מלא את הטבלאות, חשב את הערכות העלות, ותן שם לכל רכיב. זה ה-Capstone Deliverable של הקורס — מסמך שמתעד את כל מה שבנית ב-10 פרקים.

מה הלאה — Course 4 Preview

מתחילים 5 דקות חינם תיאוריה

סיימת את הקורס. יש לך ערכת כלים אישית שלמה. אתה Power User אמיתי של Claude Code. אז מה הלאה?

קורס 4: Claude Code — Production & SDK לוקח את הכל ומרחיב לסביבת Production. במקום להשתמש ב-Claude Code כמשתמש — אתה בונה מערכות שמשתמשות ב-Claude Code בתור מנוע.

מה תלמד בקורס 4

נושא מה זה למה זה חשוב
Agent SDK Python (v0.1.48) & TypeScript (v0.2.71) SDKs לבניית אפליקציות מבוססות Claude Code בנה כלים מותאמים עם אותו מנוע שמריץ Claude Code
Headless Mode הרצת Claude Code בלי ממשק — דגלי -p ו---bare אינטגרציה עם CI/CD, סקריפטים, ו-Automation Pipelines
GitHub Actions anthropics/claude-code-action@v1 — ביקורת קוד אוטומטית ב-PR Claude Code בודק כל PR שנפתח — אוטומטית, בלי מאמץ
Remote Control & Channels ניהול Claude Code מ-Telegram, Discord, דפדפן או אפליקציה שליטה מכל מכשיר, בכל מקום — כולל מהטלפון
Docker Deployment הרצת Claude Code בקונטיינרים לסביבות Production בידוד, אבטחה, וסקיילביליות
Cloud Providers Bedrock, Vertex, Foundry — שימוש ב-Claude דרך ספקי ענן Enterprise: Compliance, SLA, ושליטה ארגונית
MCP Servers at Scale בניית והפצת MCP Servers משלך תפרוס כלים שאחרים (וארגונים) יוכלו להשתמש בהם
Voice Mode אינטגרציה עם Voice Mode למערכות מתקדמות (20 שפות) ממשק קולי לכלים ו-Agents שבנית

הקורס הזה הפך אותך מ-User ל-Power User. הקורס הבא הופך אותך מ-Power User ל-Builder. מי שסיים את הקורס הזה מוכן לחלוטין.

User → Architect → Builder

קורס 1-2: למדת להשתמש ב-Claude Code (User). קורס 3 (זה): למדת לתכנן ולבנות מערכות (Architect). קורס 4: תלמד לפרוס, להפיץ ולהרחיב מערכות ב-Production (Builder).

Frameworks להחלטות — מתי כל רכיב

בינוני 5 דקות
מסגרת החלטה: Hook vs Skill vs Agent vs Prompt

ההחלטה הכי נפוצה בבניית Toolkit: איזה רכיב לבחור למשימה?

שאלה אם כן אם לא
המשימה צריכה לרוץ בכל פעם שמשהו קורה? → Hook (פרק 1) המשך לשאלה הבאה
המשימה חוזרת לפחות פעם ביום? → Skill (פרק 4) המשך לשאלה הבאה
המשימה דורשת ניתוח מעמיק עם מודל חזק? → Agent (פרק 2) המשך לשאלה הבאה
המשימה דורשת שירותים חיצוניים? → MCP (פרק 3) המשך לשאלה הבאה
משימה חד-פעמית או ניסיון ראשון? → פרומפט ידני (פרק 9) שקול מחדש — אולי מתאים Hook/Skill
מסגרת החלטה: Fork או לא Fork?
שאלה אם כן
ה-Skill קורא הרבה קבצים (>10)? fork: true
ה-Skill עלול להיכשל ולזהם את ההקשר? fork: true
ה-Skill צריך גישה לתוצאות שיחה קודמת? fork: false
ה-Skill קצר וצריך להשפיע ישירות על השיחה? fork: false
מסגרת החלטה: בחירת מודל לכל רכיב
סוג רכיב Haiku (זול ומהיר) Sonnet 4.6 (מאוזן) Opus 4.6 (חזק ויקר)
Hooks — — — (Hooks הם Shell, לא LLM)
Skills פורמט, Lint, סיכומים כתיבה, Reviews, דוחות ארכיטקטורה, ניתוח מורכב
Agents test-runner, validator deploy, report-writer security-review, SQL expert

כלל אצבע: התחל עם Sonnet 4.6 לכל דבר. עבור ל-Opus רק כשאתה רואה שהאיכות לא מספיקה. עבור ל-Haiku כשמהירות ועלות חשובות יותר מאיכות. השתמש ב-Effort Levels (פרק 9) לכוונון נוסף.

שגרת עבודה — תחזוקת Toolkit

מעשי 5 דקות קריאה
שגרת עבודה מאוחדת — Toolkit + כל הקורס

זו השגרה הסופית שמאחדת את כל הפרקים. בנוסף לשגרות מפרקים קודמים (פרק 7: Auto-Memory, פרק 8: Security Audit, פרק 9: Plan Mode + Compact + Effort), הוסף את פעולות תחזוקת ה-Toolkit:

יומי (5 דקות)

שבועי — "שעת Toolkit" (30-60 דקות)

חודשי (2-3 שעות)

רבעוני (חצי יום)

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

מעשי 60-90 דקות (לכולם) ~$2-4 לביצוע
🎯 תרגיל 1: בנה Workflow Map מלא (Beginner)
  1. רשום 10 משימות שאתה מבצע חוזר ב-Claude Code (או בכלל בעבודה)
  2. לכל משימה: תדירות (יומי/שבועי/חודשי), מורכבות (1-5), זמן ביצוע ידני, רכיב מתאים (Hook/Skill/Agent/MCP)
  3. חשב Priority Score לכל משימה: Frequency × Time_Saved × Error_Risk
  4. סדר לפי Priority Score — 3 הראשונות הן הרכיבים שתבנה ראשון
  5. צייר Dependency Graph — מה תלוי במה
  6. שמור ב-workflow-map.md בתיקיית הפרויקט
🎯 תרגיל 2: בנה Toolkit שלם לתחום שלך (Intermediate)
  1. בחר תחום: שיווק, פיתוח, נתונים, או אחר
  2. צור CLAUDE.md עם הקשר מלא: Tech Stack, סטנדרטים, קהל יעד, כללים
  3. צור לפחות 3 Skills ב-.claude/commands/ עם שמות עקביים ותיקיות מסודרות
  4. צור לפחות Agent אחד ב-.claude/agents/ עם מודל, Effort, ו-disallowedTools מתאימים
  5. הגדר לפחות Hook אחד ב-settings.json
  6. בדוק כל רכיב — הפעל ובדוק שעובד כמצופה
  7. תעד הכל ב-TOOLKIT.md
🎯 תרגיל 3: הטמע Toolkit Pattern מתקדם (Advanced)
  1. בחר Pattern: Morning Ritual, Quality Pipeline, Content Machine, Debug Detective, או Learning System
  2. תכנן את ה-Pattern: אילו רכיבים משתתפים, מה הסדר, מה קורה בכשלון (Fallback Plan)
  3. בנה את ה-Skill/Hook המרכזי שמפעיל את ה-Pattern
  4. בנה את הרכיבים המשלימים (Agents, MCP Connections)
  5. הרץ את ה-Pattern 3 פעמים לפחות — בדוק שהכל עובד, תקן מה שצריך
  6. תעד את ה-Pattern ב-TOOLKIT.md כולל: רכיבים, זרימה, עלות משוערת, ותלויות
🎯 תרגיל 4: הכן את ה-Toolkit לצוות (Advanced)
  1. ודא שתיקיית .claude/ ב-Git עם .gitignore מתאים
  2. עבור על כל הרכיבים — הסר מידע אישי, API Keys, ונתיבים ספציפיים למכונה שלך
  3. הפרד בין הגדרות צוות (.claude/settings.json) להגדרות אישיות (~/.claude/settings.json)
  4. כתוב "Getting Started" ב-TOOLKIT.md — הוראות לחבר צוות חדש שמקבל את ה-Repo
  5. שלח ל-Git: git add .claude/ && git commit -m "Add team toolkit"
  6. בקש מחבר צוות (או מעצמך במחשב אחר) לעשות Clone ולבדוק שהכל עובד
⭐ רק דבר אחד — Just One Thing

אם יש דבר אחד לקחת מהפרק הזה — ומכל הקורס — זה זה: כתוב TOOLKIT.md. לא מחר, לא בסוף השבוע — היום. גם אם יש לך רק Hook אחד ו-Skill אחד — תעד אותם. TOOLKIT.md הוא לא תיעוד בירוקרטי — הוא מפה. הוא מראה לך מה יש לך, מה חסר, ומה הצעד הבא. בלעדיו, ה-Toolkit שלך הוא ערמה אקראית של קבצים. איתו, הוא מערכת מתוכננת שאפשר לשתף, לתחזק ולהרחיב. תכתוב TOOLKIT.md היום, ותעדכן אותו כל חודש. תוך שנה תסתכל אחורה ולא תאמין כמה רחוק הגעת.

בדוק את עצמך — Check Yourself

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

ענה על 5 השאלות הבאות בלי לגלול למעלה. אם עונים נכון על 4 מתוך 5 — סיימת את הפרק בהצלחה:

  1. למה 7 השכבות של Toolkit בנויות בסדר הזה — ולא אחר? (רמז: חשוב על תלויות)
    תשובה: Foundation (CLAUDE.md), Automation (Hooks), Commands (Skills), Intelligence (Agents), Connectivity (MCP), Isolation (Worktrees), Security. כל שכבה בונה על מה שמתחתיה — Hooks אוכפים כללים מ-CLAUDE.md, Skills מפעילים Agents, וכו'.
  2. איך מטריצת "תדירות x מורכבות" עוזרת להחליט איזה רכיב לבנות? (רמז: 4 ריבועים)
    תשובה: יומי + פשוט = Hook. יומי + מורכב = Skill. שבועי + מורכב = Agent. לפי צורך + מורכב = MCP + Agent. העקרון: תדירות גבוהה = אוטומציה. מורכבות גבוהה = סוכן.
  3. מה ההבדל בין Level 2 (Organized) ל-Level 3 (Interconnected) ב-Command Library? (רמז: קשרים בין פקודות)
    תשובה: Level 2 = תיקיות מסודרות + שמות עקביים, אבל כל Skill עובד לבד. Level 3 = פקודות קוראות אחת לשנייה (/dev-deploy קורא ל-/dev-test לפני Deploy).
  4. למה TOOLKIT.md הוא לא סתם תיעוד — ומה הוא מכיל שמסמך README רגיל לא? (רמז: 5 מרכיבים ייחודיים)
    תשובה: TOOLKIT.md מכיל: טבלאות רכיבים, הערכות עלות, Architecture Diagram, לוח עדכון (שבועי/חודשי/רבעוני), ו-Getting Started לצוות. זה מפה חיה, לא תיעוד סטטי.
  5. איך Morning Ritual Pattern משלב 3 שכבות שונות של Toolkit? (רמז: Foundation + Automation + Connectivity)
    תשובה: SessionStart Hook (Automation) שטוען הקשר מ-CLAUDE.md (Foundation), בודק Git Status, טוען משימות מ-Auto-Memory (Connectivity עם FS), ומציע במה להתחיל.

סיכום הפרק — וסיכום הקורס

סיכום — פרק 10: Building Your Personal Toolkit

הפרק הזה חיבר את כל 9 הפרקים הקודמים למערכת שלמה. התובנה המרכזית: ההבדל בין משתמש מתקדם לאדריכל של Claude Code הוא לא מספר הרכיבים — אלא המערכת שמחברת אותם. Workflow Map, Priority Score, Dependency Graph, Maturity Model ו-TOOLKIT.md — כל אלה כלים שמפנים את Claude Code מאוסף אקראי של פיצ'רים לארכיטקטורה מתוכננת שמשתפרת כל שבוע. 7 שכבות, מ-Foundation עד Security, שעובדות יחד בצורה שחוסכת שעות בשבוע ומונעת טעויות יקרות.

ב-10 פרקים בנית: Hooks (אכיפה), Agents (אינטליגנציה), MCP (חיבוריות), Skills (פקודות), Plugins (הפצה), Worktrees (בידוד), Memory (זיכרון), Security (הגנה), Advanced Prompting (תקשורת), ועכשיו Personal Toolkit (ארכיטקטורה). אתה כבר לא סתם משתמש — אתה אדריכל של Claude Code.

בקורס הבא נעבור ל-Claude Code Production & SDK — שם תיקח את ערכת הכלים הזו ותרחיב אותה ל-Production עם Agent SDK (Python & TypeScript), GitHub Actions, Docker, Remote Control ופריסה בענן. מ-Power User ל-Builder.

צ'קליסט — האם סיימת את הפרק?