זרימות עבודה מתקדמות — הכל ביחד

סוכני צד שלישי — Claude ו-Codex בתוך Copilot

עד עכשיו בקורס הזה עבדתם עם Copilot Agent Mode — הלולאה האגנטית המובנית של GitHub שמשתמשת במודלים כמו GPT-4.1, Claude Sonnet, ו-Gemini. אבל מפברואר 2026 GitHub פתחה את המערכת בצורה דרמטית: עכשיו אפשר להריץ סוכני צד שלישי (Third-Party Agents) — Claude מבית Anthropic ו-Codex מבית OpenAI — ישירות בתוך VS Code, GitHub.com, ואפילו GitHub Mobile. זו לא סתם עוד תוספת — זה שינוי יסודי שהופך את GitHub ל-פלטפורמה רב-סוכנית שבה אתם בוחרים את הסוכן הנכון לכל משימה.

בואו נבהיר את ההבדל המהותי: מודל הוא לא סוכן. בפרק 3 למדתם לבחור מודל — למשל Claude Sonnet 4 — בתוך Agent Mode של Copilot. במקרה הזה, הכלים, ה-prompt, והלולאה האגנטית היו של Copilot, והמודל רק "ענה" על שאלות בתוך המסגרת של Copilot. סוכן צד שלישי זה משהו שונה לגמרי: כשאתם מפעילים Claude agent, כל ההרנס (harness) — הכלים, הלולאה האגנטית, מנגנון האישורים, השפה הפנימית — מגיע מ-Anthropic. זה אותו מנוע בדיוק שרץ ב-Claude Code כשאתם עובדים בטרמינל, רק שהפעם הוא רץ בתוך VS Code עם חיוב דרך מנוי Copilot. באותו אופן, כש-Codex agent רץ — כל המנוע, הכלים, ושיטת העבודה הם של OpenAI.

למה זה חשוב? כי כל סוכן מביא חוזקות שונות. Copilot Agent Mode מעולה לעבודה יומיומית עם גמישות בבחירת מודל. Claude מביא חלון קונטקסט עצום (עד 1M tokens) וכלי review ייחודיים. Codex מביא מודלי reasoning שמצטיינים בתכנון שיטתי ו-sandbox מבודד שמגן על הקוד שלכם. ביחד, שלושת הסוכנים נותנים לכם ארגז כלים שלם שמכסה כל תרחיש.

Agent HQ — מרכז הבקרה

GitHub הקימה ממשק מרכזי בשם Agent HQ שנותן לכם תמונה אחידה על כל הסוכנים. מ-Agent HQ ב-GitHub.com אתם יכולים:

• להקצות issue לסוכן ספציפי (Copilot, Claude, או Codex)
• להקצות אותו issue לשלושת הסוכנים במקביל ולהשוות את ה-PRs שהם מייצרים
• לעקוב אחרי sessions פעילים — כולל logs מפורטים של מה הסוכן עשה ולמה
• לסקור PRs שנוצרו על ידי סוכנים ולבקש תיקונים

כל סוכן שרץ ב-Agent HQ מקבל גישה לקוד הריפוזיטורי, היסטוריית commits, issues, Copilot Memory (זיכרון מתמשך ברמת ריפו), ומדיניות הריפוזיטורי. כלומר — גם סוכן חדש שלא עבד על הפרויקט שלכם מקבל הקשר עשיר.

מי יכול להשתמש?

נכון לפברואר 2026, סוכני צד שלישי זמינים בכל התוכניות בתשלום:

בתחילה (4 בפברואר 2026) זה היה רק ל-Pro+ ו-Enterprise, אבל תוך שלושה שבועות (26 בפברואר) הורחב לכל התוכניות בתשלום. אין עלות נוספת — כל session של סוכן צורכת premium request אחד מהמכסה שלכם. זה הופך את זה לעסקה מצוינת: ב-Pro ($10/חודש) עם 300 קרדיטים, כל session של Claude agent או Codex agent עולה premium request אחד — כלומר פחות מ-$0.04 ב-overage.

