לדלג לתוכן

0.3 נוף הכלים הרצאה

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

שלוש צורות של AI לקוד - three shapes of coding AI

כל tool AI לתכנות שתפגשו נופל, בגדול, לאחת משלוש קטגוריות:

  • צ'אט בדפדפן - chat: חלון שיחה נפרד מהקוד שלכם. אתם מדביקים קוד, שואלים, מקבלים תשובה, ומעתיקים בעצמכם בחזרה. דוגמה: claude.ai, ChatGPT.
  • עוזר IDE - IDE assistant: תוסף שיושב בתוך סביבת הפיתוח שלכם, רואה את הקוד הפתוח, ומציע completions או עריכות בתוך הקובץ עצמו. דוגמאות: Cursor, GitHub Copilot.
  • הagent CLI - CLI agent: תוכנית שרצה בטרמינל, שמקבלת ממכם משימה בשפה טבעית, וקוראת קבצים, עורכת אותם, מריצה פקודות (בדיקות, git, build) ומדווחת לכם - הכל בתוך לולאה אוטונומית. דוגמה: Claude Code.

ההבדל המרכזי בין השלושה הוא רמת האוטונומיה והגישה: צ'אט לא נוגע בכלום מלבד חלון השיחה. עוזר IDE נוגע בקובץ שאתם עורכים כרגע. הagent CLI יכול לגעת בכל דבר שאתם מרשים לו - לקרוא את כל הפרויקט, להריץ פקודות מערכת, לנווט בין קבצים, לתקן ולבדוק את עצמו בלולאה. ככל שעולים בסולם הזה, הtool יכול לעשות יותר בעצמו - אבל גם דורש יותר אמון ופיקוח מכם.

צ'אט בדפדפן - the browser chat

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

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

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

צ'אט הוא הtool הנכון לשלב החקירה והלמידה - "תסביר לי איך עובד OAuth", "מה ההבדל בין שתי גישות ארכיטקטורה" - ולא לשלב הביצוע על קוד אמיתי וגדול. נקדיש לו פרק שלם (פרק 1) כי הנדסת פרומפט שנלמדת שם רלוונטית לכל שאר הtools.

זרימת עבודה טיפוסית בצ'אט נראית כך:

You: [paste 40 lines of code] "There's a memory leak here, can you see where?"
The model: analyzes the pasted code, explains the problem, and suggests a fix
You: copy the suggested fix, paste it into your editor, manually check that it fits

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

עוזר IDE - the IDE assistant

הצורה השנייה משלבת את ה-AI ישירות לתוך סביבת הפיתוח. הtool רואה את הקובץ הפתוח (ולפעמים את כל הפרויקט), ומציע completions תוך כדי הקלדה, או מבצע עריכות ממוקדות לפי הוראה.

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

חולשות:
- מוגבל בעיקר לגבולות ה-IDE - קשה יותר לבצע דרכו משימות שדורשות הרצת פקודות מערכת, ניהול git מורכב, או תזמור בין tools חיצוניים.
- קל ליפול למצב של "לחיצת Tab מהירה" בלי לעצור ולבדוק כל הצעה - כי ההצעות מגיעות בקצב מהיר וטבעי כמו השלמה אוטומטית רגילה.
- לרוב, גם כשיש מצב "אג'נטי" בתוך ה-IDE, האוטונומיה שלו מוגבלת יחסית לagent CLI ייעודי.

Cursor ו-GitHub Copilot הם הדוגמאות המובילות כאן, ונקדיש להם הרצאות מלאות בפרק 5 - כולל מתי הם עדיפים על פני agent CLI, ומתי לא.

זרימת עבודה טיפוסית בעוזר IDE נראית כך: אתם כותבים חתימת פונקציה - def calculate_discount(price, user_tier): - ולוחצים Enter. הtool, שרואה את שאר הקובץ ולפעמים גם קבצים קשורים, מציע completion לגוף הפונקציה בזמן אמת, ואתם מאשרים אותה בלחיצת Tab או ממשיכים להקליד אם היא לא מתאימה. הרבה מהעוצמה כאן היא בזרימה החלקה - אין מעבר בין חלונות, אין העתק-הדבק.

הagent CLI - the CLI agent

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

Example of a typical flow with a CLI agent:
> "There's a bug: users can submit an empty registration form. Fix it."

