2
Foundation

הסשן הראשון שלך — בסיס שכולם מפספסים

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

תוכן הפרק
מה יהיה לך בסוף הפרק הזה
דרישות מוקדמות

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

מתחיל 8 דקות פרקטי

התחלת סשן — כל הדרכים

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

מצב אינטראקטיבי — הנפוץ ביותר

הדרך הנפוצה ביותר: פותחים טרמינל, עושים cd לתיקיית הפרויקט, ומריצים claude. זה פותח שיחה מתמשכת — אתם שואלים, Claude Code עונה, אתם ממשיכים לשאול. הסשן נשאר פתוח עד שאתם סוגרים עם /quit או Ctrl+C. מצב אינטראקטיבי הוא הלב של Claude Code — כאן קורה רוב העבודה.

1

הצעד הראשון — תמיד

cd /path/to/your/project

ואז:

claude

למה תיקיית העבודה חשובה כל כך? כי Claude Code רואה את הקבצים יחסית למיקום שבו הפעלתם אותו. אם הפעלתם אותו מ-Home directory, הוא "רואה" את כל מערכת הקבצים שלכם אבל לא יודע מה הפרויקט שלכם. אם הפעלתם מתיקיית הפרויקט, הוא מזהה את הקבצים, קורא CLAUDE.md אם יש, ויודע בדיוק איפה הוא. תיקיית העבודה הנכונה היא ההבדל בין Claude Code שמבין את הפרויקט לבין Claude Code שתועה.

מצב One-Shot — לפקודות בודדות

לפעמים אתם צריכים ש-Claude Code יעשה דבר אחד ויסיים. בלי שיחה, בלי הקשר מתמשך — פשוט מבצע ויוצא. בשביל זה יש מצב one-shot:

claude "create a .gitignore file for a Node.js project"

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

claude "summarize the main changes in the last 5 commits" | pbcopy

זה מריץ Claude Code, שולף את 5 ה-commits האחרונים, מסכם אותם, ומעתיק את התוצאה ל-clipboard (ב-Mac). שילוב של כלי AI עם כלי Unix — כוח אמיתי.

דוגמה נוספת — one-shot עם מצב print שמוציא תשובה נקייה (בלי עיצוב של הממשק):

claude -p "list all TODO comments in this project as JSON"

מצב -p (print) מחזיר תשובה נקייה שאפשר לעבד בסקריפט. מושלם לאינטגרציה עם כלי CI/CD.

המשך סשן קודם

עבדתם אתמול על משהו ורוצים להמשיך? לא צריך להתחיל מאפס. שני פלאגים חשובים:

טיפ: מתי להמשיך ומתי להתחיל מחדש

המשיכו (resume) כשאתם באמצע משימה ורוצים להמשיך את אותה עבודה. התחילו מחדש כשעוברים למשימה חדשה, כשההקשר הישן כבר לא רלוונטי, או כשהסשן הקודם היה ארוך ו-Claude Code התחיל "לשכוח" דברים. כלל אצבע: אם עברו יותר מ-24 שעות, התחילו סשן חדש.

הפעלה עם מודל ספציפי

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

אפשר גם לשלב: claude -m opus --resume — ממשיך סשן קודם אבל עם מודל חזק יותר. שימושי כשהתחלתם עם Sonnet, הגעתם לחלק מורכב, ורוצים להמשיך עם Opus.

עשה עכשיו 3 דקות

נסה את שלושת המצבים:

  1. צור תיקייה חדשה: mkdir ~/claude-test && cd ~/claude-test
  2. הפעל מצב אינטראקטיבי: claude
  3. הקלד: "create a file called hello.txt with the text 'Hello from Claude Code'"
  4. צא: /quit
  5. נסה one-shot: claude "read hello.txt and tell me what it says"

עכשיו אתה מכיר שני מצבים. את resume נלמד בהמשך הפרק.

מתחיל 12 דקות פרקטי

מערכת ההרשאות — הגנה, לא מכשול