מה כל סוכן מקבל גישה אליו? כשאתם מפעילים סוכן צד שלישי, הוא רואה את ה-workspace שלכם (ב-local) או את הריפוזיטורי (ב-cloud). בנוסף, כל סוכן מקבל גישה ל:

• קוד המקור וכל הקבצים בריפו
• היסטוריית Git — commits, branches, diffs
• Issues ו-Pull Requests פתוחים
• Copilot Memory — הנחיות וזיכרון מתמשך ברמת ריפו שנשמר בין sessions
• מדיניות הריפוזיטורי (repository policies) — כללים שהוגדרו ברמת הארגון

קונטקסט לא משותף — כלל קריטי

אחד הדברים החשובים ביותר להבין: כל סוכן פועל ב-session עצמאי. כשאתם מדברים עם Copilot Agent Mode ואז עוברים ל-Claude agent — Claude לא יודע מה Copilot עשה. אין שיתוף קונטקסט (Context Isolation), אין זיכרון משותף, אין העברת מצב.

זה לא באג, זה by design. כל סוכן יוצר CopilotSession עצמאית עם בידוד מלא — אין state, אין cross-contamination. זה חשוב מבחינת אבטחה: אם סוכן אחד קיבל גישה למידע רגיש, סוכן אחר לא יכול לגשת אליו דרך זיכרון משותף. אבל זה גם אומר שאתם צריכים לתכנן: אם רוצים להעביר ידע בין סוכנים, תעשו את זה דרך קבצים.

הטכניקה: כתבו את התוצאה של סוכן אחד לקובץ (PLAN.md, ANALYSIS.md, או כל קובץ אחר), ואז תנו לסוכן השני לקרוא אותו. זה עובד כי כל הסוכנים חולקים את אותו workspace (ב-local) או ריפוזיטורי (ב-cloud). הקובץ הוא "ערוץ התקשורת" בין הסוכנים.

Claude כסוכן — מקומי וענן

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

Claude Local Agent — אותו מנוע כמו Claude Code

Claude Local Agent רץ ישירות ב-VS Code על המחשב שלכם. הוא משתמש ב-Claude Agent SDK של Anthropic — אותו harness בדיוק שמפעיל את Claude Code בטרמינל. זה אומר שאתם מקבלים את אותם כלים, אותם prompts, ואותה ארכיטקטורה — רק בתוך ממשק גרפי של VS Code במקום בטרמינל.

למה זה משנה? כי Claude Agent SDK מביא יכולות שלא קיימות ב-Copilot Agent Mode: מערכת זיכרון מתמשך (CLAUDE.md), כלי סקירת אבטחה ייעודיים, היכולת ליצור sub-agents מתמחים, ו-lifecycle hooks. בנוסף, Claude Opus 4.6 מגיע עם חלון קונטקסט של עד 1 מיליון tokens — פי 8-30 מ-Copilot Agent Mode שמוגבל ל-32K-128K. כשיש לכם codebase של עשרות אלפי שורות שצריך refactoring, ההבדל הזה הוא עצום.

איך מפעילים:

1. פתחו Chat ב-VS Code (Ctrl+Alt+I)
2. לחצו New Chat
3. ב-dropdown של Session Type בחרו Claude
4. הקלידו את הפרומפט — Claude יתחיל לעבוד על ה-workspace שלכם

מצבי הרשאה (Permission Modes):

Slash Commands מיוחדים של Claude:

Claude agent מביא איתו פקודות שלא קיימות ב-Copilot Agent Mode:

Claude Cloud Agent — פותח PRs מהענן

Claude Cloud Agent רץ על תשתית GitHub, לא על המחשב שלכם. זה מצב שונה לגמרי מה-local agent, וצריך לחשוב עליו אחרת — כאילו אתם שולחים משימה לעובד חיצוני שמחזיר PR מוכן.

ההבדלים העיקריים מ-local agent:

• אסינכרוני לחלוטין: שולחים משימה וממשיכים לעבוד — Claude עובד ברקע על תשתית GitHub. אתם יכולים לעקוב אחרי ההתקדמות ב-logs בזמן אמת, אבל לא יכולים להתערב באמצע
• פותח PRs: התוצאה מגיעה כ-Pull Request מלא עם diff, תיאור, ולפעמים גם tests. אתם סוקרים ועושים merge
• גישה מוגבלת: אין גישה ל-MCP servers מקומיים שלכם, אין גישה ל-extensions של VS Code. הסוכן עובד רק עם הקוד שבריפו
• לא אינטראקטיבי: לא יכולים לתקן כיוון בזמן אמת. אם הסוכן הלך בכיוון לא נכון, תצטרכו לחכות שיסיים ואז לתת הוראות חדשות
• יתרון: לא תופס משאבים על המחשב שלכם, ומייצר PR ב-format של GitHub שקל לסקור בצוות

מתי cloud agent עדיף על local? כשהמשימה מוגדרת היטב (למשל: "Fix the authentication bug described in issue #42") וכשאתם רוצים PR מוכן לסקירה שאפשר לשלוח לצוות. Local agent עדיף כשצריך אינטראקציה מהירה, MCP servers, או כשהמשימה דורשת חקירה שאתם רוצים לפקח עליה.

איך מפעילים cloud session ב-VS Code:

1. ב-dropdown של Session Type בחרו Cloud
2. ב-dropdown של Partner Agent בחרו Claude
3. הקלידו את המשימה — Claude מתחיל לעבוד ברקע
4. עקבו אחרי ההתקדמות ב-logs שמתעדכנים בזמן אמת

איך מפעילים cloud session ב-GitHub.com:

1. פתחו issue בריפוזיטורי שלכם
2. ב-Assignees, בחרו Claude
3. Claude מתחיל לעבוד — תקבלו עדכונים על ההתקדמות
4. כשמסיים — PR חדש יופיע עם כל השינויים

Codex כסוכן ענן — sandbox אסינכרוני

OpenAI Codex הוא הסוכן של OpenAI, ויש לו גישה שונה לחלוטין מ-Claude ומ-Copilot Agent Mode. ההבדל המרכזי: Codex רץ אך ורק בענן, ב-sandbox מבודד לחלוטין. אין לו מצב local — כל session רצה ב-microVM נפרד על תשתית GitHub.

איך Codex עובד

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

1. שכפול: GitHub משכפל את הריפוזיטורי לתוך microVM חדש ומבודד
2. ניתוח: Codex קורא את הקוד, ה-issues, וההיסטוריה
3. תכנון: מודלי o3/o4-mini — מודלי reasoning של OpenAI — מפרקים את המשימה לצעדים מסודרים
4. ביצוע: הסוכן כותב קוד, מריץ tests, מתקן שגיאות — הכל בתוך ה-sandbox
5. תוצאה: PR מוכן עם diff, תיאור, ותוצאות tests

למה sandbox? כי הסוכן עובד בסביבה מבודדת לחלוטין, הוא יכול לנסות דברים בלי סיכון. אם הוא שובר משהו — זה רק ב-sandbox. הקוד המקורי שלכם לא נפגע. זה נותן ל-Codex חופש לנסות גישות שונות, להריץ tests, ולתקן עד שהתוצאה טובה.

מתי Codex עדיף?

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

• Test generation: "Add unit tests for all modules in the utils/ directory" — Codex יעבור שיטתית על כל קובץ, יבין את הפונקציות, ויכתוב tests מכסים. זו משימה ש-Codex עושה בצורה מצוינת כי היא שיטתית, חזרתית, וברורה
• Migration: "Migrate all database queries from Sequelize v5 to v6 API" — שינוי מבני על הרבה קבצים שהמודלים o3/o4-mini מנתחים ומבצעים בצורה שיטתית
• Refactoring patterns: "Extract all inline SQL queries to a data access layer" — שינוי מבני שחוזר על עצמו בדפוס קבוע
• Documentation: "Add JSDoc comments to all exported functions" — Codex קורא כל פונקציה, מבין מה היא עושה, וכותב תיעוד
• Linting fixes: "Fix all ESLint errors in the project" — עבודה מכנית שמטרתה להעביר CI

