Custom Agents and Subagents — סוכנים מותאמים אישית

מה הם Subagents ואיך הם עובדים

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

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

למה זה חשוב? כי החקירה של הסוכן לא מזהמת את ההקשר שלכם. אם סוכן קרא 50 קבצים וניסה 10 גישות שונות — אתם רואים רק את המסקנה. ההקשר היקר שלכם נשאר נקי ומרוכז.

מודל ההאצלה — The Delegation Model

הדרך הטובה ביותר להבין Subagents היא דרך מטאפורה ארגונית:

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

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

האצלה אוטומטית ומפורשת

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

אפשר גם להפעיל סוכנים באופן מפורש בשלוש דרכים:

1. שפה טבעית: הזכירו את שם הסוכן בבקשה — "Use the security-reviewer agent to check my code"
2. @-mention: הקלידו @ ובחרו את הסוכן מהרשימה (כמו @-mention לקבצים). זה מבטיח שהסוכן הספציפי הזה ירוץ.
3. --agent flag: הפעלה של כל הסשן כסוכן — claude --agent security-reviewer. ה-System Prompt של הסוכן מחליף את ברירת המחדל.

סוגי סוכנים מובנים

Claude Code מגיע עם כמה סוגי סוכנים מובנים. אתם לא צריכים להגדיר אותם — הם פועלים אוטומטית כשהמצב מתאים:

Claude בוחר אוטומטית את סוג הסוכן המתאים לפי הבקשה שלכם. שימו לב ש-Explore משתמש ב-Haiku (מהיר וזול), בעוד Plan ו-General-Purpose יורשים את המודל של השיחה הראשית. זה שיקול עלות חשוב.

סוכנים מובנים לעומת סוכנים מותאמים

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

יצירת סוכנים מותאמים — תיקיית .claude/agents/

סוכנים מותאמים אישית מוגדרים כקבצי Markdown (.md) בתיקיית .claude/agents/. כל קובץ = סוכן אחד. שם הקובץ (בלי .md) הופך למזהה הסוכן. רק שני שדות הם חובה: name ו-description.

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

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

מבנה קובץ סוכן

כל קובץ סוכן מורכב משני חלקים:

1. Frontmatter (בתוך ---) — הגדרות טכניות ב-YAML: שם, תיאור, מודל, כלים, מגבלות
2. Body (אחרי ה-Frontmatter) — הנחיות מפורטות ב-Markdown שהופכות ל-System Prompt של הסוכן

דוגמה בסיסית — קובץ .claude/agents/code-reviewer.md:

---
name: code-reviewer
description: Reviews code for quality, readability, and best practices
tools: Read, Glob, Grep
model: sonnet
---

# Code Reviewer Agent

You review code for quality and best practices.

## What to check
- Naming conventions
- Function length (flag >50 lines)
- Error handling
- Code duplication

## Output format
Provide a structured report with:
1. Summary (1-2 sentences)
2. Issues found (severity: high/medium/low)
3. Recommendations

שם הקובץ הוא code-reviewer.md, ולכן המזהה של הסוכן הוא code-reviewer. שימו לב שבגרסה הנוכחית (מרץ 2026) אפשר לכתוב כלים כרשימה מופרדת בפסיקים (Read, Glob, Grep) ולא רק כמערך JSON.

קונבנציות שמות

השתמשו בשמות תיאוריים עם מקפים: security-reviewer.md, test-runner.md, content-writer.md, deploy-checker.md. שם הקובץ צריך לתאר את התפקיד של הסוכן, לא את הטכנולוגיה שלו.

הפקודה /agents — ניהול אינטראקטיבי

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

הריצו /agents בסשן כדי:

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

יצירה עם Claude — Generate with Claude

אפשרות Generate with Claude מאפשרת לתאר את הסוכן בשפה טבעית, ו-Claude ייצר את ה-Frontmatter וה-System Prompt בשבילכם. הנה התהליך:

1. בחרו Create new agent → Personal (Global) או Project
2. בחרו Generate with Claude
3. תארו מה הסוכן צריך לעשות: "A code improvement agent that scans files and suggests improvements for readability and performance"
4. בחרו כלים, מודל, וצבע רקע (כדי לזהות סוכנים שונים ויזואלית)
5. הגדירו memory scope אם רוצים זיכרון מתמשך
6. שמרו — הסוכן זמין מיידית