אחד הדברים הראשונים שמשתמשים חדשים שמים לב אליהם הוא ש-Claude Code שואל הרשאה לפני שהוא עושה דברים מסוימים. "Can I edit this file?" "Can I run this command?" — זה יכול להרגיש מעצבן בהתחלה, כמו popup-ים שמפריעים לזרימה. אבל מערכת ההרשאות היא אחד הדברים החשובים ביותר בכלי, והיא שם מסיבה מצוינת.

למה הרשאות קיימות

תזכרו מה למדנו בפרק 1: Claude Code הוא agentic — הוא יכול לפעול בעולם האמיתי. הוא יכול למחוק קבצים, לשנות קוד, להריץ פקודות שרירותיות, לעשות rm -rf / (למחוק הכל), להתחבר לשרתים חיצוניים, לשלוח HTTP requests, ולהריץ סקריפטים שאתם אפילו לא יכולים לצפות מראש. בלי מערכת הרשאות, טעות אחת של ה-AI — או פרומפט לא מדויק מספיק שלכם — יכולה לגרום נזק אמיתי.

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

סיפור אזהרה אמיתי

משתמש חדש ביקש מ-Claude Code "clean up the project — remove all unnecessary files." Claude Code פירש את זה בהיקף רחב מדי — הוא רצה למחוק לא רק קבצי temp אלא גם build artifacts, lock files, ואפילו קבצי הגדרות שנראו לו "מיותרים". בזכות מערכת ההרשאות, המשתמש ראה רשימה מדויקת של מה Claude Code מתכנן למחוק לפני שזה קרה, אמר "no" לרוב הפריטים, ורק אישר את מה שבאמת מיותר. בלי ההרשאות? עשרות קבצים חשובים היו נמחקים.

שלוש רמות ההרשאה

כש-Claude Code מבקש הרשאה לפעולה, יש לכם שלוש אפשרויות. כל אחת מתאימה לסיטואציה אחרת:

אפשרות מה זה עושה מתי להשתמש סיכון
Allow once (y) מאשר את הפעולה הזו בלבד, פעם אחת ברירת מחדל. כשרוצים לבדוק כל צעד נמוך — שליטה מלאה
Allow for session מאשר פעולות מסוג זה לכל הסשן כשעובדים על משימה ויודעים שיהיו עוד פעולות דומות בינוני — שליטה ברמת הסשן
Allow always מאשר סוג פעולה זה לצמיתות רק לפעולות בטוחות בוודאות (Read, Grep) גבוה — שליטה מינימלית

מה דורש הרשאה ומה לא

לא כל הכלים שווים מבחינת רמת הסיכון. הנה הסיווג המלא:

הגדרת הרשאות ב-settings.json

במקום לאשר כל פעולה ידנית, אפשר להגדיר הרשאות מראש בקובץ הגדרות. יש שני מיקומים:

דוגמה: settings.json מומלץ

{
  "permissions": {
    "allow": [
      "Read",
      "Grep",
      "Glob",
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(npm run build)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)",
      "Bash(ls *)",
      "Bash(cat *)",
      "Bash(wc *)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(sudo *)",
      "Bash(git push --force *)",
      "Bash(git reset --hard *)",
      "Bash(chmod 777 *)",
      "Bash(curl * | bash)"
    ]
  }
}

allow — פעולות שרצות אוטומטית, בלי לשאול. deny — פעולות חסומות לחלוטין, אפילו אם תבקשו. כל השאר — Claude Code ישאל הרשאה ידנית.

Framework: הרשאות כהגנה

הנוסחה הפשוטה לניהול הרשאות:

  1. Allow כל מה שקריאה בלבד — Read, Grep, Glob, git status, git log, ls, cat
  2. Deny כל מה שמסוכן-ללא-חזרה — rm -rf, sudo, force push, hard reset
  3. Ask על כל השאר — Edit, Write, npm install, git commit, docker commands

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

טיפים פרקטיים

עשה עכשיו 5 דקות

בתיקיית הניסיון שיצרנו קודם, הפעל את Claude Code ובקש ממנו שלוש פעולות:

  1. "Read the file hello.txt" — שים לב: נדרשת הרשאה?
  2. "Create a new file called world.txt with 'Hello World'" — שים לב לבקשת ההרשאה
  3. "Run the command: ls -la" — שים לב לבקשת ההרשאה

