Claude Builder

ממשק ה-API של Claude, מבית Anthropic, מאפשר למפתחים לשלב את יכולות הבינה המלאכותית המתקדמות של מודלי Claude (כמו Claude 3.5 Sonnet) ישירות בתוך האפליקציות שלהם. בניגוד לשימוש בממשק ה-Chat הרגיל, עבודה עם ה-API מעניקה שליטה מלאה על התנהגות המודל, אבטחת המידע, וזמני התגובה. הבנת עקרונות העבודה עם ה-API היא שלב קריטי במעבר מפיתוח פרומפטים פשוטים לבניית מערכות פרודקשן מורכבות, סוכנים חכמים (Agents) ואינטגרציות מותאמות אישית.

כדי להתחיל לעבוד, הצעד הראשון הוא הגדרת ה-Authentication. ה-SDK הרשמי של Anthropic מחפש כברירת מחדל משתנה סביבה בשם ANTHROPIC_API_KEY. מומלץ להשתמש ב-SDK הרשמי עבור Node.js/TypeScript או Python, המנהל עבורנו את הגדרת ה-Headers, הטיפול בשגיאות וקריאות ה-HTTP בצורה מאובטחת ויעילה.

בלב ה-API נמצא ה-Messages API. בניגוד ל-Legacy Completions API הישן, ה-Messages API מבוסס על מבנה שיחה מוגדר מראש המורכב מתפקידים (user ו-assistant). אחד הכלים החזקים ביותר כאן הוא ה-system prompt – פרמטר ייעודי המאפשר להגדיר למודל את תפקידו, מגבלותיו וסגנון הדיבור שלו עוד לפני תחילת השיחה, מה שמבטיח עקביות גבוהה בתוצאות.

עבור חוויית משתמש (UX) מצוינת, במיוחד ביישומי צ'אט, מומלץ להשתמש ב-Streaming. במקום להמתין שניות ארוכות לקבלת התשובה המלאה מהשרת, ה-API מאפשר להזרים את חלקי הטקסט (tokens) בזמן אמת ברגע שהם נוצרים. ה-SDK מפשט זאת באמצעות שימוש ב-Async Iterators המאפשרים לקרוא את חלקי התגובה בצורה נוחה ורציפה.

הנה דוגמה קצרה ב-TypeScript המציגה שימוש ב-Messages API, הגדרת System Prompt והזרמת התוצאה (Streaming):

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

const stream = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1024,
  system: 'אתה עוזר טכנולוגי מקצועי המשיב בקצרנות ובעברית.',
  messages: [{ role: 'user', content: 'הסבר בקצרה מה זה Streaming API.' }],
  stream: true,
});

for await (const chunk of stream) {
  if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
    process.stdout.write(chunk.delta.text);
  }
}

להרחבה והעמקה ביכולות מתקדמות, מומלץ לעיין ב-Anthropic Cookbook המציע דוגמאות קוד מעשיות לפתרון בעיות נפוצות, וכן ב-Claude TypeScript Starter המהווה בסיס מצוין להקמת פרויקטים חדשים ב-TypeScript. בנוסף, מומלץ לעקוב אחר העדכונים האחרונים ב-Claude Agent SDK v0.3.147 כדי להכיר את הכלים החדשים ביותר לבניית סוכנים אוטונומיים.

הצעד הבא שלכם: הורידו את ה-Claude TypeScript Starter, הגדירו את מפתח ה-API שלכם בתוך קובץ .env, והריצו את דוגמת ה-Streaming הראשונה שלכם על גבי Claude 3.5 Sonnet.

כלי ה-CLI הרשמי של Anthropic, המכונה Claude Code, מייצג קפיצת מדרגה משמעותית בדרך שבה מפתחים מתקשרים עם מודלי שפה גדולים ישירות מסביבת הפיתוח המקומית שלהם. בניגוד לממשקי צ'אט סטנדרטיים בדפדפן, Claude Code הוא סוכן (Agent) מבוסס מסוף שמסוגל להבין את מבנה הפרויקט שלכם, לקרוא ולכתוב קבצים, להריץ פקודות בדיקה (tests), ולבצע משימות פיתוח מורכבות בצורה אוטונומית למחצה. הוא פועל ישירות בתוך ה-Terminal ומאפשר לכם לנהל שיחה חכמה על קוד המקור שלכם ללא צורך בהעתקה והדבקה ידנית.

הצורך ב-Claude Code עולה כאשר מפתחים נדרשים לבצע משימות רוחביות הדורשות הבנה עמוקה של הקשר (Context) רחב בפרויקט. לדוגמה, כאשר רוצים להוסיף פיצ'ר חדש שמצריך שינויים במספר קבצים במקביל, לפתור באגים מורכבים שמקורם לא ברור, או לבצע ריפקטורינג לקוד ישן. השימוש ב-CLI חוסך זמן יקר ומאפשר עבודה חלקה ומהירה יותר הודות ליכולות ה-Agentic המובנות שלו, המאפשרות לו לקבל החלטות, להריץ בדיקות בעצמו ולוודא שהשינויים שביצע אינם שוברים את האפליקציה. פיתוחים אחרונים בתחום, כמו אסטרטגיות למידה עצמית של סוכנים המוצגות במחקר SkillOpt, מדגישים כיצד סוכני קוד הופכים ליעילים ומדויקים יותר עם הזמן.