The agent, on its own and without further guidance:
1. Searches the code for the relevant form file
2. Reads the existing logic
3. Identifies that input validation is missing
4. Writes the fix
5. Runs the existing tests to make sure nothing broke
6. Briefly reports what changed and why

חוזקות:
- אוטונומיה אמיתית - יכול לבצע משימה שלמה מקצה לקצה, כולל שלבים שלא ציינתם במפורש (למשל, להריץ בדיקות בסוף).
- גישה מלאה לטרמינל - git, tool build, סקריפטים, כל דבר שאתם כבר משתמשים בו.
- יכול לתקן את עצמו: אם פקודה נכשלת, הוא רואה את השגיאה וממשיך לנסות, בלי שתצטרכו להעתיק שגיאה בחזרה אליו.
- עובד מצוין למשימות רב-שלביות ומורכבות - חקירת קוד לא מוכר, refactoring רחב, דיבוג מערכתי.

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

אותה משימה, שלושה tools

כדי לחדד את ההבדל, הנה איך אותה משימה - "יש דליפת זיכרון בשירות שמעבד תמונות" - נראית בכל אחד משלושת הtools:

שלב צ'אט עוזר IDE הagent CLI
איתור הבעיה אתם מזהים ומדביקים את הקובץ החשוד אתם פותחים את הקובץ בעצמכם הagent מחפש בעצמו לפי תיאור הסימפטום
ניתוח המודל מנתח רק את מה שהדבקתם הtool רואה את הקובץ הפתוח, לפעמים גם קבצים מקושרים הagent קורא את כל השירות, כולל קבצים תלויים
תיקון אתם מעתיקים את ההצעה ידנית הצעת עריכה בתוך הקובץ, מאשרים בלחיצה הagent עורך את הקבצים ישירות
וידוא עליכם להריץ ולבדוק ידנית עליכם להריץ ולבדוק ידנית הagent מריץ את הבדיקות/הפרופיילר בעצמו ומדווח

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

טבלת השוואה מרכזית

קריטריון צ'אט בדפדפן עוזר IDE הagent CLI
גישה לקבצי הפרויקט לא (רק מה שמדביקים) קובץ פתוח, לפעמים פרויקט שלם כל הפרויקט, לפי הרשאה
הרצת פקודות (בדיקות, build, git) לא חלקי, תלוי tool כן, ישירות
היקף משימה טבעי שאלה / הסבר בודד שורה עד פונקציה פיצ'ר שלם, refactor רחב
רמת אוטונומיה אפס - אתם מבצעים כל פעולה נמוכה-בינונית גבוהה, בתוך הרשאות שהגדרתם
מהירות משוב תלוי בכם (העתק-הדבק) מיידי תוך כדי הקלדה תלוי במשך המשימה, לרוב דקות
דורש פיקוח על כל תשובה לפני שימוש כל הצעה לפני קבלה תוכנית פעולה ותוצאה סופית
דוגמאות claude.ai, ChatGPT Cursor, GitHub Copilot Claude Code

למה הקורס ממוקד בagent CLI

הבחירה הזו לא מקרית. הagent CLI הוא הצורה שחושפת את מלוא העוצמה של פיתוח אג'נטי, משלוש סיבות:

  1. הוא לא כבול לinterface אחד. בעוד עוזר IDE תלוי בעורך ספציפי, וצ'אט תלוי בדפדפן, agent CLI חי בטרמינל - הסביבה המשותפת לכל tool הפיתוח שכבר יש לכם: git, Docker, סקריפטים, tool build. הוא לא "עוד tool" - הוא יודע לתזמר את כל שאר הtools.
  2. הוא הכי טוב ללמידת המיומנויות המרכזיות של הקורס. ניהול context, כתיבת קובץ prompts לפרויקט, בניית זרימות עבודה, אימות תוצאה - כל אלה באים לידי ביטוי המלא ביותר כשהtool פועל בעצמאות אמיתית. ברגע שמבינים אותם דרך agent CLI, קל להעביר אותם לכל tool אחר.
  3. הוא הכיוון שבו כל שאר הtools מתפתחים. גם עוזרי IDE כמו Cursor מוסיפים "מצבי אג'נט" משלהם, שדומים יותר ויותר לagent CLI. להבין לעומק איך agent עצמאי עובד הוא השקעה שמשתלמת גם כשמשתמשים בtools אחרים.