שים לב לדפוס: Read מאושר אוטומטית, Write ו-Bash דורשים אישור. זו בדיוק הלוגיקה.

מתחיל 15 דקות פרקטי

ששת הכלים המרכזיים

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

1. Read — קריאת קבצים

R

Read

מה עושה: קורא קובץ מהדיסק ומציג את התוכן שלו עם מספרי שורות. זה הכלי ש-Claude Code משתמש בו כדי "לראות" את הקבצים שלכם.

מתי משתמשים: כשרוצים ש-Claude Code יבין קובץ — לנתח קוד, לקרוא הגדרות, לבדוק מצב נוכחי.

מה הוא יכול לקרוא:

דוגמאות פרומפטים:

הרשאה: בדרך כלל אוטומטי — קריאה לא משנה כלום.

2. Edit — עריכת קבצים

E

Edit

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

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

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

דוגמאות פרומפטים:

הרשאה: דורש אישור — שינוי קבצים הוא פעולה שצריך לבדוק.

Edit vs Write — הבדל קריטי שחייבים להבין

Edit משנה חלק מקובץ קיים — כירורגי, בטוח, משאיר את השאר ללא שינוי. Write יוצר קובץ חדש או דורס קובץ שלם — מחליף הכל. תמיד העדיפו Edit על Write לקבצים קיימים. אם יש לכם קובץ של 500 שורות ואתם צריכים לשנות שורה אחת — Edit משנה רק את השורה ההיא. Write יכתוב מחדש את כל 500 השורות, ועלול לאבד דברים שלא התכוונתם לשנות.

3. Write — יצירת קבצים

W

Write

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

מתי משתמשים: כשצריך ליצור משהו שלא קיים — קומפוננטה חדשה, סקריפט, קובץ הגדרות, דף HTML, קובץ CSS, README. לא לשינויים קטנים בקבצים קיימים — לזה יש Edit.

דוגמאות פרומפטים:

הרשאה: דורש אישור.

4. Bash — הרצת פקודות

B

Bash

מה עושה: מריץ כל פקודת shell שאפשר להריץ בטרמינל. Git, npm, Python, Docker, curl, wget, grep (כפקודת מערכת), כל דבר.

מתי משתמשים: להריץ טסטים, לעשות commit, להתקין חבילות, להפעיל סקריפטים, לבדוק סטטוס שרתים, לנהל Docker containers, לבנות פרויקטים.

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

דוגמאות פרומפטים:

הרשאה: דורש אישור כמעט תמיד. מומלץ מאוד להגדיר allowlist.

טיפ: Bash allowlist מומלץ למתחילים

בטוח לאשר תמיד (allow): git status, git diff, git log, ls, cat, wc, npm test, npm run lint, node --version

צריך הרשאה ידנית (ask): git commit, git push, npm install, docker, python

חסום לחלוטין (deny): rm -rf, sudo, git push --force, git reset --hard, chmod 777

5. Grep — חיפוש בתוכן קבצים

G

Grep

מה עושה: מחפש תבנית טקסט (כולל Regular Expressions) בתוך תוכן של קבצים. מוצא איפה מופיע משהו בפרויקט.

מתי משתמשים: כשצריך למצוא איפה פונקציה מוגדרת, איפה משתנה בשימוש, איפה יש TODO, איפה מיובא מודול, איפה מוגדר error message.

הבדל חשוב: Grep מחפש בתוכן של קבצים (מה כתוב בפנים). Glob מחפש בשמות של קבצים (איך הם נקראים).

דוגמאות פרומפטים:

הרשאה: אוטומטי — חיפוש לא משנה כלום.

6. Glob — חיפוש קבצים לפי שם

F

Glob

מה עושה: מוצא קבצים לפי תבנית שם. "תראה לי את כל קבצי ה-CSS", "מצא את קובץ ה-config", "כמה קבצי TypeScript יש בפרויקט".

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