המודלים o3/o4-mini מעולים בפירוק בעיה לצעדים ובביצוע שיטתי. כי הכל קורה ב-sandbox, אין לחץ — הסוכן יכול לנסות, להיכשל, ולתקן בלי שום השפעה עליכם. אם הניסיון הראשון לא עבד — הוא מנסה שוב.

Codex vs Claude Cloud — מתי מה?

שני הסוכנים יכולים לעבוד בענן ולייצר PRs. אבל יש הבדלים מהותיים:

מגבלות Codex: אין מצב local, אין אינטראקציה בזמן אמת, אין גישה ל-MCP servers, ואין גישה למשאבים מחוץ ל-sandbox. אם המשימה דורשת גישה ל-API חיצוני, database מקומי, או כל משאב שלא בריפו — Codex לא הכלי הנכון.

איך מפעילים:

1. ב-VS Code: Session Type ← Cloud, אז Partner Agent ← Codex
2. ב-GitHub.com: ב-Agent HQ, בחרו Codex בתור הסוכן ו-assign issue

השוואה: Copilot Agent Mode vs Claude vs Codex

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

שלושת הסוכנים נבדלים ב-5 ממדים מרכזיים: harness (מי מפעיל את הלולאה האגנטית), מודלים (איזה מוח חושב), מצב ריצה (מקומי או ענן), אינטראקטיביות (כמה שליטה לכם בזמן אמת), ו-חלון קונטקסט (כמה קוד הסוכן "רואה" בו-זמנית). בואו נפרק:

חמשת ממדי ההשוואה — בפירוט

1. Harness — מי מנהל את השיחה? Copilot Agent Mode משתמש ב-harness של GitHub/Microsoft — הלולאה האגנטית, מנגנון הכלים, ואופן קבלת ההחלטות מוגדרים על ידי GitHub. Claude agent משתמש ב-harness של Anthropic — אותו מנוע בדיוק שמפעיל את Claude Code. זה אומר ש-Claude מביא כלים ייחודיים (/memory, /security-review, /agents) ודפוסי חשיבה שונים. Codex משתמש ב-harness של OpenAI עם מודלי reasoning (o3, o4-mini) שמפרקים בעיות באופן שונה — שיטתי ומובנה יותר.

2. מודלים — איזה "מוח" חושב? Copilot נותן לכם את הגמישות הגדולה ביותר: GPT-4.1 (חינם!), Claude Sonnet, Gemini Pro, ועוד — ואפשר לשנות מודל באמצע שיחה. Claude agent מוגבל למודלי Claude (Sonnet, Opus), אבל Opus 4.6 הוא אחד המודלים החזקים ביותר עם חלון קונטקסט עצום. Codex מוגבל ל-o3 ו-o4-mini — מודלי reasoning שמצטיינים בפירוק בעיות מורכבות אבל לא בהכרח הטובים ביותר לשיחה חופשית.

3. מצב ריצה — מקומי או ענן? Copilot Agent Mode רץ רק מקומית ב-VS Code. Claude מציע שני המצבים: local (אינטראקטיבי) ו-cloud (אסינכרוני). Codex רץ רק בענן, ב-sandbox. זה אומר ש-Claude הוא הגמיש ביותר מבחינת מצב ריצה — אבל Codex הוא הבטוח ביותר כי הוא תמיד מבודד.

4. אינטראקטיביות — כמה שליטה? Copilot ו-Claude local נותנים שליטה מלאה — רואים כל צעד, מאשרים שינויים, מתקנים כיוון. Cloud agents (Claude cloud, Codex) הם fire-and-forget — שולחים ומחכים. אפשר לעקוב ב-logs, אבל לא להתערב.

5. חלון קונטקסט — כמה "רואה"? זה ההבדל הכי דרמטי. Copilot Agent Mode עובד עם 32K-128K tokens — מספיק לרוב המשימות היומיומיות. Claude Opus 4.6 עם עד 1 מיליון tokens — יכול "לראות" 25,000-30,000 שורות קוד בבת אחת. Codex ב-sandbox משכפל את כל הריפו, אז גודל הקונטקסט לא מגביל אותו — אבל הוא לא מחזיק הכל בזיכרון בו-זמנית כמו Claude.