זה לא אומר שצ'אט ועוזרי IDE חסרי ערך - להפך, יש להם מקום ברור בזרימת עבודה בוגרת, ונלמד מתי להשתמש בכל אחד (פרקים 1 ו-5). אבל כדי להבין באמת מה זה "פיתוח אג'נטי", חייבים להתנסות בtool שהאוטונומיה שלו היא מלאה - וזה בדיוק מה שagent CLI נותן.

יש גם שיקול פחות טכני וחשוב לא פחות: מודל התמחור. צ'אט ועוזרי IDE נמכרים לרוב במנוי חודשי קבוע עם מכסת שימוש, ואילו עבודה מול API (כמו זו שנפגוש בפרק 7) מחויבת לפי כמות טוקנים בפועל. הagent CLI כמו Claude Code נופל בדרך כלל תחת אותו מנוי כמו הצ'אט - כך שאין הפתעה כלכלית כשעוברים מהאחד לשני, אבל כדאי לדעת שמשימות ארוכות וagents שרצים הרבה זמן צורכים יותר מאשר שאלה בודדת בצ'אט.

שילוב בין הtools בפועל

בעבודה יומיומית אמיתית, רוב המפתחים לא בוחרים tool אחד ונשארים איתו לתמיד - הם משלבים. דוגמה טיפוסית: פותחים שיחת צ'אט כדי לחקור גישת ארכיטקטורה לפני שמתחייבים לקוד, עוברים לagent CLI כדי לממש את הפיצ'ר על פני כמה קבצים ולהריץ בדיקות, ותוך כדי עריכה נקודתית קטנה בקובץ בודד נעזרים בcompletion עוזר ה-IDE כי היא הכי מהירה לשינוי מקומי. אין כאן "tool אחד לשלוט בכולם" - יש tool מתאים לכל שלב בתהליך.

הקורס בנוי כך שתכירו לעומק את agent ה-CLI קודם (פרקים 2-4), כי הוא מלמד את מרב המיומנויות התשתיתיות, ורק אחר כך (פרק 5) תראו איך לשלב אותו עם הtools האחרים בצורה מודעת, במקום לבחור מתוך הרגל או מקריות.

כלל אצבע פשוט לזיהוי מהיר: אם השאלה מתחילה ב"תסביר לי" או "מה ההבדל בין" - זה כמעט תמיד צ'אט. אם היא מתחילה ב"תשנה את השורה הזו" תוך כדי שאתם כבר מסתכלים על הקובץ - זה עוזר IDE. ואם היא מתחילה ב"תפתור לי את" או "תממש" ומערבת יותר מקובץ אחד - זה agent CLI. הכלל הזה לא מדויק ב-100% מהמקרים, אבל הוא נקודת התחלה טובה עד שתפתחו אינטואיציה משלכם.

סיכום

  • קיימות שלוש צורות עיקריות של AI לתכנות: צ'אט בדפדפן (ללא גישה לקוד), עוזר IDE (גישה לקובץ הפתוח, completions מיידיות), וagent CLI (אוטונומיה מלאה בטרמינל - קריאה, עריכה, הרצת פקודות).
  • ההבדל המרכזי בין השלושה הוא רמת האוטונומיה והגישה לפרויקט - ככל שהיא עולה, הtool יכול לבצע יותר בעצמו, אבל דורש יותר פיקוח.
  • צ'אט מתאים לחקירה ולמידה, עוזר IDE למשימות ממוקדות בזרימת כתיבה, וagent CLI למשימות רב-שלביות ומורכבות שדורשות הרצה ובדיקה בפועל.
  • הקורס ממוקד בagent CLI (Claude Code) כי הוא חושף את מלוא העוצמה של פיתוח אג'נטי, מתזמר את כל שאר tools הפיתוח שלכם, ומלמד את המיומנויות הבסיסיות ביותר בצורה המלאה ביותר.
  • בעבודה אמיתית משלבים בין הtools לפי שלב המשימה - צ'אט לחקירה, agent CLI למימוש רחב, עוזר IDE לעריכה נקודתית מהירה - ולא נשארים עם tool אחד קבוע.
  • צ'אט ועוזרי IDE נשארים tools חשובים בזרימת עבודה בוגרת - נלמד אותם בפרוט בפרקים 1 ו-5, אחרי שנבסס את היסודות דרך הagent.