לרשימה מלאה מה-CLI בלי להיכנס לסשן אינטראקטיבי: claude agents (בלי /).

Agent Frontmatter — כל השדות

ה-Frontmatter הוא ה"מוח" של הסוכן. כאן אתם מגדירים מי הוא, מה הוא יכול לעשות, וכמה חבל אתם משחררים לו. הנה כל השדות שזמינים נכון למרץ 2026:

The Agent Blueprint — מודל מנטלי

חשבו על כל שדה כחלק ממבנה:

• name + description = הזהות — מי הסוכן ולמה הוא קיים
• model + effort = המוח — כמה חכם ועמוק הוא חושב
• tools + disallowedTools = הידיים — מה הוא מורשה לעשות
• maxTurns = הרצועה — כמה חופש פעולה יש לו
• hooks = מעקות הבטיחות — מה קורה אוטומטית סביב הפעולות שלו
• memory = הזיכרון — מה הוא שומר מסשן לסשן
• permissionMode = רמת האוטונומיה — כמה אישורים הוא צריך ממכם
• isolation = הסביבה — האם הוא עובד על אותו ריפו או על עותק מבודד

tools לעומת disallowedTools — מתי להשתמש בכל אחד

יש שתי גישות להגבלת כלים:

הגבלת סוגי סוכנים שהסוכן יכול להפעיל

כשסוכן רץ כ-main thread (עם --agent), הוא יכול ליצור סוכני-משנה. כדי להגביל אילו סוכנים הוא מורשה ליצור, השתמשו בסינטקס Agent(agent_type) בשדה tools:

---
name: coordinator
description: Coordinates work across specialized agents
tools: Agent(worker, researcher), Read, Bash
---

הסוכן coordinator יכול ליצור רק worker ו-researcher. בלי Agent ברשימת tools — הסוכן לא יכול להפעיל סוכנים כלל.

דוגמה מלאה: Security Reviewer

בואו נבנה סוכן אמיתי שתוכלו להשתמש בו מחר בבוקר. סוכן Security Reviewer סורק קוד ומחפש פגיעויות אבטחה — בלי לשנות שום דבר. זה הדגם הקלאסי של סוכן Read-Only.

צרו את הקובץ .claude/agents/security-reviewer.md:

---
name: security-reviewer
description: Reviews code for security vulnerabilities, injection attacks, auth issues, and data exposure. Use proactively after code changes.
model: opus
effort: high
tools: Read, Grep, Glob, Bash
maxTurns: 25
---

# Security Reviewer Agent

You are a security-focused code reviewer. Your job is to find
vulnerabilities, NOT to fix them. Report findings, never edit files.

## What to Check

### Critical (Severity: HIGH)
- SQL injection: raw queries, string interpolation in SQL
- XSS: unescaped user input in HTML/templates
- CSRF: missing tokens on state-changing endpoints
- Hardcoded secrets: API keys, passwords, tokens in source code
- Authentication bypass: routes without auth middleware
- Path traversal: user-controlled file paths

### Important (Severity: MEDIUM)
- Insecure dependencies: known CVEs in package.json/requirements.txt
- Missing rate limiting on sensitive endpoints
- Overly permissive CORS configuration
- Sensitive data in logs (passwords, tokens, PII)
- Missing input validation

### Advisory (Severity: LOW)
- Deprecated crypto functions
- Missing security headers (CSP, HSTS, X-Frame-Options)
- Debug mode enabled in production config
- Verbose error messages exposing internals

## Output Format

For each finding, report:
1. **File**: exact path and line number
2. **Severity**: HIGH / MEDIUM / LOW
3. **Issue**: what you found
4. **Risk**: what could happen if exploited
5. **Remediation**: how to fix it (description only, do not edit)

End with a summary table: total findings by severity.

למה הבחירות האלה?