השוואת Agent HQ — שלושה סוכנים על אותו issue

אחד הפיצ'רים החזקים של Agent HQ הוא היכולת להקצות אותו issue לשלושת הסוכנים במקביל. כל אחד ייצר PR עצמאי, ואתם בוחרים את הטוב ביותר (או עושים cherry-pick מכמה). זו דרך מצוינת ללמוד את הסגנון של כל סוכן — ואחרי 2-3 ניסיונות כאלה תדעו בדיוק מי עדיף לאיזו משימה.

שילוב VS Code + CLI + GitHub.com

עד עכשיו למדתם כל כלי בנפרד: VS Code בפרקים 1-5, CLI בפרק 6, fleet בפרק 7, GitHub.com בפרק 8. כל כלי מעולה בתחום שלו, אבל הכוח האמיתי מתגלה כשמשלבים אותם — Multi-Tool Workflow.

הרעיון פשוט אבל חזק: לכל שלב בפיתוח יש כלי שעושה אותו הכי טוב. במקום לעשות הכל ב-VS Code (מה שרוב המפתחים עושים), אתם מפזרים את העבודה למקום הנכון. תכנון ב-CLI, חקירה ב-VS Code, בנייה מקבילית עם fleet, סקירה ב-GitHub.com, ופרסום עם Coding Agent. כל כלי במקום שלו — כמו סרט צבא מאורגן.

למה לא לעשות הכל ב-VS Code? כי:

• CLI מהיר יותר לתכנון: פקודה אחת בטרמינל מייצרת תוכנית, בלי לפתוח UI
• Fleet מאפשר מקביליות: 3-5 סוכנים עובדים על worktrees שונים בו-זמנית — דבר שלא אפשרי ב-VS Code agent בודד
• GitHub.com מאפשר אסינכרוניות: שולחים issue ל-coding agent, ממשיכים לעבוד, PR מגיע כשמוכן
• Code Review ב-GitHub.com הוא אגנטי: הסוכן קורא את כל הריפו, לא רק את ה-diff

שלב 1: Plan — תכנון עם CLI או Cloud Agent

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

• Copilot CLI: הריצו copilot "plan a refactoring of the auth module to use middleware pattern" — תקבלו תוכנית טקסטואלית שאפשר לערוך. הפלט הולך ישירות לטרמינל, ואפשר לשמור אותו: copilot "..." > PLAN.md
• Cloud Agent (plan mode): מאפריל 2026, הסוכן בענן יכול לייצר implementation plan ולחכות לאישור לפני שכותב קוד. שולחים בקשה ב-GitHub.com, מקבלים תוכנית מפורטת, מאשרים, והסוכן מבצע. היתרון: התוכנית נשארת ב-GitHub ואפשר לשתף אותה עם הצוות לפני שמתחילים

Output של השלב: קובץ PLAN.md עם רשימת משימות ממוספרת, קבצים מושפעים, רמות סיכון, וסדר ביצוע מומלץ.

שלב 2: Explore — חקירה עם VS Code

לפני שמשנים קוד, צריך להבין אותו. VS Code הוא המקום הטוב ביותר לחקור codebase כי יש לכם את הכל — עורך, טרמינל, debugger, ו-agent שיכול לחפש בקוד:

• Copilot Agent Mode עם כלי codebase לחיפוש סמנטי — שאלו "Where is authentication handled?" ותקבלו תשובה מדויקת עם נתיבי קבצים
• Claude local agent עם /review לסקירה מקדימה — Claude קורא את הקוד ומספר מה טוב, מה בעייתי, ומה צריך שיפור. המידע הזה מעדכן את התוכנית
• Ask mode (מפרק 1) לשאלות מהירות — "What pattern does this module use?" בלי להפעיל את כל המנוע האגנטי

Output של השלב: הבנה מעמיקה של הקוד הקיים, רשימת תלויות, ותוכנית מעודכנת.

