2.2 הריצה הראשונה הרצאה

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

נניח שהתקנתם כבר את Claude Code והתחברתם לחשבון (זה קורה בהרצה הראשונה, כשהtool פותח לכם דפדפן להתחברות). אם לא, אפשר להתקין בפקודה אחת ולהריץ claude בפעם הראשונה כדי להתחבר. מכאן והלאה נניח שהכל מוכן.

פתיחת סשן - starting claude¶

הצעד הראשון תמיד זהה: נכנסים לתיקיית הפרויקט ומריצים את הפקודה claude.

cd ~/projects/my-app
claude

ברגע שהagent עולה, תראו שורת הזנה שמעליה מופיעים מספר הגרסה, המודל הנוכחי (למשל Sonnet 5 או Opus 4.8), ותיקיית העבודה. עצם ההרצה בתוך התיקייה נותנת ל-Claude גישה לכל מה שהוא צריך: הקבצים בתיקייה ובתת-התיקיות, מצב ה-git (הענף הנוכחי, שינויים לא מקומטים, היסטוריית קומיטים אחרונה), וקובץ ה-CLAUDE.md אם קיים. אתם לא מוסיפים context ידנית - הagent קורא מה שהוא צריך תוך כדי עבודה.

כמה פקודות הפעלה שימושיות מהטרמינל:

פקודה	מה היא עושה
`claude`	פותח סשן אינטראקטיבי
`claude "task"`	מריץ משימה חד-פעמית
`claude -p "query"`	מריץ שאילתה בודדת ויוצא (מצב הדפסה)
`claude -c`	ממשיך את השיחה האחרונה בתיקייה
`claude -r`	מאפשר לבחור שיחה קודמת לחידוש

בתוך הסשן, אפשר תמיד להקליד /help כדי לראות את הפקודות הזמינות, ולהקליד / כדי לראות את כל הפקודות והskills. שתי פקודות בסיסיות שכדאי לזכור מיד: /clear שמנקה את היסטוריית השיחה ומתחיל מחדש, ו-/exit (או Ctrl+D) שיוצא מהסשן.

מודל השיחה - the conversation model¶

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

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

בזמן שהagent עובד, אתם עדיין חלק מהלולאה. שתי דרכים לכוון אותו תוך כדי:

לחיצה על Esc עוצרת את Claude מיד. הtool שרץ מבוטל, והagent ממתין לprompt הבאה שלכם. העבודה שכבר נעשתה נשמרת.
הקלדת תיקון ולחיצה על Enter שולחת הודעה בלי לעצור את הtool הרץ. Claude יקרא אותה ברגע שהפעולה הנוכחית תסתיים, ויתאים את עצמו לפני הצעד הבא.

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

לבקש לקרוא ולהסביר קוד - explain¶

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

> what does this project do?

Claude יסרוק את הקבצים ויחזיר תקציר. אפשר לחדד:

> what technologies does the project use?
> where is the main entry point?
> explain the directory structure

מאחורי הקלעים, בכל שאלה כזאת הagent מריץ את הלולאה: הוא משתמש ב-Glob וב-Grep כדי למצוא קבצים רלוונטיים, ב-Read כדי לקרוא אותם, ואז מסכם. אתם רואים את הtools רצים על המסך בזמן אמת. הנה איך זה עשוי להיראות עבור שאלה על נקודת הכניסה:

> where is the main entry point and what happens there?

  Glob    **/main.py, **/app.py, **/index.js
  Read    src/app.py
  Read    src/config.py

The entry point is src/app.py. It loads the settings from config.py,
initializes the Flask server, and registers three routes under /api. The server
listens on port 5000 by default.

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

לבקש עריכה - asking for an edit¶

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

> add a function called validate_email to the file src/utils.py.
  It takes a string and returns True if it's a valid email address.
  Test cases: 'user@example.com' -> True, 'invalid' -> False.
  Run the tests afterward.

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

לאשר או לדחות שינוי - accepting and rejecting diffs¶

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

  Edit src/utils.py

  + def validate_email(value: str) -> bool:
  +     import re
  +     pattern = r"^[^@\s]+@[^@\s]+\.[^@\s]+$"
  +     return re.match(pattern, value) is not None

  Do you want to make this edit to utils.py?
  > 1. Yes
    2. Yes, and allow edits during this session
    3. No, tell Claude what to do differently (Esc)