• model: opus — ביקורת אבטחה דורשת חשיבה עמוקה. לא כדאי לחסוך כאן.
• effort: high — רוצים שהסוכן באמת יחפור. לא "סקירה מהירה".
• tools: Read, Grep, Glob, Bash — קריאה + חיפוש + הרצת פקודות (למשל git diff כדי לראות שינויים אחרונים). שימו לב: אין Write ו-Edit — הסוכן לא יכול לערוך קבצים. זה בכוונה: סוכן ביקורת צריך לדווח, לא לתקן.
• maxTurns: 25 — ביקורת אבטחה יסודית דורשת הרבה קריאת קבצים. 25 תורות מספיקות לפרויקט בגודל בינוני.
• "Use proactively" ב-description — מעודד את Claude להפעיל את הסוכן מיוזמתו אחרי שינויי קוד.

איך להפעיל

אפשרות 1 — בפתיחת שיחה:

claude --agent security-reviewer

ואז תכתבו: "Review the auth module for security issues"

אפשרות 2 — @-mention מתוך שיחה קיימת:

@"security-reviewer (agent)" scan the API routes for injection vulnerabilities

אפשרות 3 — שפה טבעית. Claude יבחר את הסוכן אוטומטית אם ה-description מתאים: "Run a security audit on src/api/"

## Security Review: src/api/

### Finding 1 (HIGH)
**File:** src/api/users.js:47
**Issue:** SQL injection via string interpolation
**Risk:** Attacker can dump/modify the entire database
**Remediation:** Use parameterized queries instead of template literals

### Finding 2 (MEDIUM)
**File:** src/middleware/cors.js:12
**Issue:** CORS origin set to "*" (wildcard)
**Risk:** Any domain can make authenticated requests
**Remediation:** Whitelist specific allowed origins

### Summary
| Severity | Count |
|----------|-------|
| HIGH     | 1     |
| MEDIUM   | 3     |
| LOW      | 2     |

דוגמה מלאה: Content Pipeline — סוכן תוכן בעברית

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

צרו את הקובץ .claude/agents/content-writer.md:

---
name: content-writer
description: Creates, reviews, and polishes Hebrew marketing content following brand guidelines
model: sonnet
effort: medium
tools: Read, Write, Edit, WebSearch
maxTurns: 15
memory: project
---

# Content Writer Agent

You create Hebrew marketing content. Follow these rules strictly.

## Hebrew Writing Standards
- Technical terms stay in English: SEO, CPC, ROI, CTA, API
- Explanatory text in natural Hebrew -- not "translation Hebrew"
- Short sentences (max 20 words)
- Active voice: "תשתמשו ב-X" instead of "ניתן להשתמש ב-X"
- Professional but accessible tone

## Content Types You Handle
- Blog posts (800-1500 words)
- Ad copy (headlines + descriptions)
- Email campaigns (subject + body)
- Landing page text (hero, features, CTA)
- Social media posts

## Process for Each Content Piece
1. Check your agent memory for brand voice guidelines
2. Read existing content for tone matching (if available)
3. Research the topic via WebSearch (if needed)
4. Write the draft
5. Self-review: check grammar, tone, CTA presence
6. Save to the specified file
7. Update agent memory with any new brand patterns

## Quality Checklist
- [ ] No machine-translation artifacts
- [ ] Technical terms in English with Hebrew explanation on first use
- [ ] Clear CTA in every piece
- [ ] Under word limit
- [ ] Consistent brand voice

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

Agent Memory — זיכרון מתמשך בין סשנים

אחת הפיצ'רים העוצמתיים ביותר בסוכנים מותאמים הוא זיכרון מתמשך (Persistent Memory). בלי memory — כל הפעלה של סוכן מתחילה מאפס. עם memory — הסוכן שומר תובנות, דפוסים, ותגליות לתיקייה ייעודית, ומשתמש בהן בהפעלות הבאות.

איך זה עובד בפועל

כשמפעילים memory:

• ה-System Prompt של הסוכן כולל הנחיות לקריאה וכתיבה לתיקיית הזיכרון
• 200 השורות הראשונות של MEMORY.md נטענות אוטומטית לקונטקסט
• כלי Read, Write, Edit מופעלים אוטומטית כדי שהסוכן יוכל לנהל את הזיכרון שלו