תבניות נפוצות (Glob Patterns):

הרשאה: אוטומטי — חיפוש שמות קבצים הוא בטוח לחלוטין.

Framework: הכלי הנכון למשימה

מטריצת הכלים — שמרו את הטבלה הזו
אני צריך... הכלי דוגמה
לראות תוכן של קובץ Read "Read src/app.js"
לשנות חלק מקובץ קיים Edit "Fix the typo in line 15"
ליצור קובץ חדש Write "Create a new component"
להריץ פקודה Bash "Run npm test"
למצוא טקסט בתוך קבצים Grep "Find all TODO comments"
למצוא קובץ לפי שם Glob "Find all CSS files"
טיפ חשוב: אתם לא צריכים לציין את הכלי

נקודה שרבים לא מבינים: אתם לא צריכים להגיד ל-Claude Code "use the Grep tool" או "use Edit." פשוט תתארו מה אתם רוצים: "find all places where we handle payment errors" — ו-Claude Code יבחר את הכלי הנכון לבד. ההסבר כאן על הכלים הוא כדי שתבינו מה קורה מאחורי הקלעים ותוכלו לזהות אם Claude Code בחר כלי לא אופטימלי. אבל ב-99% מהמקרים, פשוט תתארו את המטרה והוא יטפל.

כלים נוספים — מבט קדימה

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

עשה עכשיו 5 דקות

ב-Claude Code, בצע את 5 הפעולות הבאות ושים לב לכלי שנבחר:

  1. "Show me all files in this directory" — שים לב: Glob? Bash(ls)?
  2. "Read the file hello.txt" — צפה ל-Read
  3. "Add a second line to hello.txt that says 'This is line 2'" — צפה ל-Edit
  4. "Find any file that contains the word Hello" — צפה ל-Grep
  5. "How many lines are in hello.txt?" — צפה ל-Bash(wc) או Read
מתחיל 10 דקות תיאורטי

DO מול EXPLAIN — ההבדל הקריטי

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

שלושת המצבים

מצב מה קורה דוגמת פרומפט משתנים קבצים?
DO Claude Code מבצע — עורך קבצים, מריץ פקודות "Fix the bug in auth.py" כן — קבצים נערכים
EXPLAIN Claude Code מסביר — קורא ומנתח בלבד "Explain the bug in auth.py" לא — רק מידע
PLAN Claude Code מתכנן — מציע גישה, לא מבצע "Plan how to refactor the DB" לא — רק תוכנית

למה זה חשוב כל כך

תארו לעצמכם שאתם חוקרים קוד שלא כתבתם. אתם רוצים להבין מה פונקציה עושה. אם תכתבו "handle the error in processPayment" — Claude Code עלול לשנות את הקוד ולהוסיף error handling. אבל אם תכתבו "explain the error handling in processPayment" — הוא רק יסביר, בלי לגעת בקובץ. מילה אחת שונה בפרומפט, תוצאה שונה לחלוטין.

הטעות הנפוצה ביותר אצל מתחילים

משתמש חדש רוצה להבין למה ה-authentication לא עובד. הוא כותב: "Make the authentication more secure." זה DO — Claude Code ישנה קבצים, יוסיף validations, אולי ישנה את כל מנגנון ה-auth. אם כל מה שרציתם הוא לדעת מה לא מאובטח, כתבו: "Review the authentication code and list potential security issues." זה EXPLAIN — הוא יקרא, ינתח, ויגיד לכם מה הבעיות, בלי לגעת בכלום.

מילות מפתח לכל מצב

מילים שמפעילות DO (עושה שינויים)

Fix / Create / Add / Remove / Delete / Update / Change / Refactor / Implement / Install / Build / Deploy / Commit / Move / Rename

כל מילה שמרמזת על פעולה אקטיבית — Claude Code יעשה אותה.

מילים שמפעילות EXPLAIN (רק מידע)

Explain / What does / Why / How does / Review / Analyze / Describe / List / Compare / Show me / Tell me about

כל מילה שמבקשת מידע, הסבר, או ניתוח — Claude Code ינתח בלי לשנות.