שלב 3: Build — בנייה עם Agent, Fleet, או CLI

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

• משימה בודדת, אינטראקטיבית: VS Code Agent Mode או Claude local agent — אתם רואים כל שינוי ומאשרים
• מספר משימות מקבילות: /fleet דרך CLI (מפרק 7) — 3-5 סוכנים עובדים על worktrees שונים בו-זמנית. כל סוכן מקבל משימה אחת מהתוכנית
• משימה גדולה ברקע: Codex cloud agent — שלחו ותחזרו. בזמן ש-Codex עובד ב-sandbox, אתם יכולים להמשיך לקדד ב-VS Code
• שילוב: Claude local למשימות שדורשות הקשר עמוק + Codex cloud למשימות שיטתיות. שניהם עובדים במקביל

Output של השלב: קוד עובד על branch, tests רצים.

שלב 4: Review — סקירה עם GitHub.com

ממרץ 2026, Copilot Code Review רץ על ארכיטקטורה אגנטית — הוא לא רק מסתכל על ה-diff אלא משתמש ב-tool calling כדי לאסוף הקשר מכל הריפוזיטורי. בפועל זה אומר:

• Code Review מזהה באגים שנובעים מתלות בקבצים אחרים — לא רק בקוד שהשתנה
• הוא מזהה בעיות אבטחה: secrets שנחשפו, תלויות פגיעות, injection flaws
• הוא מציע תיקונים ויכול ליצור PR תיקון אוטומטי דרך coding agent — לחיצה אחת על "Apply fix"

בנוסף, אפשר להשתמש ב-Claude local agent עם /security-review לניתוח אבטחה מעמיק יותר — במיוחד לפרויקטים רגישים.

Output של השלב: PR שעבר סקירה אגנטית ואנושית, מוכן ל-merge.

שלב 5: Publish — פרסום עם Coding Agent

Coding Agent (מפרק 8) רץ על GitHub Actions, מריץ tests, סורק אבטחה (code scanning, secret scanning, dependency vulnerability), ויוצר PR מוכן. אחרי שהסקירה עוברת — merge ו-deploy. אם יש בעיות — Coding Agent יכול לתקן אוטומטית.

Output של השלב: קוד ב-main, CI ירוק, deployed.

למה שלא לעשות הכל ב-step אחד?

שאלה טובה. מפתחים רבים שואלים: "למה לא פשוט לתת ל-Claude local agent את כל המשימה מההתחלה?" התשובה: כי כל שלב נותן feedback שמשפר את השלב הבא. כשאתם מתכננים קודם (Plan), אתם מזהים בעיות לפני שהן הופכות לקוד. כשאתם חוקרים (Explore), אתם מגלים תלויות שלא חשבתם עליהן. כשאתם סוקרים (Review), אתם מוצאים באגים שהסוכן יצר — לפני שהם מגיעים ל-production. 5 שלבים קצרים עם feedback loops טובים יותר משלב אחד ארוך בלי בקרה.

כמובן, לא כל משימה דורשת את כל 5 השלבים. תיקון באג פשוט? Agent Mode ישירות (שלבים 3+5). פיצ'ר חדש בינוני? Plan + Build + Review (שלבים 1+3+4). הזרימה המלאה נדרשת לפרויקטים מורכבים — ואז כל שלב חוסך זמן בשלב הבא.

טיפ מתקדם: Worktree Isolation

כשעובדים עם CLI ו-VS Code במקביל, השתמשו ב-Worktree Isolation (מפרק 6): ה-CLI יוצר Git worktree נפרד, כך שהשינויים של הסוכן לא מתנגשים עם מה שאתם עושים בעורך. כשהסוכן מסיים — בדקו את ה-diff ועשו merge. זה קריטי כשעובדים עם fleet: 5 סוכנים על 5 worktrees, כל אחד עובד על חלק אחר של הפרויקט בלי להפריע לשאר.

Decision Framework — 4 שאלות שקובעות הכל