שימוש אפקטיבי

הדרך הטובה ביותר לבנות זיכרון סוכן:

1. לפני משימה: בקשו מהסוכן "Review your memory for relevant patterns before starting"
2. אחרי משימה: בקשו "Save what you learned to your memory"
3. ב-System Prompt: הוסיפו הנחייה כמו: "Update your agent memory as you discover patterns, library locations, and key architectural decisions"

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

הרצה מקבילית של סוכנים

אחת היכולות החזקות ביותר של Subagents היא הרצה מקבילית (Parallel Execution). כשהמשימות עצמאיות, Claude יכול ליצור כמה סוכנים בו-זמנית ולחכות שכולם יסיימו.

דוגמה: ביקורת PR מקיפה

נניח שאתם רוצים לבדוק Pull Request מכמה זוויות. במקום לבדוק אותו סדרתית (אבטחה, אחר כך ביצועים, אחר כך סגנון), בקשו:

Review this PR for: security issues, test coverage, and code quality.
Run all three reviews in parallel.

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

הפקודה /simplify — דוגמה מובנית

Claude Code מגיע עם Skill מובנה בשם /simplify שמדגים בדיוק את הדפוס הזה. כשמפעילים /simplify, הוא:

1. מזהה את הקבצים שהשתנו לאחרונה
2. מפעיל 3 סוכני ביקורת במקביל:
   • סוכן Code Reuse — מחפש דפוסים שמופיעים בכמה מקומות ובודק אם כבר קיימות פונקציות עזר שמטפלות בלוגיקה הזו
   • סוכן Code Quality — קורא את הקוד כמו Reviewer: שמות משתנים, פירוק פונקציות, בהירות
   • סוכן Efficiency — מחפש הקצאות מיותרות, לולאות כפולות, ופעולות שאפשר לאגד
3. מסנתז את שלושת הדוחות
4. מתקן אוטומטית את הבעיות שנמצאו

הפקודה /batch — מקביליות בסקלה

הדרגה הבאה היא /batch: Skill שיכול ליצור עד 30 סוכנים עצמאיים, כל אחד ב-Git Worktree מבודד. כל סוכן מממש את היחידה שלו, מריץ טסטים, ופותח Pull Request. /batch מפעיל אוטומטית /simplify על השינויים לפני ה-commit.

עיצוב משימות להרצה מקבילית

הכלל הקריטי: אם סוכן B צריך את הפלט של סוכן A — הם חייבים לרוץ סדרתית. אם הם עצמאיים — תמיד מקביל.

Background Agents — סוכנים ברקע

סוכנים יכולים לרוץ בשני מצבים:

• Foreground (ברירת מחדל) — חוסם את השיחה עד שהסוכן מסיים. בקשות הרשאה ושאלות עוברות אליכם ישירות.
• Background — רץ במקביל בזמן שאתם ממשיכים לעבוד. לפני ההפעלה, Claude מבקש את כל ההרשאות שהסוכן יצטרך מראש.

שלוש דרכים לשלוח סוכן לרקע:

1. בקשו מ-Claude: "Run this in the background"
2. לחצו Ctrl+B בזמן שסוכן רץ
3. הגדירו background: true ב-Frontmatter — הסוכן תמיד ירוץ ברקע

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

Agent Teams — שיתוף פעולה בין מופעים (ניסיוני)

Agent Teams הם הצעד הבא מעבר ל-Subagents. במקום מודל "בוס-עובד" (השיחה הראשית שולחת סוכנים שמדווחים חזרה), Teams מאפשרים שיתוף פעולה בין עמיתים — עם תקשורת דו-כיוונית, רשימת משימות משותפת, ותיאום עצמי.

הפעלה

כדי להפעיל Agent Teams, הגדירו את משתנה הסביבה ל-1 — דרך ה-Shell או דרך settings.json:

// settings.json
{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

ההבדל בין Subagents ל-Teams

מתי Teams ולא Subagents?

• Teams: כשהמשימה פתוחה וצריכים "דיון" בין גישות שונות — "חקור שלוש ארכיטקטורות והשווה", "Debug בעיה שיכולה להיות ב-Frontend או Backend או DB"
• Subagents: כשהמשימה מוגדרת היטב — "בדוק אבטחה", "כתוב בדיקות", "פרמט קוד"

מצבי תצוגה

שני מצבים:

• In-Process (ברירת מחדל) — כל ה-Teammates רצים בטרמינל הראשי. Shift+Down מחליף בין Teammates. עובד בכל טרמינל.
• Split Panes — כל Teammate בחלון נפרד (דורש tmux או iTerm2). אפשר לראות את כולם במקביל.

ארכיטקטורה

כל צוות מורכב מ:

• Team Lead — הסשן הראשי שיוצר את הצוות ומתאם
• Teammates — מופעי Claude Code נפרדים
• Task List — רשימת משימות משותפת שכל אחד יכול לתפוס
• Mailbox — מערכת הודעות לתקשורת בין סוכנים

מתי להשתמש בסוכנים ומתי לעשות לבד

סוכנים הם כלי עוצמתי, אבל לא כל משימה צריכה אחד. הנה ה-Framework שיעזור לכם להחליט:

כלל 5 הדקות

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

Decision Framework מלא

ניתוח עלות-תועלת

הפעלת Subagent עולה בין $0.01 (Haiku, משימה פשוטה) ל-$2.00 (Opus, סריקה מורכבת), תלוי במודל ובמורכבות. אם ההפעלה חוסכת לכם 5 דקות של חקירה ידנית — זה שווה. אם המשימה לוקחת 10 שניות — עשו בעצמכם. שקלו גם Skills כחלופה: הם רצים בהקשר הראשי (לא מבודד) ולא צורכים קונטקסט נוסף.

The Orchestrator Pattern — בניית תזמורת

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

ארבעת השלבים של הדפוס

דוגמה מלאה: "בצע ביקורת קוד לפרויקט"

Audit this codebase comprehensively. Spawn these agents in parallel:
1. security-reviewer: scan for vulnerabilities
2. An explore agent: map all external dependencies and their versions
3. A general agent: run the test suite and report coverage
4. content-writer: review all user-facing strings for quality

Collect all four reports and synthesize into one audit document
with prioritized recommendations.

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

Chain Subagents — שרשרת סוכנים

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

Use the code-reviewer subagent to find performance issues,
then use the optimizer subagent to fix them

Claude משתמש בתוצאות הסוכן הראשון כקונטקסט לסוכן השני. זה מתאים לתהליכים סדרתיים כמו: ביקורת → תיקון → אימות.

Resume — המשכת סוכן קיים

כל סוכן מקבל Agent ID. אפשר לחדש סוכן שסיים במקום ליצור אחד חדש מאפס. הסוכן המחודש שומר את כל ההיסטוריה שלו:

Continue that code review and now analyze the authorization logic

Claude משתמש ב-SendMessage עם ה-Agent ID כדי להעיר את הסוכן. תעתוקי סוכנים נשמרים ב-~/.claude/projects/{project}/{sessionId}/subagents/.

ניהול עלויות סוכנים

כל סוכן הוא מופע נפרד עם חלון הקשר משלו — מה שאומר שעלויות ה-Token מוכפלות עם כל סוכן. בחירת המודל היא המנוף הגדול ביותר:

מדריך בחירת מודל לפי סוג משימה

maxTurns — הרצועה שמונעת סוכנים בורחים

תמיד הגדירו maxTurns — במיוחד לסוכנים יקרים. בלי מגבלה, סוכן Opus יכול לרוץ ולרוץ עד שנגמר לו הקונטקסט, ותשלמו על כל Token.

מעקב עלויות

השתמשו בפקודה /cost כדי לראות את ההוצאה המצטברת כולל כל הפעלות הסוכנים. בדקו אותה באופן קבוע בזמן עבודה עם הרבה סוכנים. ב-Statusline (שורת הסטטוס בתחתית), אפשר לראות גם חלונות Rate Limit של 5 שעות ו-7 ימים.

סוכנים ו-Skills — החיבור

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

שני כיוונים של חיבור

יש שני כיוונים לחיבור בין Skills ו-Agents:

1. Skill שמפעיל Agent — ב-Skill, שדה context: fork מפעיל את הסוכן שמצוין בשדה agent. ההנחיות של ה-Skill מוזרקות לסוכן.
2. Agent שטוען Skills — בסוכן, שדה skills ב-Frontmatter טוען Skills לתוך הקונטקסט של הסוכן. התוכן המלא מוזרק, לא רק זמין להפעלה.

כיוון 1: Skill שמפעיל Agent

# File: .claude/commands/security-check.md
---
name: security-check
description: Run a full security audit
agent: security-reviewer
context: fork
---

Scan the following paths for security vulnerabilities:
- src/api/
- src/auth/
- src/middleware/

Focus on injection attacks and authentication bypass.
Report findings with severity levels.

כשמריצים /security-check, Claude:

1. מוצא את ה-Skill security-check
2. רואה שהוא מציין agent: security-reviewer עם context: fork
3. מפעיל את הסוכן security-reviewer עם ההנחיות של ה-Skill
4. הסוכן רץ בבידוד (Forked Context) — לא מזהם את השיחה הראשית

כיוון 2: Agent שטוען Skills

---
name: api-developer
description: Implement API endpoints following team conventions
skills:
  - api-conventions
  - error-handling-patterns
---

Implement API endpoints. Follow the conventions and patterns
from the preloaded skills.

הסוכן מקבל את התוכן המלא של כל Skill ישירות לקונטקסט שלו. שימו לב: סוכנים לא יורשים Skills מהשיחה הראשית — צריך לציין אותם במפורש.

למה החיבור הזה חזק?

• הפרדת אחריות: ה-Skill מגדיר את המשימה הספציפית, הסוכן מגדיר את הכלים, המודל, והמגבלות
• שימוש חוזר: אפשר ליצור כמה Skills שמשתמשים באותו Agent, או Agent אחד שמשרת כמה Skills
• בידוד: הסוכן רץ ב-Forked Context — ההקשר של השיחה הראשית נשאר נקי
• ידע מוטמע: Skills שנטענים לסוכן נותנים לו Domain Knowledge מבלי שיצטרך לגלות אותו

ספרייה של Skills + Agents

מילון מונחים

Frameworks להחלטות — סיכום

שגרת עבודה — Agents בשוטף

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

בדוק את עצמך — האם עברת את פרק 2?

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

• מבין מה זה Subagent ואיך חלון ההקשר הנפרד שלו עובד
• מכיר את הסוכנים המובנים: Explore (Haiku), Plan (inherit), General-Purpose (inherit, כל הכלים)
• יצרתי תיקיית .claude/agents/ בפרויקט שלי
• יש לי לפחות סוכן מותאם אחד עובד (Security Reviewer או Content Writer)
• מבין את כל שדות ה-Frontmatter: name, description, model, tools, disallowedTools, effort, maxTurns, hooks, memory, permissionMode, skills, mcpServers, background, isolation
• יודע את ההבדל בין tools (Allowlist) ל-disallowedTools (Blocklist) ואיך הם עובדים ביחד
• מכיר את /agents — הפקודה לניהול אינטראקטיבי של סוכנים
• הרצתי סוכנים במקביל (לפחות /simplify) וראיתי את הדוח המסונתז
• מבין מתי להשתמש בסוכן ומתי לעשות לבד (כלל 5 הדקות)
• מכיר את Orchestrator Pattern — פירוק, בחירה, הרצה, סינתזה
• יודע לבחור מודל לסוכן לפי סוג המשימה (Haiku/Sonnet/Opus)
• מגדיר maxTurns לכל סוכן כדי לשלוט בעלויות
• בדקתי עלויות עם /cost לפני ואחרי הפעלת סוכן
• מכיר את הקשר בין Agents ל-Skills — שני כיוונים: Skill שמפעיל Agent ו-Agent שטוען Skills
• מבין Agent Memory — שלושה scopes: user, project, local
• מודע ל-Agent Teams (ניסיוני) וההבדל מ-Subagents
• מכיר Background Agents — הרצה ב-Ctrl+B או background: true
• יש לי שגרת עבודה מתוכננת לשימוש בסוכנים

סיכום הפרק