מילים שמפעילות PLAN (מתכנן בלי לבצע)

Plan / Outline / Suggest / Propose / Draft a strategy / What would be the best approach / Design (בהקשר של תכנון)

כל מילה שמבקשת חשיבה קדימה — Claude Code יחשוב ויציע, בלי לבצע.

הכלל הזהב

הכלל שחוסך את רוב הטעויות

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

דוגמה מלאה לתהליך נכון

נניח שקיבלתם דיווח על באג ב-payment processing. ככה נראה תהליך עבודה נכון:

  1. EXPLAIN: "Explain the payment processing flow in this project. Which files are involved and how do they connect?"
  2. EXPLAIN: "The user reports that payments fail silently for amounts over $1000. Review the payment validation logic and tell me what might cause this."
  3. PLAN: "Based on what you found, plan a fix. List the files that need to change and what changes are needed. Don't implement yet."
  4. DO: "Implement step 1 from the plan — fix the amount validation in payment.js."
  5. DO: "Now add a test case for payments over $1000."
  6. DO: "Run the test suite to verify the fix works and nothing else broke."

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

עשה עכשיו 3 דקות

ב-Claude Code, נסה את שלושת המצבים על אותו קובץ:

  1. EXPLAIN: "Explain what's in the file hello.txt"
  2. PLAN: "Plan how to turn this into a proper greeting file with name, date, and a message"
  3. DO: "Implement the plan"

שים לב: בשלבים 1 ו-2 הקובץ לא השתנה. רק בשלב 3 Claude Code ביצע שינויים.

בינוני 10 דקות פרקטי

הטעויות הנפוצות — ואיך להימנע מהן

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

1. פרומפט עמום מדי

1

"תשפר את האפליקציה"

הבעיה: Claude Code לא יודע מה "לשפר" אומר. מהירות? עיצוב? אבטחה? קוד נקי? UX? הוא יבחר כיוון אקראי, ובדרך כלל לא מה שחשבתם.

הפתרון: היו ספציפיים. מה הבעיה, איפה היא, ומה אתם רוצים שיקרה.

לפני: "Make the app better"

אחרי: "The /dashboard page takes 8 seconds to load. Find the performance bottleneck — it's probably in the database queries in dashboard.js. Optimize them."

הנוסחה: What (מה המשימה) + Where (איפה) + Why (למה זה בעיה) + Want (מה רוצים).

2. התעלמות משגיאות

2

"זה לא עובד, תתקן"

הבעיה: Claude Code הראה לכם הודעת שגיאה מפורטת. אם אתם מתעלמים ממנה ופשוט אומרים "fix it", הוא צריך לנחש — ולפעמים מנחש לא נכון.

הפתרון: קראו את השגיאה, ציינו אותה בפרומפט.

לפני: "It's broken, fix it"

אחרי: "I get 'TypeError: Cannot read property id of undefined' at user.js line 23. The user object is null when someone isn't logged in. Add a null check."

3. "Allow Always" לכל דבר

3

אישור גורף של הרשאות

הבעיה: נלחצים מההרשאות ומאשרים "Always" לכל דבר. עכשיו Claude Code יכול למחוק, לדרוס, ולהריץ כל דבר בלי לשאול.

הפתרון: השתמשו ב-settings.json עם allow/deny מוגדרים. ב-2-3 הסשנים הראשונים, אשרו הכל ידנית כדי להבין את הדפוס.

4. חוסר הקשר

4

"תתקן את הבאג" — בלי הקשר

הבעיה: Claude Code לא רואה את מה שקורה ב-IDE שלכם. הוא לא יודע מה שיניתם בשעה האחרונה (אלא אם עשיתם דרכו). הוא לא יודע מה ניסיתם כבר.

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

לפני: "Fix the auth bug"

אחרי: "I changed the login function to use bcrypt instead of md5 (I edited it in VS Code, not through Claude Code). Now tests fail with 'hash mismatch'. The old password hashes in the DB use md5 and don't match the new bcrypt validation."

5. פרומפט ענקי אחד

5

500 מילים בפרומפט אחד

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

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