כדי להתחיל לעבוד עם הכלי, יש לוודא שמותקנת אצלכם סביבת Node.js (גרסה 18 ומעלה). ההתקנה מתבצעת בצורה פשוטה דרך מנהל החבילות npm באופן גלובלי. לאחר ההתקנה, תתבקשו לבצע תהליך אימות (Authentication) קצר מול החשבון שלכם ב-Anthropic, ולאחר מכן תוכלו להריץ את הכלי ישירות מתיקיית הפרויקט שלכם.

הנה פקודות ההתקנה וההרצה הבסיסיות כדי להתחיל לעבוד:

# התקנת ה-CLI של Claude Code באופן גלובלי
npm install -g @anthropic-ai/claude-code

# ניווט לתיקיית הפרויקט שלכם
cd /path/to/your/project

# הפעלת הכלי בפעם הראשונה (ידרוש התחברות)
claude

# בתוך ממשק ה-CLI, תוכלו לשאול שאלות או לבקש משימות:
# > Explain the routing logic in this project
# > Run the tests and fix any failing test cases

מעבר לשימוש הבסיסי כמסייע אישי במסוף, Claude Code מציע יכולות מתקדמות המאפשרות אינטגרציה מלאה בתהליכי ה-CI/CD שלכם. באמצעות שימוש ב-Claude Code Cookbook, ניתן להטמיע את הסוכן כחלק מ-GitHub Actions כדי לבצע קוד-רוויו (Code Review) אוטומטי לכל Pull Request, לזהות פרצות אבטחה או אפילו להציע תיקוני באגים ישירות בתוך ה-workflow של ה-Repository. בנוסך, מפתחים יכולים כעת לעקוב אחר פעולות הסוכן בזמן אמת באמצעות כלי ניטור מתקדמים, כפי שניתן לראות בהצגת לוח המחוונים לסוכנים של Claude Code.

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

כלי הפיתוח Claude Code הוא ממשק שורת פקודה (CLI) מהפכני מבית Anthropic, המביא את יכולות הסוכן (Agentic AI) של Claude ישירות לטרמינל שלכם. בניגוד לעוזרי קוד רגילים, Claude Code אינו רק כלי להשלמת טקסט; הוא מסוגל לקרוא ולכתוב קבצים במערכת המקומית, להריץ פקודות בטרמינל, להפעיל טסטים, לזהות שגיאות קומפילציה ולתקן אותן באופן עצמאי לחלוטין.

רבים שואלים במה הוא שונה מכלים פופולריים כמו Cursor או GitHub Copilot. בעוד שכלים אלו פועלים כתוספים בתוך סביבת הפיתוח (IDE) וממתינים להנחיות שלכם שורה-אחר-שורה, Claude Code פועל כסוכן עצמאי (Agent). הוא מקבל משימה ברמת על (למשל: "תקן את באג ה-login ותוודא שהטסטים עוברים"), מתכנן את שלבי העבודה, מריץ את הבדיקות בעצמו, קורא את השגיאות ומתקן את הקוד בלופ סגור עד להצלחה. מחקרים כמו SEC-bench Pro מראים כי מודלים הפועלים כסוכנים עצמאיים מסוגלים לפתור משימות פיתוח ואבטחה מורכבות וארוכות טווח ביעילות גבוהה בהרבה משיטות מסורתיות.

כדי להתחיל לעבוד עם Claude Code, תצטרכו לוודא שמותקן אצלכם Node.js (גרסה 18 ומעלה). ההתקנה מתבצעת באופן גלובלי דרך הטרמינל שלכם, ולאחר מכן תוכלו להריץ את הפקודה בכל תיקיית פרויקט קיימת כדי להתחיל לעבוד.

# התקנת הכלי באופן גלובלי
npm install -g @anthropic-ai/claude-code

# ניווט לתיקיית הפרויקט שלכם
cd my-awesome-project

# הפעלת הכלי ותהליך הזדהות ראשוני
claude

# כעת תוכלו לשאול שאלות או לבקש משימות בתוך ה-CLI:
# > "Run the tests and fix any failing ones"

לאחר הפעלת הפקודה claude, תועברו לממשק אינטראקטיבי ייחודי. הממשק מציע תפריט פקודות עשיר המתחיל בלוכסן (Slash Commands). לדוגמה, הפקודה /dev תאפשר לכם להגדיר משימת פיתוח מורכבת, הפקודה /bug תסייע באיתור ותיקון שגיאות, והפקודה /commit תנתח את השינויים שביצעתם ותציע הודעת Commit מדויקת ל-git. הכלי מנהל את הרשאות הגישה שלו בצורה בטוחה ומבקש אישור לפני הרצת פקודות מערכת רגישות.

לקריאה נוספת והעמקה, מומלץ לצפות בסקירה המעשית 100 שעות של בדיקת Claude Code מול ChatGPT Codex כדי להבין את ביצועי הכלי בשטח, וכן לעיין במדריך הרשמי ב-Claude Code Documentation המציג שילוב מתקדם עם git ו-CI/CD.

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

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