אחרי 12 פרקים יש לכם לפחות 17 כלים ומצבים שונים. האתגר הוא לא לדעת מה קיים — אלא לדעת מה להשתמש עכשיו. בלי מסגרת החלטה, מה שקורה בפועל הוא אחד משניים: או שאתם משתמשים באותו כלי לכל דבר (בזבוז פוטנציאל), או שאתם מתלבטים 5 דקות לפני כל משימה (בזבוז זמן). בואו נבנה Decision Framework — מערכת 4 שאלות שמובילה לבחירה הנכונה תוך 15 שניות.

שאלה 1: מה המשימה?

שאלה 2: כמה אינטראקטיביות?

• "אני רוצה לראות כל צעד" → מקומי (VS Code / CLI)
• "תעשה ותביא PR" → ענן (Cloud Agent / Codex)

שאלה 3: כמה קונטקסט צריך?

• קובץ בודד / מודול קטן (עד ~128K tokens): Copilot Agent Mode מספיק
• codebase שלם (128K-1M tokens): Claude הוא הבחירה — חלון קונטקסט עד 1M
• כל הריפו (Codex sandbox): Codex משכפל את הכל ל-sandbox, אז גודל לא מגביל

שאלה 4: מה התקציב?

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

• חסכוני (Pro, 300 קרדיטים/חודש): GPT-4.1 (0x, חינם) לשגרה → Sonnet (0.25x-1x) למורכב. סוכני צד שלישי — 1 premium request לכל session, אז שמרו אותם למשימות גדולות
• מאוזן (Pro, שימוש חכם): auto model selection (הנחה 10%) לרוב המשימות → Claude/Codex cloud ל-2-3 משימות גדולות בשבוע. זה עובד אם יש לכם 300 קרדיטים ואתם מקפידים על GPT-4.1 לשגרה
• ללא הגבלה (Pro+, 1500 קרדיטים/חודש): Claude Opus local לכל דבר מורכב, Codex ל-systematic tasks, auto לכל השאר. ב-1500 קרדיטים יש מספיק לשילוב חופשי של כל הסוכנים

דוגמה מספרית: יום עבודה טיפוסי של מפתח ב-Pro ($10/חודש, 300 קרדיטים):

5 קרדיטים ליום × 22 ימי עבודה = 110 קרדיטים. נשארים 190 קרדיטים למשימות מורכבות עם Opus או לימים עמוסים. זו אסטרטגיה בת-קיימא שמאפשרת שימוש חופשי בסוכני צד שלישי בלי לחשוש מחריגה. ואם כן חרגתם — overage עולה $0.04 לקרדיט, כלומר 10 קרדיטים נוספים = 40 סנט. לא דרמטי.

איך ה-Decision Framework עובד בפועל — 3 תרחישים

תרחיש 1: באג דחוף ב-production

• Q1: תיקון באג → כלי מהיר
• Q2: אני צריך לראות כל צעד בזמן אמת → מקומי
• Q3: באג בקובץ אחד, עד 128K מספיק → Copilot
• Q4: חינם עדיף → GPT-4.1
• תשובה: Copilot Agent Mode + GPT-4.1 → 0 קרדיטים, תיקון תוך דקות

תרחיש 2: migration של ORM על 40 קבצים

• Q1: עבודה שיטתית על הרבה קבצים → כלי שיטתי
• Q2: המשימה ברורה, לא צריך פיקוח → ענן
• Q3: צריך לקרוא 40 קבצים → sandbox או 1M context
• Q4: 1 premium request → מתקבל
• תשובה: Codex cloud agent → sandbox מבודד, reasoning שיטתי, PR מוכן

תרחיש 3: refactoring ארכיטקטוני של microservice

• Q1: refactoring עמוק → כלי עם הבנה מעמיקה
• Q2: אני רוצה לראות את התוכנית ולאשר → מקומי
• Q3: צריך להבין 20,000 שורות קוד → מעל 128K, צריך 1M
• Q4: מוכן לשלם על Opus → Claude
• תשובה: Claude local agent (Plan mode) + Opus → קריאת כל הקוד, תוכנית, ביצוע עם אישורים