לפני: "Build a complete e-commerce app with user auth, product catalog, shopping cart, checkout with Stripe, order management, email notifications, admin dashboard, and deploy to Vercel."

אחרי: 8 פרומפטים נפרדים, אחד לכל רכיב, בסדר הגיוני.

6. לא לבדוק את התוצאה

6

"Claude Code אמר שהכל עובד"

הבעיה: Claude Code יכול להגיד "Done!" כשבעצם יש באג. הוא יכול לעשות edit שלא שומר על indentation. הוא יכול ליצור קוד שעובר compilation אבל נכשל ב-runtime.

הפתרון: אחרי כל שינוי משמעותי — בדקו. הריצו git diff, הריצו טסטים, פתחו את הקובץ ובדקו בעיניים. זה לוקח 30 שניות ויכול לחסוך שעה של debug.

7. שכחת תיקיית העבודה

7

הפעלת Claude Code מהמקום הלא נכון

הבעיה: הפעלתם Claude Code מ-Home directory ואמרתם "fix the bug in src/app.js". הוא מחפש ~/src/app.js — לא ~/projects/my-app/src/app.js.

הפתרון: תמיד cd /path/to/project לפני claude. פשוט, אבל זה הדבר הראשון לבדוק כשמשהו "לא עובד".

70%

מהתסכולים של משתמשים חדשים נפתרים על ידי הימנעות מ-7 הטעויות האלה

מתחיל 15 דקות פרקטי

Walkthrough מלא — משימה אמיתית מתחילה ועד סוף

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

תרחיש A: מפתח — מצא באג, תקן אותו, ועשה commit

תרגיל מעשי: תיקון באג

מה נעשה: ניצור פרויקט קטן עם באג מכוון, ונלמד את הזרימה המלאה: EXPLAIN → PLAN → DO → VERIFY → COMMIT.

  1. הקמת הפרויקט:
    mkdir ~/bug-fix-demo && cd ~/bug-fix-demo && git init
  2. הפעלת Claude Code:
    claude
  3. יצירת קובץ עם באג:
    "Create a file called calculator.py with functions for add, subtract, multiply, and divide. Intentionally put a bug in the divide function — make it return a * b instead of a / b."
  4. EXPLAIN — מצא את הבאג:
    "Review calculator.py for bugs. Don't fix anything yet — just explain what you find."
    שימו לב: Claude Code קורא את הקובץ ומסביר, בלי לשנות כלום.
  5. DO — תקן:
    "Fix the bug you found in the divide function."
    עכשיו Claude Code עורך את הקובץ. שימו לב שהוא משתמש ב-Edit, לא ב-Write.
  6. VERIFY — בדוק:
    "Run a quick test: execute python3 -c 'from calculator import divide; print(divide(10, 2))' — it should print 5.0"
  7. COMMIT:
    "Commit all changes with the message 'Fix: divide function was multiplying instead of dividing'"

זמן משוער: 5-8 דקות

מה למדת: את הזרימה EXPLAIN → DO → VERIFY → COMMIT. זו הזרימה שתשתמש בה כל יום.

תרחיש B: משווק — צור תוכן שיווקי מלוטש

תרגיל מעשי: יצירת עותקים למודעות

מה נעשה: ניצור קובץ עם עותקים למודעות Google Ads ו-Meta Ads, נבדוק אותם, ונשפר.

  1. הקמה:
    mkdir ~/ad-copy-demo && cd ~/ad-copy-demo && claude
  2. יצירת עותקים:
    "Create a file called ad-copy.md with ad copy for a Tel Aviv coworking space called 'SpaceHub'. Include: 5 Google Ads headlines (max 30 chars each, Hebrew), 5 Google Ads descriptions (max 90 chars, Hebrew), and 3 Meta Ads primary text options (Hebrew, longer form). Target audience: freelancers and startup founders aged 25-40."
  3. EXPLAIN — בדיקת אורך:
    "Read ad-copy.md and verify all Google Ads headlines are actually under 30 characters. List any that are too long."
  4. DO — תיקון ושיפור:
    "Fix any headlines that are over 30 characters. Also, add urgency to all headlines — mention a 20% launch discount."
  5. DO — גרסה שנייה:
    "Create a second version as ad-copy-v2.md with completely different angle — focus on community and networking instead of space and pricing."