הצורך בעריכה מרובת קבצים (multi-file edits) עולה כאשר אנו נדרשים לבצע שינוי ארכיטקטוני או להוסיף תכונה חדשה המשפיעה על מספר שכבות במערכת. לדוגמה, עדכון של פרוטוקול תקשורת דורש שינוי בשרת, בלקוח ובקובצי הטייפים (Types). היכולת של Claude לנהל את השינויים הללו במקביל מונעת חוסר עקביות וחוסכת שעות של עבודה סיזיפית. מחקרים ובדיקות עומק, כמו אלו המוצגים בהשוואה של 100 שעות של בדיקת Claude Code מול ChatGPT Codex, מראים כי היכולת הזו משנה לחלוטין את מהירות הפיתוח.

כדי לשמור על בטיחות הקוד ולמנוע טעויות, תהליך העבודה כולל מנגנוני בקרה מובנים: diff review ו-undo. לפני שכל שינוי מוחל על הקבצים הפיזיים, המערכת מציגה תצוגת שינויים (diff) ברורה המראה בדיוק אילו שורות יתווספו ואילו יימחקו, בדומה ל-Git. אם התוצאה אינה לשביעות רצונו של המפתח, פקודת undo פשוטה מאפשרת להחזיר את המצב לקדמותו באופן מיידי ומבלי להשאיר עקבות. יכולות אלו קריטיות במיוחד במשימות מורכבות, כפי שנחקר ב-SEC-bench Pro הבוחן פתרון בעיות אבטחה ארוכות טווח בקוד.

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

# התקנה והרצה של Claude Code בתיקיית הפרויקט
npm install -g @anthropic-ai/claude-code
claude

# בקשת שינוי מרובה קבצים בתוך ה-CLI
> "Refactor the database connection to use a connection pool in db.js and update config.json"

# Claude ינתח את הקבצים, יציג Diff לאישור:
# [Diff Review: db.js, config.json]
# האם להחיל את השינויים? (y/n)
> y

# במידה והתחרטתם, ניתן לבטל את הפעולה מיד:
> /undo

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

הצעד הבא שלכם: כדי לתרגל את הנושא הלכה למעשה, שכפלו את הפרויקט Claude Code — file operations cookbook. כנסו לתיקיית examples/ והריצו את אחד מתרחישי ה-batch refactors המוכנים כדי לראות כיצד Claude עורך מספר קבצים במקביל ומציג את ה-diff בזמן אמת.

בסביבות פיתוח מבוססות בינה מלאכותית, כמו Claude Code, פקודות סלאש (Slash Commands) הן הדרך המהירה ביותר להפעיל משימות מורכבות ישירות מהטרמינל. פקודות מותאמות אישית (Custom Slash Commands) מאפשרות לכם להגדיר קיצורי דרך משלכם לפעולות חוזרות, כמו הרצת בדיקות, סקירת קוד לפי תקני החברה, או יצירת תיעוד אוטומטי. במקום להקליד שוב ושוב הנחיות ארוכות (Prompts), אתם מגדירים פקודה פשוטה כמו /review או /test שמבצעת את העבודה בדיוק לפי ההנחיות שלכם.

הצורך בפקודות מותאמות אישית עולה ככל שמשלבים סוכני AI (AI Agents) עמוק יותר בתוך זרימת העבודה היומיומית. מחקרים ובדיקות מעשיות, כמו ההשוואה המקיפה של Nate Herk ביוטיוב בין Claude Code ל-ChatGPT Codex, מראים כי התאמה אישית של סביבת העבודה משפרת דרמטית את הפרודוקטיביות ומקצרת את זמן העבודה של המפתח. שימוש בפקודות מובנות מונע "הזיות" (hallucinations) של המודל ומבטיח שהוא פועל תמיד תחת קונטקסט מוגדר מראש, במיוחד במשימות רגישות כמו אבטחת מידע שנבדקו במאגרים כמו SEC-bench Pro.

הקמת פקודה מותאמת אישית ב-Claude Code היא פשוטה להפליא ואינה דורשת כתיבת קוד מורכב. כל מה שצריך לעשות הוא ליצור תיקייה ייעודית בשם .claude/commands/ בתוך תיקיית השורש (root) של הפרויקט שלכם. כל קובץ Markdown (.md) שתוסיפו לתיקייה זו יהפוך אוטומטית לפקודת סלאש זמינה בתוך ממשק ה-CLI של Claude Code, כאשר שם הקובץ קובע את שם הפקודה.

הנה דוגמה פשוטה לקובץ בשם .claude/commands/review.md שמגדיר פקודה מותאמת אישית לסקירת קוד מהירה:

# /review
# Description: סקירת קוד מהירה לאיתור בעיות אבטחה וביצועים

אנא סרוק את השינויים האחרונים ב-git (השתמש ב-git diff).
התמקד בנקודות הבאות:
1. חולשות אבטחה נפוצות (כמו SQL Injection או דליפת סודות).
2. בעיות ביצועים פוטנציאליות.
הצג את הממצאים בטבלה קריאה עם הצעות לתיקון.

מאחורי הקלעים, המערכת קוראת את קובץ ה-Markdown ומשתמשת בתוכן שלו כהנחיית מערכת (System Prompt) ממוקדת עבור ה-Agent. כפי שניתן לראות בעדכונים האחרונים של ה-Claude Agent SDK, היכולת לנהל קונטקסט ולבצע משימות מרובות שלבים הולכת ומשתפרת, מה שמאפשר לפקודות ה-Slash שלכם להפעיל תהליכים מורכבים הכוללים קריאה לכלי מערכת חיצוניים, הרצת סקריפטים מקומיים וניתוח פלטים בזמן אמת.

