לדלג לתוכן

2.1 מה זה פיתוח אג'נטי הרצאה

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

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

לולאת הagent - the agentic loop

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

1. Gather context   - read files, search the code, understand what's going on
2. Plan              - decide the next step toward the goal
3. Act                - use a tool: edit a file, run a command, search
4. Observe            - read the output: did it succeed? fail? what did we learn?
5. Repeat the loop until the goal is achieved

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

בואו נראה דוגמה קונקרטית. נניח שביקשתם: "תקן את הבדיקות שנכשלות". הagent טוב יעשה בערך כך:

> fix the failing tests

1. Runs the test suite          -> sees that 3 tests fail
2. Reads the error message       -> "TypeError in auth.py line 42"
3. Searches for the file auth.py -> finds it
4. Reads auth.py                 -> understands the function returns None instead of dict
5. Edits auth.py                 -> fixes the bug
6. Reruns the tests              -> all pass. Done.

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

הtools של הagent - tools

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

קטגוריה מה הagent יכול לעשות
פעולות קבצים - file operations לקרוא קבצים, לערוך קוד, ליצור קבצים חדשים, לשנות שם ולארגן
חיפוש - search למצוא קבצים לפי תבנית, לחפש תוכן עם ביטוי רגולרי, לסרוק בסיס קוד
הרצה - execution להריץ פקודות מעטפת, להפעיל שרתים, להריץ בדיקות, להשתמש ב-git
רשת - web לחפש באינטרנט, למשוך תיעוד, לחפש הודעות שגיאה
בינת קוד - code intelligence לראות שגיאות טיפוס ואזהרות אחרי עריכה, לקפוץ להגדרות, למצוא הפניות

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

Read    - reads the contents of a file
Edit    - makes a precise change inside an existing file
Write   - writes a new file (or overwrites an existing one)
Grep    - searches content by regular expression across the code
Glob    - finds files by name pattern (e.g. *.py)
Bash    - runs a real shell command on your machine

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

מעבר לtools המובנים אפשר להרחיב את היכולות: הskills, שרתי MCP לחיבור לשירותים חיצוניים, hooks לאוטומציה, וsub-agents למשימות מקבילות. את אלה נלמד בפרקים מאוחרים יותר. בשלב הזה מספיק להבין שהבסיס הוא חמש הקטגוריות שלמעלה.

במה זה שונה מהשלמה אוטומטית - autocomplete

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

הנה ההשוואה המלאה:

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

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

במה זה שונה מצ'אט - chat

השאלה המתבקשת: הרי אפשר לפתוח צ'אט עם מודל שפה, להדביק קוד, ולקבל תשובה. במה זה שונה מagent? ההבדל הוא בשלושה דברים.

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

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

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

אפשר לחשוב על זה כך: צ'אט הוא מודל שפה עירום. הagent הוא אותו מודל שפה, עטוף במה שהתיעוד מכנה "מעטפת אג'נטית" - agentic harness - שמספקת לו tools, ניהול context, וסביבת הרצה. Claude Code הוא המעטפת הזו סביב מודל Claude.

למה הלולאה חזקה - ואיפה היא נשברת

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

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

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

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

דוגמה קונקרטית לכשל - a concrete failure

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

> delete the temp files

  Bash  rm -rf ./*   <- wrong and dangerous interpretation!
  Do you want to run this command? > 3. No

כאן בדיוק נכנס מנגנון ההרשאות. הagent לא הריץ את הפקודה - הוא ביקש אישור, ואתם, שראיתם rm -rf ./*, דחיתם והבהרתם: "רק קבצי .tmp, לא הכל". הדחייה תפסה את הטעות לפני שהיא קרתה. זו התמונה המלאה של למה הלולאה חזקה אבל דורשת פיקוח: הagent פועל מהר ורחב, ומנגנוני הבטיחות הם מה שהופך את המהירות הזו לבטוחה.

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

הלך הרוח הנכון - delegate, don't dictate

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

The payment process is broken for users with an expired card.
The relevant code is in src/payments/. Investigate and fix it.

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

סיכום

  • הagent מקבל מטרה, מפרק אותה לצעדים, מפעיל tools אמיתיים, בודק את התוצאה, ומתקן את עצמו - להבדיל ממודל שפה שרק מייצר טקסט.
  • לולאת הagent היא איסוף context, פעולה עם tools, תצפית על התוצאה, וחזרה עד להשגת המטרה. כל צעד נובע מהתצפית של הצעד הקודם.
  • הagent מפעיל tools בחמש קטגוריות: פעולות קבצים (Read, Edit, Write), חיפוש (Grep, Glob), הרצה (Bash), רשת, ובינת קוד. הוא בוחר בעצמו במה להשתמש.
  • השלמה אוטומטית מציעה טקסט ברמת השורה בלי להריץ כלום; הagent פועל על כל הפרויקט ובודק את עצמו.
  • צ'אט עונה פעם אחת ועוצר; הagent ניגש ישירות לקבצים, פועל במקום להמליץ, וסוגר את מעגל המשוב.
  • הלולאה חזקה בזכות המשוב - ככל שיש יותר מול מה לאמת, כך התוצאה טובה יותר.
  • הלולאה נשברת כשהמטרה מעורפלת, כשאין מול מה לאמת, כשהcontext מתמלא, או בהרעלת קלט. בגלל זה קיימים מנגנוני הרשאות ונקודות שחזור.
  • הגישה הנכונה: להאציל כמו לעמית מוכשר - לתת context וכיוון, לא להכתיב כל צעד.