זמן משוער: 8-10 דקות

מה למדת: Write + Edit + Read בשילוב, iteration על תוכן, ויצירת גרסאות.

תרחיש C: אנליסט — נתח נתונים וצור דוח

תרגיל מעשי: ניתוח נתונים ודוח HTML

מה נעשה: Claude Code יצור נתוני דוגמה, ינתח אותם, ויפיק דוח HTML מעוצב.

  1. הקמה:
    mkdir ~/data-demo && cd ~/data-demo && claude
  2. יצירת נתונים:
    "Create a CSV file called sales.csv with 50 rows of realistic Israeli sales data. Columns: date (random dates in last 3 months), product_name (5 products: laptop, headphones, keyboard, monitor, webcam), quantity (1-15), unit_price (100-5000 ILS), region (North/South/Center/Jerusalem/Tel Aviv)."
  3. EXPLAIN — ניתוח ראשוני:
    "Analyze sales.csv and give me: total revenue, best-selling product by revenue, best region, average order value, and any interesting patterns."
  4. DO — דוח מעוצב:
    "Create a beautiful HTML report called report.html with the analysis. Include summary table, top product highlight, regional breakdown. Hebrew text, dark theme, RTL, responsive, inline CSS. Make it look professional — like a real dashboard."

זמן משוער: 10-12 דקות

מה למדת: שילוב של Write (יצירת נתונים), Bash (ניתוח), Read (קריאה), Write (דוח).

עשה עכשיו 15 דקות

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

מתחיל 10 דקות פרקטי

ניהול סשנים — clear, compact, resume

ככל שתעבדו יותר עם Claude Code, תגלו שניהול הסשן חשוב לא פחות מהפרומפטים עצמם. סשן שמנוהל נכון חוסך tokens (= כסף), שומר על איכות התגובות, ומאפשר עבודה ארוכה בלי ירידה בביצועים.

הבנת חלון ההקשר (Context Window)

Claude Code עובד עם חלון הקשר של כ-200K tokens. כמה זה בפועל? בערך 150,000 מילות אנגלית, או כ-500 עמודי טקסט. זה נשמע הרבה — וזה — אבל בסשן פעיל הוא מתמלא מהר יותר ממה שחושבים. כל פרומפט, כל תגובה, כל קובץ שנקרא, כל פלט של פקודה — הכל נכנס לחלון ההקשר. כשהחלון מתמלא, Claude Code מתחיל "לשכוח" דברים מתחילת השיחה — הוא לא מאבד אותם ממש, אבל הם מתחילים להשפיע פחות על התגובות שלו.

איך חלון ההקשר מתמלא — דוגמה

בחשבון מהיר: אחרי 10 סבבי שיחה עם כמה קריאות קבצים, אתם כבר ב-50-80K tokens. אחרי 30 דקות של עבודה אינטנסיבית, יכולים להגיע ל-120K+. ברגע שמגיעים לאזור ה-150K+, התגובות מתחילות לאבד איכות.

הפקודות לניהול סשן

/clear — מחיקת ההיסטוריה

/clear מוחק את כל היסטוריית השיחה. אחריו, Claude Code "מתחיל מחדש" — שוכח הכל חוץ מ-CLAUDE.md. זה כמו לפתוח שיחה חדשה, אבל בלי לסגור את הטרמינל.

מתי להשתמש:

/compact — דחיסת הקשר

זו אחת הפקודות החשובות ביותר ב-Claude Code. /compact לוקח את כל השיחה עד כה ומסכם אותה לגרסה מקוצרת. במקום 80K tokens של שיחה מלאה, אתם מקבלים 5-10K tokens של סיכום — שכולל את כל המידע החשוב, בלי הפירוט המלא. זה משחרר עשרות אלפי tokens בחלון ההקשר, בלי לאבד את הידע שנצבר.

מתי להשתמש:

טיפ: compact עם הנחיה

אפשר להוסיף הנחיה ל-compact: /compact focus on the auth module changes — ככה הסיכום ידגיש את מה שחשוב לכם לשלב הבא.

--resume ו---continue — חזרה לסשנים קודמים

כשסוגרים את Claude Code (עם /quit או Ctrl+C) ורוצים לחזור מאוחר יותר:

Framework: מחזור חיי הסשן

The Session Lifecycle — שמרו את הדפוס הזה
  1. Start — cd /project && claude (תמיד מתיקיית הפרויקט)
  2. Work — שיחה, כלים, שינויים (20-30 דקות)
  3. Compact — /compact (משחרר מקום בהקשר)
  4. Work more — ממשיכים עם הקשר דחוס (עוד 20-30 דקות)
  5. Compact again — אם צריך
  6. End — /quit
  7. Resume later — claude --resume (למחרת, או אחרי הפסקה)

טיפים מתקדמים

עשה עכשיו 5 דקות

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

  1. הקלידו /cost — ראו כמה הסשן עלה
  2. הקלידו /compact — שימו לב לסיכום שנוצר
  3. שאלו: "What have we done so far?" — Claude Code זוכר למרות הדחיסה
  4. הקלידו /quit
  5. הריצו claude --resume — ראו שהסשן חוזר
  6. שאלו: "What were we working on?" — בדקו שהוא זוכר
מתחיל 8 דקות פרקטי

עבודה בעברית — תרחיש מלא

בואו נעשה תרחיש שלם בעברית כדי לראות איך Claude Code מטפל ב-RTL, בתוכן עברי, ובשילוב עברית-אנגלית. נבנה דף נחיתה פשוט עם תוכן מלא בעברית, ונלמד את הדפוסים הנכונים.

תרגיל: דף נחיתה מלא בעברית

שלב 1 — הקמה:

mkdir ~/hebrew-demo && cd ~/hebrew-demo && claude

שלב 2 — בקשת הדף (שילוב עברית + אנגלית):

> Create an HTML file called index.html for a digital marketing
> course called "קורס שיווק דיגיטלי מתקדם".
> All visible text in Hebrew, RTL layout, use dir="rtl" on html.
> Include these sections:
> 1. Hero: title, subtitle, CTA button "הרשמה עכשיו"
> 2. Features: 3 course highlights with emoji icons
> 3. Pricing: 3 plans (basic/pro/premium) in ILS
> 4. Testimonials: 3 Hebrew reviews with names
> 5. Signup form: name, email, phone, submit button
> Dark theme, modern design, fully responsive, all CSS inline.
> Use the Heebo font from Google Fonts.

שלב 3 — בדיקה:

פתחו את index.html בדפדפן (ב-Mac: open index.html, ב-Linux: xdg-open index.html).

בדקו:

שלב 4 — שיפורים באמצעות Edit:

> Improve the page:
> 1. Add a countdown timer showing "נותרו 7 ימים להנחה"
> 2. Add a floating WhatsApp button (bottom-left)
> 3. Add smooth scroll to sections
> 4. Make the pricing cards have a hover effect

שלב 5 — בדיקה סופית ו-commit:

רענו את הדפדפן, בדקו שהכל עובד, ואז: "Commit with message: 'Add Hebrew landing page for digital marketing course'"

טיפ: הדפוס המומלץ לעבודה דו-לשונית

הדפוס שעובד הכי טוב:

Claude Code מבין את שניהם ומתרגם בצורה חלקה בין השפות.

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

לפני שממשיכים לפרק 3, ודאו שביצעתם את כל הפריטים ברשימה:

מה בנית בפרק הזה
הצעד הבא: פרק 3

בפרק הבא נלמד על CLAUDE.md — המוח של הפרויקט שלך. זה הקובץ שהופך את Claude Code מכלי AI גנרי לשותף עבודה שמכיר את הפרויקט, הקונבנציות, ה-tech stack, וההעדפות שלך. נבנה CLAUDE.md מושלם מאפס, עם template מוכן ודוגמאות אמיתיות.