הצעד הבא שלכם: כדי להתחיל לעבוד עם פקודות מותאמות אישית, היכנסו לפרויקט הרשמי Claude Code Slash Commands Examples, הקימו את תיקיית .claude/commands/ בפרויקט המקומי שלכם, וצרו את פקודת ה-/review הראשונה שלכם לפי הדוגמה למעלה. הריצו את Claude Code בטרמינל ובדקו כיצד הוא מגיב לפקודה החדשה שיצרתם!

בעולם של סוכני AI עצמאיים (Autonomous Agents), היכולת לפקח על פעולות המודל בזמן אמת היא קריטית ליציבות ואבטחת המערכת. כאן נכנסים לתמונה Hooks (אוטומציה תגובתית). הוקס הם נקודות התערבות מובנות במחזור החיים של ריצת הסוכן, המאפשרות לנו להריץ קוד מותאם אישית לפני שהסוכן משתמש בכלי (PreToolUse), מיד לאחר השימוש בכלי (PostToolUse), או כאשר הסוכן מסיים את פעולתו (Stop). כלי זה מעניק למפתחים שליטה מלאה על מה שהסוכן מורשה לבצע ומאפשר אוטומציה של תהליכי בקרת איכות.

הצורך ב-Hooks עולה ככל שהסוכנים הופכים ליותר אקטיביים בסביבות פיתוח וייצור. לדוגמה, ללא הגבלה מתאימה, סוכן עלול להריץ פקודת מחיקה הרסנית בטרמינל או להכניס קוד פגיע למערכת. באמצעות PreToolUse hook, אנו יכולים לכפות בדיקות אבטחה קפדניות או לדרוש אישור אנושי לפעולות רגישות. בצד השני של התהליך, PostToolUse מאפשר להריץ בדיקות יחידה (Unit Tests) או Linter באופן אוטומטי מיד לאחר שהסוכן ביצע שינוי בקוד, ובכך לוודא שהסוכן אינו "שובר" את הפרויקט תוך כדי עבודה.

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

const agent = new ClaudeAgent({
  hooks: {
    preToolUse: async (toolCall) => {
      if (toolCall.name === 'execute_bash' && toolCall.args.command.includes('rm -rf')) {
        throw new Error("Unsafe command blocked by PreToolUse hook!");
      }
      console.log(`Executing tool: ${toolCall.name}`);
    },
    postToolUse: async (toolResult) => {
      if (toolResult.toolName === 'edit_file') {
        await runAutomatedTests(); // הרצת בדיקות אוטומטית
      }
    }
  }
});

השימוש בבקרות אלו הופך לחיוני במיוחד לאור מחקרים עדכניים בתחום אבטחת סוכנים. מחקרים כמו SEC-bench Pro מראים כי סוכני AI הפועלים ללא מנגנוני הגנה והוקס נוטים להיכשל במשימות אבטחה מורכבות ואף עלולים לייצר פרצות אבטחה חמורות בעצמם. שילוב הוקס מאפשר לארגונים ליהנות מהפרודוקטיביות של סוכני קוד תוך שמירה על סטנדרטים מחמירים של אבטחה ואיכות קוד.

הצעד הבא שלכם: כדי להתנסות בכך באופן מעשי, התקינו והגדירו את Claude Code. פתחו את קובץ ה-settings.json של הכלי והגדירו PostToolUse hook שמריץ את פקודת ה-Linter או ה-Tests של הפרויקט שלכם בכל פעם ש-Claude מבצע עריכת קוד. זוהי הדרך הטובה ביותר לראות אוטומציה תגובתית בפעולה בסביבת הפיתוח האישית שלכם.

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

כדי להתחיל, Anthropic מספקת אקוסיסטם עשיר של מיומנויות מוכנות. ב-Anthropic Skills Repository תוכלו למצוא דוגמאות רשמיות לעבודה עם קבצי PDF, Word, ואפילו יוצר מיומנויות אוטומטי (skill-creator). בנוסף, פרויקט הקהילה הרשמי cowork משמש כ-Marketplace שבו מפתחים משתפים מיומנויות שימושיות ואינטגרציות, המתווספות ישירות לליבת המערכת ומציגות דוגמה מצוינת לארכיטקטורה נכונה של הרחבות.

הלב של כל מיומנות הוא קובץ SKILL.md. זהו קובץ Markdown המגדיר עבור ה-Agent את המטרה של המיומנות, מתי להשתמש בה, ואילו פקודות או סקריפטים זמינים עבורה. כתיבת SKILL.md אפקטיבי דורשת הגדרה ברורה של ה-System Prompt, תיאור מדויק של הכלים (Tools) ודוגמאות קונקרטיות לשימוש (Few-shot examples). ככל שההנחיות בקובץ זה יהיו ממוקדות יותר, כך Claude ידע להפעיל את המיומנות ברגע הנכון ללא התערבות ידנית.

הנה דוגמה פשוטה למבנה של קובץ SKILL.md המגדיר מיומנות לניתוח אבטחה בסיסי של קוד:

# Security Auditor Skill