פרויקט Capstone — רפקטורינג מקצה לקצה

הגיע הזמן להרכיב הכל. זה הפרויקט שמחבר בין 12 פרקים ומוכיח שאתם שולטים לא רק בכל כלי בנפרד, אלא גם ביכולת לשלב ביניהם בצורה חלקה. תבצעו פרויקט רפקטורינג מקצה לקצה שמשלב את כל הכלים שלמדתם בקורס — IDE, CLI, GitHub.com, וסוכני צד שלישי.

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

מתי לא להשתמש בסוכני צד שלישי?

לא כל משימה דורשת Claude או Codex. הנה מקרים שבהם Copilot Agent Mode הוא הבחירה הנכונה:

• תיקון באג פשוט: שינוי בשורה אחת, תיקון typo, עדכון dependency — Agent Mode עם GPT-4.1 (חינם) מספיק בהחלט
• שאלות מהירות: "What does this function do?" — Ask mode, לא צריך סוכן שלם
• פיצ'ר קטן ב-2-3 קבצים: Agent Mode מהיר יותר כי לא צריך להפעיל harness נפרד
• כשצריך גמישות מודל: רק Copilot Agent Mode מאפשר לכם לבחור בין 10+ מודלים ולשנות באמצע

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

סיכום הפרק — מה למדנו ומה הלאה?

בשלב הזה של הקורס כבר יש לכם את כל הכלים וה-frameworks. מה שנשאר הוא לתרגל. הניסיון מראה שמפתחים שמשתמשים ב-Decision Framework באופן מודע במשך שבועיים ראשונים — מפסיקים לחשוב על זה אחרי חודש. זה הופך לטבע שני. לכן הדבר החשוב ביותר הוא: תתחילו עכשיו. לא מחר, לא "כשיהיה פרויקט מתאים" — עכשיו. כל משימה, גם קטנה, היא הזדמנות לתרגל את ה-framework.

מפת הכלים המלאה — סיכום 12 פרקים

ב-12 פרקים כיסינו 17+ כלים ומצבים שונים. הטבלה הבאה היא המפה הסופית — שמרו אותה בהישג יד. לכל כלי יש "sweet spot" — התרחיש שבו הוא הבחירה הנכונה ביותר. כשתתרגלו להסתכל על הטבלה לפני שמתחילים משימה, הבחירה תהפוך לאוטומטית תוך שבועיים.

שלוש שכבות של שימוש

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

אם אתם חדשים — התרכזו בשכבת הליבה. אחרי שבועיים, הוסיפו כלי אחד מ"כוח" כל שבוע. אחרי חודשיים, תגיעו גם ל"מומחיות" לפי הצורך.

מפת שילובים — מה עובד עם מה

חלק מהכלים עובדים מצוין ביחד. הנה השילובים הכי חזקים:

• CLI + VS Code: CLI לתכנון → VS Code לביצוע. ה-CLI מייצר PLAN.md, VS Code agent מבצע
• Claude local + Copilot Code Review: Claude כותב קוד עם /security-review → PR עולה ל-GitHub → Copilot Code Review בודק מנקודת מבט שונה
• Fleet + Codex: Fleet מריץ 3 סוכנים מקומיים על worktrees + Codex רץ ברקע ב-sandbox = 4 משימות במקביל
• Agent Mode + Claude local: Agent Mode לחקירה ראשונית (עם מודל חינמי) → Claude local לביצוע עמוק (עם Opus)
• Custom Instructions + כל סוכן: הנחיות ב-copilot-instructions.md משפיעות על Copilot Agent Mode, ו-CLAUDE.md משפיע על Claude agent — שימו הנחיות בשני הקבצים לעקביות

שגרת עבודה MASTER — כל הקורס

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

שימו לב: השגרה הזו כוללת את השגרות מפרקים 1-11. אם עקבתם אחרי השגרות הקודמות, חלק מהפעולות כבר מוכרות לכם. הפעולות החדשות מפרק 12 מסומנות ב-(חדש).

בדוק את עצמך

צ'קליסט סיום הקורס