יש כאן שלוש אפשרויות, וכדאי להבין את ההבדל ביניהן:

Yes - מאשר את השינוי הבודד הזה בלבד. בפעם הבאה שהagent ירצה לערוך, הוא ישאל שוב.
Yes, and allow edits during this session - מאשר, ומעביר את הסשן למצב שבו עריכות קבצים לא ידרשו אישור נוסף (מצב שנלמד לעומק בהרצאה 2.3).
No - דוחה את השינוי. חשוב: כשדוחים, מסבירים ל-Claude מה לעשות אחרת. הדחייה היא לא סוף הדרך אלא כיוון מחדש: "לא, אל תשתמש בביטוי רגולרי, תשתמש בספריית email-validator".

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

עבודה עם git - git integration¶

אחת התכונות הנוחות היא ש-Claude Code הופך פעולות git לשיחתיות. הוא רואה את מצב ה-git שלכם ויכול לפעול עליו:

> which files did I change?
> commit the changes with a descriptive message
> open a new branch called feature/email-validation

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

להיות ספציפי ולתת מול מה לאמת - be specific¶

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

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

Vague version:
> fix the bug

Specific version:
> The payment process is broken for users with an expired card.
  Check src/payments/, especially the token refresh.
  Write a failing test first, then fix it.

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

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

מחזור החיים של סשן - session lifecycle¶

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

1. cd into the project directory, then claude   -> the session starts
2. Understanding questions                       -> "what does this do?", "where is X?"
3. A well-defined change request                  -> "add function Y"
4. Reviewing the diff and approving/rejecting      -> Yes or No with an explanation
5. Verification                                    -> "run the tests"
6. commit                                          -> "commit with a message"
7. /exit or Ctrl+D                                 -> exit

נקודה חשובה על סשנים: כל סשן מתחיל עם context window נקי. אם תצאו ותפתחו סשן חדש, Claude לא זוכר את השיחה הקודמת. יש לזה שני פתרונות. הראשון הוא לחדש שיחה קיימת עם claude -c (המשך אחרון) או claude -r (בחירת שיחה). השני, החשוב יותר לטווח ארוך, הוא לכתוב prompts קבועים בקובץ CLAUDE.md כדי שהם ייטענו בכל סשן מחדש. את זה נלמד בהרצאה 2.5.

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

דוגמה מלאה מקצה לקצה - a full session¶

נחבר הכל לסשן אחד רציף על repo קטן של סקריפט פייתון:

$ cd ~/projects/todo-cli
$ claude

> what does this project do?
  A command-line tool for managing a to-do list, stored in a JSON file.
  The entry point is todo.py.

> there's a bug: running 'add' without text crashes the program. Fix it.
  Read  todo.py
  Found it: the function cmd_add accesses args[1] without checking it exists.

  Edit todo.py
  + if len(args) < 2:
  +     print("Error: missing task text")
  +     return
  Do you want to make this edit? > 1. Yes

> run it without an argument to verify
  Bash  python todo.py add
  Error: missing task text   (the program did not crash. Fixed.)

> commit with an appropriate message
  git commit -m "Fix crash when adding an empty task"  > 1. Yes

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

סיכום¶

מתחילים סשן ב-cd לתיקיית הפרויקט ואז claude. הagent מקבל אוטומטית גישה לקבצים, ל-git ול-CLAUDE.md.
העבודה שיחתית: מתארים מטרה בשפה טבעית, ומכוונים אם צריך. Esc עוצר את הagent; הקלדת תיקון מכוונת אותו בלי לעצור.
שואלים את הagent להבין את הקוד ("מה זה עושה?", "איפה נקודת הכניסה?"), והוא מפעיל Glob, Grep ו-Read בעצמו.
לבקשת עריכה ספציפית עם מקרי בדיקה מקבלים תוצאה טובה יותר, כי יש לagent מול מה לאמת.
Claude תמיד מציג diff ומבקש אישור לפני עריכה. אפשר לאשר (Yes), לאשר לכל הסשן, או לדחות (No) ולהסביר מה לעשות אחרת.
פעולות git הופכות שיחתיות, ועוברות דרך אותו מנגנון אישור.
כל סשן מתחיל עם context נקי; מחדשים עם claude -c/-r, ומשמרים prompts קבועים ב-CLAUDE.md.
כל עריכת קובץ ניתנת לביטול דרך נקודות שחזור (Esc פעמיים), כרשת ביטחון נפרדת מ-git.