## Purpose
Analyze the codebase for potential security vulnerabilities, specifically focusing on hardcoded secrets and outdated dependencies.

## When to use
- Before committing code.
- When asked to perform a security audit.

## Instructions
1. Run `npm audit` to check for dependency issues.
2. Scan files for patterns like `API_KEY` or `PASSWORD`.
3. Provide a summary report in `SECURITY_REPORT.md`.

כדי להבין את החשיבות של הרחבת יכולות ה-Agent ופתרון משימות מורכבות, מומלץ לעיין במחקר SEC-bench Pro העוסק ביכולת של מודלי שפה לפתור משימות אבטחה ארוכות טווח, וכן בסקירה המעשית של Nate Herk ב-YouTube המשווה בין Claude Code ל-ChatGPT Codex ומציגה את היתרונות של התאמת סביבת העבודה.

הצעד הבא שלכם: שכפלו את מאגר ה-cowork, עיינו בתיקיית ה-skills הקיימת, ונסו ליצור קובץ SKILL.md משלכם בתוך פרויקט מקומי. השתמשו ב-skill-creator מתוך ה-Skills Repository הרשמי כדי לייצר את השלד הראשוני של המיומנות החדשה שלכם באופן אוטומטי.

בעולם של סוכני בינה מלאכותית (AI Agents), פתרון משימות מורכבות וארוכות טווח דורש לעיתים קרובות יותר מאשר סוכן יחיד שמנסה לעשות הכל. כאן נכנס לתמונה הקונספט של Subagents (סוכני משנה במקביל). בבסיסו, הרעיון הוא לאפשר לסוכן הראשי (כמו Claude Code) להאציל סמכויות, לפצל משימות מורכבות, ולהריץ תתי-סוכנים במקביל כדי לפתור בעיות מורכבות בצורה יעילה וממוקדת יותר. כל סוכן משנה פועל בסביבה מוגדרת משלו ומבצע משימה ספציפית תוך שימוש בכלי ייעודי (Task tool).

מדוע אנו זקוקים לארכיטקטורה הזו? במערכות מורכבות, סוכן יחיד עלול לסבול מ"עומס קוגניטיבי" (Context window saturation) או ללכת לאיבוד בלולאות אינסופיות של פתרון בעיות. מחקרים כמו DIANOIA מראים כי פירוק אבחוני ואופטימיזציה משותפת של מספר סוכנים משפרים משמעותית את דיוק ההסקה. שימוש בסוכני משנה מאפשר הפרדת רשויות (Separation of Concerns): סוכן אחד יכול לבצע בדיקות אבטחה, סוכן שני יכול לכתוב טסטים, וסוכן שלישי יכול לתעד, בעוד הסוכן הראשי מנהל את האופרציה. הדבר קריטי במיוחד במשימות אבטחה ארוכות טווח כפי שנבדקו ב-SEC-bench Pro.

בכלי החדשני Claude Code, המנגנון הזה מיושם בצורה אלגנטית על ידי הגדרת קובצי הגדרה בתיקייה ייעודית: .claude/agents/. כל קובץ markdown בתיקייה זו (למשל subagent.md) מגדיר את תפקידו, הכלים העומדים לרשותו וההנחיות של סוכן המשנה. כאשר Claude נתקל במשימה מורכבת, הוא משתמש ב-Task tool שלו כדי לאתחל את סוכן המשנה הרלוונטי, להעביר לו את הקשר המשימה ולקבל ממנו את התוצאות בסיום הריצה המקבילית.

הנה דוגמה פשוטה לאופן שבו נראה קובץ הגדרה של סוכן משנה (.claude/agents/security_reviewer.md) המתמחה בסריקת קוד לאבטחה:

# Security Reviewer Subagent
You are a specialized security subagent. Your task is to review code changes for potential vulnerabilities.

## Instructions
1. Analyze the diff provided by the main agent.
2. Run security scanners if available.
3. Return a structured JSON report with findings and severity levels.
4. Do not modify any files directly unless explicitly requested.

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

הצעד הבא שלכם:

כדי להתנסות בכך בעצמכם, התקינו את Claude Code בסביבת הפיתוח שלכם. צרו תיקייה בשם .claude/agents/ בפרויקט קיים, והוסיפו קובץ בשם tester.md שמגדיר סוכן משנה לכתיבת טסטים. לאחר מכן, הריצו את Claude Code ובקשו ממנו: "Run a parallel task to generate unit tests for our new utility functions using the tester subagent". עקבו אחר ה-Task tool בפעולה וראו כיצד המשימה מבוצעת במקביל!

פרוטוקול Model Context Protocol (או MCP) הוא תקן פתוח המאפשר למודלי שפה גדולים (LLMs) להתחבר בצורה מאובטחת ויעילה למקורות נתונים וכלים חיצוניים. כאשר אנו עובדים עם Claude Code, כלי ה-CLI העוצמתי של Anthropic, אנו מוגבלים לעיתים קרובות למידע המקומי של הפרויקט הנוכחי. חיבור שרתי MCP (כמו שרתי קבצים, בסיסי נתונים או ממשקי API חיצוניים) מאפשר ל-Claude Code "להושיט יד" החוצה, לקרוא ולכתוב נתונים, ולבצע פעולות מורכבות ישירות מסביבת העבודה שלנו.

הצורך בחיבור שרתי MCP עולה כאשר אנו רוצים להעניק ל-Claude Code יכולות מתקדמות שאינן מובנות בו כברירת מחדל. לדוגמה, באמצעות שרת filesystem נוכל לאפשר לו לגשת לתיקיות מוגדרות מראש במחשב; שרת github יאפשר לו לנהל Issues ו-Pull Requests; שרת postgres יאפשר לו לתשאל את בסיס הנתונים שלנו ישירות כדי להבין את סכמת הנתונים; ושרת slack יאפשר לו לשלוח עדכונים לצוות על התקדמות העבודה. זה הופך את ה-AI מעוזר כתיבה פשוט לסוכן (Agent) עצמאי שמסוגל לפתור בעיות מקצה לקצה.

כדי לחבר שרתי MCP ל-Claude Code, אנו משתמשים בקובץ הגדרות גלובלי או מקומי (לרוב בנתיב ~/.config/claude/claude_desktop_config.json עבור Claude Desktop, או דרך הגדרות ה-CLI של Claude Code). בקובץ זה אנו מגדירים את השרתים השונים תחת המפתח mcpServers, ומציינים עבור כל שרת כיצד להריץ אותו (למשל באמצעות npx או uvx) ואילו פרמטרים או משתני סביבה להעביר לו בזמן הריצה.

הנה דוגמה פשוטה להגדרת שרת MCP של מערכת הקבצים (filesystem) ושרת github בקובץ הקונפיגורציה שלכם:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your_token_here"
      }
    }
  }
}

הפרוטוקול מתפתח במהירות רבה ונתמך על ידי התעשייה כולה. תוכלו לקרוא עוד על התקדמות הפרוטוקול והגרסאות האחרונות שלו ב- MCP spec 2025-11-25-RC וכן בגרסאות קודמות כמו MCP spec 2025-06-18. שילובים אלו מאפשרים תאימות רחבה לא רק עם Claude אלא גם עם ספריות סוכנים מתקדמות אחרות.

הצעד הבא שלכם: כדי להתחיל לעבוד עם MCP באופן מעשי, מומלץ להשתמש באוסף השרתים הרשמי MCP Servers Catalog. הגדירו את שרת ה-filesystem המקומי שלכם, חברו אותו ל-Claude Code, ונסו לבקש מ-Claude לנתח קובץ שנמצא מחוץ לתיקיית הפרויקט הנוכחית שלכם כדי לוודא שהחיבור עובד בהצלחה!

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

מדוע זה כל כך חשוב? סוכני קוד אוטונומיים מסוגלים לקרוא, לכתוב ולבצע פקודות במערכת שלכם. מחקרים כמו SEC-bench Pro מראים כי מודלי שפה המתמודדים עם משימות אבטחה ארוכות טווח דורשים ניהול הרשאות קפדני כדי למנוע פרצות אבטחה בזמן אמת. הגדרת ה-Permissions וה-MCP Scopes (פרוטוקול הקשר למודלים) מאפשרת לכם לקבוע בדיוק אילו שרתים חיצוניים וכלי מערכת יהיו נגישים לסוכן, ומתי נדרש אישור ידני שלכם (Human-in-the-loop).

כדי להתחיל, עלינו להכיר את המבנה הבסיסי של הגדרות ה-CLI. הקובץ מאפשר לקבוע את בחירת המודל (Model Selection), משתני סביבה (Env Vars), שליחת טלמטריה (Telemetry) ואינטגרציות של שרתי MCP. בסרטון הסקירה של Nate Herk על Claude Code, מוצג כיצד שליטה נכונה בהגדרות אלו משפרת משמעותית את יעילות העבודה של הסוכן ומצמצמת שגיאות ריצה יקרות.

להלן דוגמה מינימלית לקובץ settings.json המגדיר הרשאות בטוחות, בחירת מודל וביטול טלמטריה:

{
  "model": "claude-3-5-sonnet",
  "telemetry": false,
  "permissions": {
    "allowWrite": ["./src", "./tests"],
    "allowExecute": false,
    "requireApprovalForCommands": ["rm", "npm install"]
  },
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

בתוך הגדרות אלו, שימו לב לשימוש ב-permissions. הגדרנו כאן שהסוכן מורשה לכתוב רק לתיקיות הקוד והבדיקות, וחסמנו לחלוטין הרצת פקודות טרמינל אוטומטיות ללא אישור ידני עבור פקודות רגישות. ניהול נכון של משתני סביבה (Env Vars) דרך קובץ זה או דרך מערכת ההפעלה מבטיח שמפתחות ה-API שלכם יישארו מוגנים.

הצעד הבא שלכם: שכפלו את ה-Schema הרשמית מתוך Claude Code repository, צרו קובץ settings.json מקומי בתיקיית הבית שלכם, והגדירו את ה-permissions כך שכל פקודת כתיבה (Write) תדרוש אישור ידני שלכם לפני הביצוע.

פרוטוקול Model Context Protocol (או בקיצור MCP) הוא תקן פתוח חדש שפותח על ידי חברת Anthropic, שמטרתו לפתור את אחת הבעיות המורכבות ביותר בעולם ה-AI: כיצד לחבר מודלי שפה גדולים (LLMs) למקורות מידע וכלים חיצוניים בצורה מאובטחת, אחידה וניתנת להרחבה. במקום לפתח אינטגרציה ייעודית (Ad-hoc) עבור כל כלי ומודל בנפרד, MCP מגדיר ארכיטקטורת לקוח-שרת (Client-Server) אחידה המאפשרת למודלים כמו Claude לגשת לקבצים, בסיסי נתונים, כלי פיתוח ואינטרנט בצורה טבעית.

עד היום, מפתחים נאלצו לכתוב קוד \"דבק\" (glue code) מורכב כדי לחבר סוכני AI (Agents) למערכות הארגוניות שלהם. כל שינוי ב-API של כלי חיצוני דרש עדכון של קוד הסוכן. באמצעות MCP, המודל פועל כ\"לקוח\" (Client) שמתחבר ל\"שרתים\" (Servers) שונים החושפים משאבים (Resources), כלים (Tools) והנחיות (Prompts). השרתים הללו מופרדים לחלוטין מהלוגיקה של המודל, מה שמאפשר להחליף, לעדכן או להוסיף כלים בקלות רבה מבלי לשנות את ליבת האפליקציה. זהו פתרון אידיאלי לבניית סוכני AI ארגוניים שצריכים לגשת למידע רגיש בצורה מבוקרת.

כדי להתחיל לעבוד עם MCP, אנו משתמשים ב-SDK הרשמיים של הפרוטוקול. הדרך הפשוטה ביותר להתחיל בפייתון היא באמצעות MCP Python SDK, המאפשר להקים שרת MCP מינימלי בכמה שורות קוד בלבד. השרת מגדיר את הכלים הזמינים ומממש את הלוגיקה שלהם, בעוד הלקוח (למשל, Claude Desktop או סוכן מותאם אישית) קורא להם לפי הצורך.

הנה דוגמה קצרה להקמת שרת MCP בסיסי המציע כלי לחישוב פשוט בעזרת ה-SDK הרשמי:

from mcp.server.fastmcp import FastMCP

# יצירת שרת MCP חדש
mcp = FastMCP(\"MathServer\")

# הגדרת כלי (Tool) שהמודל יוכל להפעיל
@mcp.tool()
def add_numbers(a: int, b: int) -> int:
    \"\"\"מחבר שני מספרים ומחזיר את התוצאה.\"\"\"
    return a + b

if __name__ == \"__main__\":
    mcp.run()

הפרוטוקול מתפתח במהירות עצומה וזוכה לאימוץ נרחב בתעשייה. לדוגמה, תוכלו לקרוא על השינויים האחרונים במפרט ב-גרסת Release Candidate של MCP spec משלהי 2025 או לעקוב אחר אבני הדרך ההיסטוריות כמו שחרור MCP מיוני 2025. בנוסף, ספריות פופולריות כמו Pydantic AI כבר משלבות תמיכה מובנית בפרוטוקול, כפי שניתן לראות בעדכון pydantic-ai v1.97.0.

הצעד הבא שלכם: כדי לראות את MCP בפעולה, מומלץ לשכפל את מאגר השרתים הרשמי MCP Servers Reference. נסו להריץ את שרת ה-filesystem המקומי וחברו אותו ל-Claude Desktop. זה יאפשר ל-Claude לקרוא ולכתוב קבצים ישירות במחשב שלכם בצורה מאובטחת ותחת הרשאות מוגדרות מראש.

ה-Claude Agent SDK הוא כלי הפיתוח הרשמי מבית Anthropic המיועד לבניית סוכנים אוטונומיים (Autonomous Agents) מתקדמים המבוססים על מודלי Claude. ה-SDK מספק תשתית מובנית לניהול מחזור החיים של הסוכן, ניהול שיחות (Sessions), הפעלת כלים (Tools), ושימוש ב-Hooks המאפשרים להתערב ולנטר את פעולת הסוכן בזמן אמת. בניגוד לשימוש ב-API הפשוט, ה-SDK מאפשר לסוכן לקבל החלטות מורכבות, להפעיל לולאות חשיבה ופעולה (Reasoning loops) ולבצע משימות רב-שלביות בצורה עצמאית לחלוטין.

עבור מפתחים ברמת Advanced, פיתוח סוכנים מורכבים מאפס דורש התמודדות עם אתגרים קשים כמו ניהול זיכרון, טיפול בשגיאות של הפעלת כלים, ושמירה על עקביות לאורך זמן. ה-SDK פותר את הבעיות הללו על ידי מתן ארכיטקטורה מוכנה לייצור (Production-ready). הוא מתאים במיוחד לפיתוח עוזרים אישיים חכמים, מערכות אוטומציה של תהליכים עסקיים (RPA), וסוכני קוד שמסוגלים לפתור בעיות תכנות מורכבות. שימוש ב-SDK הרשמי מבטיח תאימות מלאה ליכולות ה-Tool Use המתקדמות של Claude 3.5 Sonnet ומאפשר אינטגרציה חלקה בסביבות Serverless כמו Cloudflare Workers או Vercel.

כדי להתחיל לעבוד, ניתן לבחור בין גרסת ה-TypeScript לגרסת ה-Python, בהתאם לארכיטקטורת המערכת שלכם. ה-SDK מבוסס על הגדרת סוכן (Agent), רישום כלים (Tools) שהסוכן יכול להפעיל, והרצת לולאת הפעלה מנוהלת. הכלים מוגדרים באמצעות סכמות סטנדרטיות, וה-SDK דואג להעביר את תוצאות הריצה של הכלים בחזרה למודל בצורה אוטומטית, עד להשגת המטרה שהוגדרה על ידי המשתמש.

הנה דוגמה קצרה להקמת סוכן בסיסי ב-TypeScript המשתמש בכלי מותאם אישית:

import { Agent, Tool } from '@anthropics/claude-agent-sdk';

const getWeather = new Tool({
  name: 'getWeather',
  description: 'Get current weather for a location',
  inputSchema: { type: 'object', properties: { location: { type: 'string' } } },
  handler: async ({ location }) => ({ weather: `Sunny in ${location}` })
});

const agent = new Agent({
  model: 'claude-3-5-sonnet-latest',
  tools: [getWeather]
});

const session = await agent.createSession();
const response = await session.say("What is the weather in Tokyo?");
console.log(response.text);

הפרויקט מתפתח במהירות רבה, ומומלץ לעקוב אחר העדכונים האחרונים בגרסאות ה-TypeScript. לדוגמה, עדכון Claude Agent SDK v0.3.147 וכן גרסת Claude Agent SDK v0.3.146 מציגים שיפורים משמעותיים בניהול ה-Sessions וה-Hooks של הסוכנים. מומלץ לעיין גם בשינויים של גרסה Claude Agent SDK v0.3.144 כדי להבין את האבולוציה של ה-API ויכולות ה-Streaming החדשות.

הצעד הבא שלכם הוא להתקין את אחד ה-Starter Projects הרשמיים. אם אתם עובדים בסביבת Python, שכפלו את המאגר Claude Agent SDK Python והריצו את דוגמת ה-Quickstart. אם אתם מעדיפים עבודה ב-Node.js או בסביבות קצה (Edge), הורידו את Claude Agent SDK TypeScript והתנסו בבניית סוכן פשוט המשלב לפחות שני כלים המשתפים מידע ביניהם.

מודלים של שפות גדולות (LLMs) כמו Claude הם חזקים במיוחד, אך לעיתים קרובות הם מוגבלים למידע שעליו הם אומנו או לטקסט בלבד. כדי להתגבר על כך, חברת Anthropic מציעה את הקונספט של Claude Skills (מיומנויות). מיומנויות אלו הן למעשה כלים (Tools) מוגדרים מראש המאפשרים ל-Claude לבצע פעולות מורכבות, לגשת לנתונים חיצוניים ולפתור בעיות ספציפיות בעולם האמיתי – החל מניתוח קבצי PDF ועד לחישובים מדעיים מורכבים.

השימוש ב-Claude Skills חיוני כאשר אנו רוצים לבנות סוכני AI (Agents) עצמאיים ואמינים. במקום לכתוב לוגיקה מורכבת מאפס עבור כל משימה, אנו יכולים להרחיב את היכולות של Claude באמצעות ה-Claude Agent SDK. זה מאפשר למודל להבין מתי ואיך להפעיל פונקציות חיצוניות בצורה חלקה, לשפר את דיוק התשובות ולחסוך זמן פיתוח יקר על ידי שימוש במיומנויות מוכנות מראש שפותחו ונבדקו על ידי הקהילה והחברה.

כדי להתחיל לעבוד, אנו משתמשים ב-Claude Agent SDK (בגרסת TypeScript). ה-SDK מאפשר לנו להגדיר "מיומנות" (Skill) כפונקציה עם סכמה ברורה (Schema) המתארת מה היא עושה ואיזה פרמטרים היא מקבלת. כאשר המשתמש שואל שאלה, Claude מזהה באופן אוטומטי שיש לו מיומנות מתאימה, קורא לה עם הפרמטרים הנכונים, ומחזיר את התוצאה המעובדת למשתמש.

הנה דוגמה פשוטה להגדרת Skill בסיסי של חישוב מס מותאם אישית באמצעות ה-SDK:

import { Agent } from '@anthropic-ai/claude-agent';

const taxSkill = {
  name: 'calculate_tax',
  description: 'Calculates the tax for a given amount',
  input_schema: {
    type: 'object',
    properties: { amount: { type: 'number' } },
    required: ['amount']
  },
  run: async ({ amount }) => ({ tax: amount * 0.17 })
};

const agent = new Agent({ skills: [taxSkill] });

הפיתוח סביב ה-SDK מתקדם במהירות רבה. עדכונים אחרונים כמו Claude Agent SDK v0.3.147 וכן גרסת Claude Agent SDK v0.3.146 מציגים שיפורים משמעותיים בניהול הזיכרון ובאינטגרציה של מיומנויות מורכבות. מומלץ לעקוב גם אחר השינויים ב-Claude Agent SDK v0.3.144 כדי להבין את האבולוציה של הכלים הללו ואת הדרכים האופטימליות לניהול סוכנים חכמים.

הצעד הבא שלכם: כדי לראות את היכולות הללו בפעולה, שכפלו את מאגר הדוגמאות הרשמי Claude Skills Examples. התחילו בהרצת דוגמת ה-Excel או ה-PDF processing כדי לראות כיצד Claude מתמודד עם קבצים אמיתיים ומבצע משימות עיבוד נתונים מורכבות בקלות.