פרק 2: הסשן הראשון שלך — Your First Session

מה יהיה לך בסוף הפרק הזה

שליטה בכל 5 הדרכים להפעיל Claude Code — ותדע מתי להשתמש בכל אחת
הבנה מלאה של מערכת ההרשאות — כולל קובץ settings.json מוגדר ומוכן
הכרות מעמיקה עם כל 9 הכלים: Read, Edit, Write, Bash, Grep, Glob, Agent, WebSearch, WebFetch
היכולת להבחין בין DO, EXPLAIN ו-PLAN — ולדעת מתי להשתמש בכל מצב
שליטה ב-7 קיצורי מקלדת שיהפכו אתכם למהירים משמעותית
זיהוי של 7 טעויות נפוצות שתדעו להימנע מהן מהיום הראשון
לפחות משימה אמיתית אחת שהשלמתם מתחילה ועד סוף
שליטה בניהול סשנים: /compact, /clear, --resume, --continue

מה תוכלו לעשות בסוף הפרק הזה

תוכלו לבחור את דרך ההפעלה הנכונה מבין 5 אפשרויות — לפי סוג המשימה
תוכלו להגדיר settings.json עם allow/deny שמאזנים בין זרימת עבודה לאבטחה
תוכלו להבחין בין DO, EXPLAIN ו-PLAN ולבחור את המצב הנכון לכל סיטואציה
תוכלו לנהל סשן עבודה מלא — כולל compact, clear, ו-resume — בלי לאבד הקשר
תוכלו לזהות ולהימנע מ-7 הטעויות הנפוצות ביותר אצל מתחילים

דרישות קדם

פרקים קודמים: פרק 1 — מבוא: מה זה Claude Code (חובה — Claude Code צריך להיות מותקן ועובד)
חשבונות וכלים: Claude Code מותקן ומאומת, טרמינל פתוח, חיבור לאינטרנט
זמן משוער לפרק: כ-90 דקות (קריאה + תרגילים + 3 משימות מעשיות)

הפרויקט שלך

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

בפרק הזה תעברו מ"להכיר את הכלי" ל"לעבוד עם הכלי": תלמדו את כל דרכי ההפעלה, מערכת ההרשאות, 9 הכלים, ההבדל בין DO/EXPLAIN/PLAN, ניהול סשנים, וקיצורי מקלדת — ותשלימו 3 משימות מעשיות.

בפרק 3 תבנו קובץ CLAUDE.md — הקובץ שהופך את Claude Code משותף גנרי לשותף שמכיר את הפרויקט שלכם.

מילון מונחים — פרק 2

מונח באנגלית	מה זה אומר
Session (סשן)	שיחה מתמשכת עם Claude Code. מתחילה כשמפעילים, נגמרת כשיוצאים
Interactive Mode	מצב שיחה — שואלים, עונה, ממשיכים. המצב הנפוץ ביותר
One-Shot Mode	מצב פקודה בודדת — מריצים, מקבלים תשובה, יוצאים
Permission (הרשאה)	אישור שנותנים ל-Claude Code לפני שהוא עושה פעולה מסוימת
Tool (כלי)	יכולת ספציפית של Claude Code — קריאת קובץ, עריכה, הרצת פקודה
Context Window	חלון ההקשר — כמות המידע ש-Claude Code יכול "לזכור" בסשן
Compact (דחיסה)	קיצור ההיסטוריה כדי לפנות מקום בחלון ההקשר
Allowlist / Denylist	רשימות של פעולות מאושרות מראש / חסומות מראש בהרשאות
Plan Mode	מצב תכנון — Claude Code מציע גישה בלי לבצע שינויים
Checkpoint	נקודת שמירה אוטומטית שמאפשרת לחזור אחורה

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

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

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

1. מצב אינטראקטיבי — Interactive Mode

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

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

cd /path/to/your/project

ואז:

claude

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

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

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

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

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

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

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

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

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

3. בחירת מודל ספציפי — Model Selection

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

claude -m opus — מתחיל סשן עם Opus 4.6 (הכי חכם, הכי יקר, 1M context)
claude -m sonnet — Sonnet (נקודת איזון טובה בין מהירות ואיכות)
claude -m haiku — Haiku (הכי מהיר, הכי זול — למשימות פשוטות)

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

4. המשכת סשן קודם — Resume

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

claude --resume — ממשיך את הסשן האחרון. Claude Code טוען את כל ההיסטוריה ויודע בדיוק מאיפה הפסקתם
claude --continue — מציג רשימת סשנים אחרונים ומאפשר לבחור

מתי להמשיך ומתי להתחיל מחדש

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

5. סשן עם שם — Session Naming

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

claude -n "auth-refactor"

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

מה קורה מאחורי הקלעים כשמפעילים סשן

כשמקלידים claude ולוחצים Enter, קורים כמה דברים בו-זמנית שכדאי להכיר:

טעינת הגדרות: Claude Code קורא את .claude/settings.json (פרויקט) ו-~/.claude/settings.json (גלובלי) — כדי לדעת מה מותר ומה אסור
טעינת CLAUDE.md: קורא את CLAUDE.md מתיקיית הפרויקט ו-~/.claude/CLAUDE.md (גלובלי) — כדי "להכיר" את הפרויקט ואת ההעדפות שלכם. נלמד על זה לעומק בפרק 3
טעינת Rules: קורא קבצים מתיקיית .claude/rules/ — הוראות ממוקדות לנושאים ספציפיים
טעינת Skills: סורק את .claude/commands/ ו-~/.claude/commands/ — פקודות /slash שיצרתם
טעינת Plugins: מפעיל plugins שמוגדרים בהגדרות
חיבור MCP: מתחבר ל-MCP servers שמוגדרים — כלים חיצוניים כמו GitHub, Slack, דאטאבייסים

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

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

נסה שלוש דרכי הפעלה:

צור תיקיית ניסיון: mkdir ~/claude-test && cd ~/claude-test
הפעל מצב אינטראקטיבי: claude
בקש: "Create a file called hello.txt with the text 'Hello from Claude Code'"
צא: /quit
נסה one-shot: claude "read hello.txt and tell me what it says"
נסה resume: claude --resume — האם הוא זוכר מה עשיתם?

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

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

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

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

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

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

טעות נפוצה: פרומפט "נקה את הפרויקט" בלי גבולות

מה הטעות: משתמש חדש ביקש "clean up the project — remove all unnecessary files." Claude Code פירש את זה רחב מדי — רצה למחוק build artifacts, lock files, ואפילו הגדרות.

למה זה מפתה: כי רוצים "לנקות" ו-Claude Code נשמע כמו שידע מה לעשות.

מה לעשות במקום: תמיד ציינו בדיוק מה למחוק: "Remove only .tmp files and __pycache__ directories." בזכות מערכת ההרשאות, הוא ראה רשימה מדויקת לפני המחיקה ואישר רק מה שבאמת מיותר.

ארבע רמות ההרשאה

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

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

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

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

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

Read / Grep / Glob — בדרך כלל אוטומטיים. קריאה וחיפוש הם בטוחים — לא משנים כלום
Edit — דורש הרשאה. שינוי קובץ קיים יכול לפגוע בקוד עובד
Write — דורש הרשאה. יצירת קובץ חדש או דריסה של קיים
Bash — דורש הרשאה כמעט תמיד. הרצת פקודות shell היא הפעולה הכי "רחבה" — אפשר לעשות כל דבר
Agent — דורש הרשאה. סוכן משנה צורך tokens נוספים ויכול לבצע פעולות לא צפויות
WebSearch / WebFetch — דורשים הרשאה. גישה לאינטרנט

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

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

פרויקט-ספציפי: .claude/settings.json בתיקיית הפרויקט
גלובלי: ~/.claude/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 ישאל הרשאה ידנית. ה-wildcard * מתאים לכל ארגומנט.

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

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

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

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

Wildcards בהרשאות — כלי חזק

ה-* ברשימת ה-allow/deny הוא wildcard שמתאים לכל ארגומנט. זה מאפשר ליצור כללים גמישים:

Bash(git status) — מאשר רק git status בדיוק
Bash(git log *) — מאשר git log עם כל ארגומנט: git log --oneline, git log -5, וכו'
Bash(npm *) — מאשר כל פקודת npm (שימו לב — זה כולל npm publish!)
mcp__github__* — מאשר את כל הכלים של MCP server של GitHub

היזהרו עם wildcards רחבים מדי. Bash(rm *) ירשה כל מחיקה — כולל rm -rf /. תמיד חשבו מה ה-wildcard מכסה לפני שמוסיפים.

טיפים פרקטיים להרשאות

התחילו שמרנים — ב-2-3 הסשנים הראשונים, אשרו הכל ידנית. ככה תלמדו מה Claude Code עושה
הוסיפו ל-allow בהדרגה — אחרי 10 פעמים ש-git status בטוח, הוסיפו לרשימה
אל תוסיפו Edit ל-allow — review של כל Edit שווה את הזמן. תמיד בדקו מה משתנה
Deny list קצר ונוקשה — חסמו רק דברים שאף פעם לא צריכים לקרות אוטומטית
אחרי שבוע — בדקו את ההרשאות ב-settings.json. תראו דפוסים ותוכלו לייעל
הגדרות מדורגות — settings.json בתיקיית הפרויקט (.claude/settings.json) חל רק על הפרויקט הזה. settings.json גלובלי (~/.claude/settings.json) חל על כל הפרויקטים. כשיש התנגשות ב-arrays, הרשימות מתאחדות (concatenated), לא מוחלפות

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

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

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

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

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

2.3 שלוש הפעולות הבסיסיות — Read, Edit, Run

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

פעולה	כלים	מה קורה	דוגמה
Understand (הבנה)	Read, Grep, Glob	Claude Code קורא, מחפש, ולומד את הפרויקט	"What does this file do?"
Change (שינוי)	Edit, Write	Claude Code משנה קבצים קיימים או יוצר חדשים	"Fix the typo on line 5"
Execute (הרצה)	Bash	Claude Code מריץ פקודות בטרמינל	"Run the tests"

כל משימה שאתם נותנים ל-Claude Code — מתיקון באג ועד בניית אפליקציה שלמה — היא שילוב של שלוש הפעולות האלה. הוא קורא כדי להבין, משנה כדי לפעול, ומריץ כדי לבדוק. Understand → Change → Execute. שמרו את הדפוס הזה. הוא חוזר על עצמו פעם אחר פעם.

דוגמה: "Fix the bug in login.py"

Understand: Claude Code קורא את login.py עם Read, מחפש קריאות רלוונטיות עם Grep
Change: Claude Code משתמש ב-Edit כדי לתקן את הבעיה
Execute: Claude Code מריץ python -m pytest test_login.py עם Bash כדי לוודא שהתיקון עובד

שלושה צעדים, שלוש פעולות. זה כל מה שיש.

דוגמה מתקדמת יותר: "Set up a new Express.js API endpoint"

Understand: Claude Code מחפש את כל קבצי ה-routes הקיימים עם Glob (src/routes/*.js), קורא את קובץ ה-router הראשי עם Read, ומחפש דפוסי middleware קיימים עם Grep
Change: Claude Code יוצר קובץ route חדש עם Write, מוסיף את ה-import שלו ל-router הראשי עם Edit, ומעדכן את ה-middleware עם Edit נוסף
Execute: Claude Code מריץ את ה-server עם Bash (npm run dev), בודק עם curl שה-endpoint מגיב, ומריץ טסטים עם npm test

שימו לב שמשימה מורכבת יותר משלבת כמה כלים בכל שלב — אבל הדפוס הבסיסי תמיד אותו דבר: Understand → Change → Execute.

הטעות הנפוצה: לדלג על Understand

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

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

ב-Claude Code, בקש: "Read hello.txt, add a second line that says 'line 2', then verify the change with cat"

שים לב: Claude Code עושה Understand (Read) → Change (Edit) → Execute (Bash cat) — שלוש הפעולות ברצף.

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

2.4 כל הכלים בארגז — תשעה כלים שצריך להכיר

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

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

Read

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

מה הוא יכול לקרוא: כל קובץ טקסט (קוד, JSON, YAML, HTML, CSV), תמונות (PNG, JPG — כן, Claude Code רואה תמונות!), PDF (עד 20 עמודים בפעם), ו-Jupyter Notebooks.

דוגמאות:

"Read the file src/auth.py"
"Show me lines 50-80 of package.json"
"Look at the screenshot error.png and tell me what the error is"

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

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

Edit

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

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

דוגמאות:

"Change the background color from blue to green in style.css"
"Fix the typo in the heading on line 23"
"Add error handling to the divide function"

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

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

Write

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

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

דוגמאות:

"Create a new file called utils/helpers.js with date formatting functions"
"Write a Python script that processes CSV data"

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

טעות נפוצה: שימוש ב-Write במקום Edit לקבצים קיימים

מה הטעות: מבקשים "rewrite the file" כשצריכים לשנות רק שורה אחת. Claude Code משתמש ב-Write ודורס קובץ שלם של 500 שורות.

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

מה לעשות במקום: תמיד נסחו "change X to Y in file Z" או "fix the typo on line 23" — כך Claude Code ישתמש ב-Edit (כירורגי) ולא ב-Write (דריסה). Edit משנה רק מה שצריך. Write מחליף הכל.

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

Bash

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

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

דוגמאות:

"Run the tests" → npm test / pytest
"Commit these changes" → git add + git commit
"What's running on port 3000?" → lsof -i :3000

הרשאה: דורש אישור כמעט תמיד.

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

Grep

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

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

דוגמאות:

"Find all usages of getUserById function"
"Search for TODO comments across the project"
"Where is the database connection string defined?"

הרשאה: אוטומטי.

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

Glob

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

תבניות נפוצות:

**/*.js — כל קבצי JavaScript, בכל עומק תיקיות
src/**/*.test.ts — כל קבצי הטסטים בתיקיית src
*.config.* — כל קבצי הקונפיגורציה

הרשאה: אוטומטי.

7. Agent — סוכן משנה לחקירה עמוקה

Agent (Sub-agent)

מה עושה: שולח "סוכן משנה" — Claude Code נוסף שרץ בחלון הקשר (Context Window) נפרד — לחקור שאלה מורכבת. הסוכן חוקר, מנתח, וחוזר עם דוח מסכם.

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

דוגמה: "Investigate how error handling works across this project. Look at all catch blocks and tell me if there's a consistent pattern."

הרשאה: דורש אישור (צורך tokens נוספים).

8. WebSearch — חיפוש באינטרנט

WebSearch

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

דוגמה: "Search for the latest Next.js 15 breaking changes"

זמינות: רק ב-API ישיר של Anthropic (לא ב-Bedrock/Vertex).

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

9. WebFetch — הורדת תוכן מ-URL

WebFetch

מה עושה: מוריד תוכן מכתובת URL ספציפית ועונה על שאלה ממוקדת לגביו. לא מחזיר HTML גולמי — Claude Code מעבד את התוכן ומסכם.

דוגמה: "Fetch https://docs.example.com/api and tell me how to authenticate"

הגבלה: Claude Code לא בונה כתובות URL בעצמו (מאבטחה). הוא יכול רק לגשת ל-URL שנתתם לו או שמצא ב-WebSearch.

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

מסגרת החלטה: הכלי הנכון למשימה

מסגרת החלטה: מטריצת הכלים — שמרו את הטבלה הזו

אני צריך...	הכלי	דוגמה
לראות תוכן של קובץ	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"
לחקור שאלה מורכבת	Agent	"Investigate the auth flow"
לחפש מידע באינטרנט	WebSearch	"Search for React 19 features"
להוריד תוכן מכתובת	WebFetch	"Fetch the API docs at URL"

אתם לא צריכים לציין את הכלי

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

מתי Claude Code משלב כמה כלים ביחד

ברוב המקרים, Claude Code לא משתמש בכלי אחד — הוא משרשר כמה כלים בתגובה אחת. למשל, כשמבקשים "refactor the API routes to use async/await", Claude Code יכול:

Glob — מוצא את כל קבצי ה-routes (src/routes/*.js)
Grep — מחפש שימוש ב-callbacks ו-promises (\.then\(, callback)
Read — קורא כל קובץ שמצא כדי להבין את ההקשר
Edit — משנה כל פונקציה מ-callback/promise ל-async/await
Bash — מריץ npm test כדי לוודא שהכל עובד

כל זה קורה מפרומפט אחד שלכם. Claude Code מתכנן את הרצף בעצמו, בוחר את הכלים הנכונים, ומבצע. בכל שלב שדורש הרשאה (Edit, Bash) — הוא עוצר ומבקש אישור. ולכן ההכרות עם הכלים חשובה — כשתראו ש-Claude Code משתמש ב-Write במקום ב-Edit, או ב-Bash(cat) במקום ב-Read, תדעו שאפשר לכוון אותו טוב יותר.

כלים מובנים ב-Claude Code, ובנוסף — כלי MCP חיצוניים שמרחיבים את היכולות (נלמד בפרק מתקדם)

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

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

"Show me all files in this directory" — Glob? Bash(ls)?
"Read the file hello.txt" — צפה ל-Read
"Add a second line to hello.txt that says 'This is line 2'" — צפה ל-Edit
"Find any file that contains the word Hello" — צפה ל-Grep
"How many lines are in hello.txt?" — Bash(wc) או Read?

מתחיל 10 דקות תיאורטי $0

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

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

שלושת המצבים

מצב	מה קורה	דוגמת פרומפט	משתנים קבצים?
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 עלול לשנות את הקוד. אבל אם תכתבו "explain the error handling in processPayment" — הוא רק יסביר, בלי לגעת. מילה אחת שונה, תוצאה שונה לחלוטין.

טעות נפוצה: שימוש ב-DO כשהתכוונתם ל-EXPLAIN

מה הטעות: רוצים להבין למה ה-authentication לא עובד, וכותבים "Make the authentication more secure." Claude Code ישנה קבצים, יוסיף validations, ואולי ישנה את כל מנגנון ה-auth.

למה זה מפתה: כי "שפר" מרגיש כמו הבקשה הנכונה — אבל זו פקודת DO, לא EXPLAIN.

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

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

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

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

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

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

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

Plan / Outline / Suggest / Propose / Draft a strategy / What would be the best approach / Design

הפעלת Plan Mode רשמית

מעבר למילים בפרומפט, יש דרך רשמית להכנס ל-Plan Mode: הקלידו /plan או לחצו Shift+Tab פעמיים. ב-Plan Mode, Claude Code רק חושב ומציע — אף פעם לא מבצע. כשאתם מאשרים את התוכנית, ההקשר מתנקה אוטומטית — מה שחוסך 25-45% בצריכת tokens.

למה Plan Mode חוסך tokens? כי כשהתוכנית מאושרת, כל השיחה שהובילה אליה מתנקה. במקום להמשיך עם 50K tokens של דיון, Claude Code מתחיל עם תוכנית נקייה של 2-3K tokens. זה כמו לעשות /compact אוטומטי שממוקד בדיוק במה שצריך לעשות הלאה.

אפשר גם לתת הנחיה ל-Plan Mode: /plan migrate the database from SQLite to PostgreSQL — ככה Claude Code מקבל את המשימה ומתכנן ישירות.

Framework: EXPLAIN → PLAN → DO

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

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

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

נניח שקיבלתם דיווח על באג ב-payment processing:

EXPLAIN: "Explain the payment processing flow in this project. Which files are involved?"
EXPLAIN: "Payments fail silently for amounts over 1000 ILS. Review the payment validation logic and tell me what might cause this."
PLAN: "Based on what you found, plan a fix. List the files that need to change. Don't implement yet."
DO: "Implement step 1 from the plan — fix the amount validation."
DO: "Add a test case for payments over 1000 ILS."
DO: "Run the test suite to verify."

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

כשאתם לא בטוחים — ברירת המחדל היא EXPLAIN

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

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

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

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

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

מתחיל 5 דקות פרקטי $0

2.6 הקידומת `!` — פקודות Shell בלי Claude

תכונה קטנה אבל שימושית מאוד: אם מקלידים ! לפני פקודה ב-Claude Code, היא רצה ישירות ב-shell, בלי שClaude מעורב כלל. לא חושב, לא מנתח, לא צורך tokens — פשוט מריץ.

דוגמאות:

! git status — רואים את מצב ה-Git
! pwd — בודקים באיזו תיקייה אנחנו
! ls -la — רואים את כל הקבצים
! cat hello.txt — קוראים קובץ
! git diff — רואים שינויים

למה זה חשוב? כי הקידומת ! לא צורכת tokens — היא בחינם. השתמשו בה כשאתם יודעים בדיוק מה להריץ ולא צריכים את עזרת Claude Code. טריק מצוין: הריצו פקודה עם !, ואז שאלו את Claude Code על התוצאה:

שילוב חכם של ! עם Claude Code

! git diff --stat

ואז:

"Based on the changes I just made, write a descriptive commit message"

ככה קיבלתם את ה-diff בחינם (דרך !) ורק שילמתם על ה-commit message (דרך Claude Code). חיסכון חכם.

מתי להשתמש ב-! ומתי לא

השתמשו ב-!	תנו ל-Claude Code
`! git status` — בדיקת מצב	"What changed since my last commit?" — ניתוח שדורש הבנה
`! ls -la src/` — הצצה לתיקייה	"Find all files related to authentication" — חיפוש חכם
`! npm test` — הרצת טסטים	"Fix the failing test" — תיקון שדורש הבנת הקוד
`! cat package.json` — הצגת קובץ	"Update the dependencies to latest versions" — שינוי שדורש מחקר

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

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

ב-Claude Code, הריצו 3 פקודות עם !: ! pwd, ! ls, ! git status. שימו לב שהן רצות מיד, בלי שClaude Code "חושב".

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

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

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

טעות 1: פרומפט עמום מדי

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

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

הפתרון: היו ספציפיים. הנוסחה: What + Where + Why + Want.

לפני: "Make the app better"

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

טעות 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 not logged in. Add a null check."

טעות 3: "Allow Always" לכל דבר

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

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

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

טעות 4: חוסר הקשר

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

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

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

לפני: "Fix the auth bug"

אחרי: "I changed the login function to use bcrypt instead of md5 (I edited in VS Code, not through Claude Code). Now tests fail with 'hash mismatch'. Old passwords in the DB use md5."

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

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

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

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

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

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

טעות 6: לא לבדוק תוצאות

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

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

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

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

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

הבעיה: הפעלתם מ-Home Directory. Claude Code מחפש ~/src/app.js במקום ~/projects/my-app/src/app.js.

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

הדפוס שחוזר: פרומפטים מדויקים = תוצאות מדויקות

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

Decision Framework: מגן המתחיל

"The Beginner's Shield" — 4 כללים פשוטים

תמיד בדקו תיקייה — ! pwd לפני שמתחילים
תמיד התחילו עם EXPLAIN — הבינו לפני שמבצעים
תמיד בדקו שינויים — ! git diff אחרי כל Edit
תמיד השתמשו ב-Git — commit לפני שינויים גדולים, כדי שאפשר לחזור

אם תעקבו אחרי 4 הכללים האלה, 70% מהתסכולים של מתחילים פשוט לא יקרו.

70%

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

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

לפני שממשיכים — העתיקו את 4 הכללים של "מגן המתחיל" למקום נגיש (פתק, Notes, מסמך). הם ילוו אתכם בשבועות הראשונים.

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

2.8 שלוש משימות מעשיות — Walkthroughs

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

כל תרחיש מיועד לסוג אחר של משתמש: תרחיש A הוא ליוצרי תוכן, משווקים, ואנשים שלא כותבים קוד — הוא מראה איך Claude Code עוזר גם בעבודה שאינה תכנות. תרחיש B הוא למפתחים — זרימת תיקון באג מלאה עם Git. תרחיש C הוא לאנליסטים ואנשי דאטה — יצירת נתונים, ניתוח, ודוח מעוצב. אין תרחיש "לא בשבילי" — Claude Code מתאים לכולם, והתרחישים מדגימים את הרוחב.

חשוב: עלויות התרחישים

כל תרחיש עולה בין $0.20 ל-$0.60 — תלוי באורך השיחה ובמודל שאתם משתמשים בו. אם אתם על מנוי Max — זה כלול. אם אתם משלמים לפי API — שימו לב לעלות. בכל מקרה, זו השקעה ששווה — כי 15 דקות של עבודה מעשית מלמדות יותר משעה של קריאה.

תרחיש A: יוצר תוכן — צור עותקים למודעות

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

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

הקמת הפרויקט:
mkdir ~/ad-copy-demo && cd ~/ad-copy-demo && claude
יצירת עותקים (DO):
"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). Target: freelancers and startup founders aged 25-40."
בדיקת אורך (EXPLAIN):
"Read ad-copy.md and verify all Google Ads headlines are under 30 characters. List any that are too long."
תיקון ושיפור (DO):
"Fix any headlines that are over 30 characters. Also add urgency — mention a 20% launch discount."
גרסה שנייה (DO):
"Create ad-copy-v2.md with a completely different angle — focus on community and networking instead of space and pricing."

זמן: 8-10 דקות | עלות: ~$0.30-0.50

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

תרחיש B: מפתח — מצא באג, תקן, commit

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

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

הקמת הפרויקט:
mkdir ~/bug-fix-demo && cd ~/bug-fix-demo && git init && claude
יצירת קובץ עם באג (DO):
"Create calculator.py with add, subtract, multiply, divide functions. Put a bug in divide — make it return a * b instead of a / b."
מציאת הבאג (EXPLAIN):
"Review calculator.py for bugs. Don't fix anything — just explain what you find."
תיקון (DO):
"Fix the bug you found in the divide function."
בדיקה (DO - Execute):
"Run: python3 -c 'from calculator import divide; print(divide(10, 2))' — it should print 5.0"
Commit (DO):
"Commit all changes: 'Fix: divide function was multiplying instead of dividing'"

זמן: 5-8 דקות | עלות: ~$0.20-0.40

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

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

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

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

הקמה:
mkdir ~/data-demo && cd ~/data-demo && claude
יצירת נתונים (DO):
"Create sales.csv with 50 rows of Israeli sales data. Columns: date (last 3 months), product_name (laptop/headphones/keyboard/monitor/webcam), quantity (1-15), unit_price (100-5000 ILS), region (North/South/Center/Jerusalem/Tel Aviv)."
ניתוח (EXPLAIN):
"Analyze sales.csv: total revenue, best-selling product, best region, average order value, interesting patterns."
דוח מעוצב (DO):
"Create report.html with the analysis. Summary table, top product highlight, regional breakdown. Hebrew, dark theme, RTL, responsive, inline CSS. Make it look professional."

זמן: 10-12 דקות | עלות: ~$0.40-0.60

מה למדת: Write + Bash (ניתוח) + Read + Write (דוח) בשילוב.

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

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

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

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

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

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

Claude Code עובד עם חלון הקשר של כ-200K tokens (ועד 1M tokens ב-Max/Team/Enterprise עם Opus 4.6). כמה זה בפועל? בערך 150,000 מילות אנגלית, או ~500 עמודי טקסט. נשמע הרבה — וזה — אבל בסשן פעיל הוא מתמלא מהר יותר ממה שחושבים.

איך חלון ההקשר מתמלא — הערכה

CLAUDE.md — 1-3K tokens (נקרא אוטומטית בתחילת סשן)
פרומפט ממוצע שלכם — 50-500 tokens
תגובה ממוצעת של Claude Code — 500-5,000 tokens
קובץ קוד בינוני שנקרא — 2,000-10,000 tokens
פלט של npm test — 500-5,000 tokens
git diff ארוך — 3,000-20,000 tokens

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

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

`/compact` — דחיסת הקשר (הכי חשוב)

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

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

מתי להשתמש:

כל 20-30 דקות בסשן עבודה פעיל
אחרי שסיימתם שלב במשימה ("סיימנו auth, עכשיו dashboard")
כשהתגובות מתחילות להיות פחות מדויקות — סימן שהחלון מתמלא
לפני שאלה חשובה — כדי שיהיה מקום לתשובה מפורטת

Auto-compaction — קורה גם בלעדיכם

Claude Code מפעיל דחיסה אוטומטית כשמגיע ל-80% מחלון ההקשר. תראו עצירה קצרה והודעה. אבל עדיף לדחוס פרואקטיבית ולא לחכות — כי ב-80% כבר יש ירידה באיכות. כלל אצבע: דחסו כל 15-20 דקות, אל תחכו לאוטומט.

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

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

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

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

כשסוגרים את Claude Code ורוצים לחזור:

claude --resume — ממשיך את הסשן האחרון. טוען את כל ההיסטוריה
claude --continue — מציג רשימה ומאפשר לבחור סשן

מסגרת החלטה: מחזור חיי הסשן

מסגרת החלטה: מחזור חיי הסשן — הדפוס שצריך לשנן

Start — cd /project && claude (תמיד מתיקיית הפרויקט)
Work — שיחה, כלים, שינויים (20-30 דקות)
Compact — /compact (משחרר מקום)
Work more — ממשיכים עם הקשר דחוס (20-30 דקות)
Compact again — אם צריך
End — /quit
Resume later — claude --resume

מסגרת החלטה: מתי compact, מתי clear, מתי session חדש

מסגרת החלטה: עץ החלטות לניהול סשנים

מצב	פעולה	למה
עבדתם 20 דקות, ממשיכים באותו נושא	/compact	פינוי מקום, שמירת הקשר
עוברים לנושא אחר לגמרי באותו פרויקט	/clear	ההקשר הישן רק מבלבל
עוברים לפרויקט אחר	סשן חדש	תיקיית עבודה שונה
Claude Code נותן תגובות מוזרות	/clear או סשן חדש	ההקשר "מורעל"
חזרה אחרי הפסקה קצרה (שעות)	--resume	ההקשר עדיין רלוונטי
חזרה אחרי יום+	סשן חדש	ההקשר כבר לא מעודכן

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

איך נראה סשן עבודה טיפוסי מנוהל נכון

דקה 0: cd ~/projects/my-app && claude -n "auth-refactor" — נכנסים לפרויקט ונותנים שם לסשן
דקה 1-5: "Explain the current authentication flow. Which files handle login, token refresh, and session management?" — EXPLAIN קודם
דקה 5-10: "Plan how to migrate from JWT stored in localStorage to httpOnly cookies. List all files that need to change." — PLAN אחרי שהבנו
דקה 10-30: DO — מבצעים את השינויים אחד אחרי השני, כל פעם עם ! git diff לבדיקה
דקה 30: /compact focus on the auth migration progress and remaining tasks — דחיסה ממוקדת
דקה 30-55: ממשיכים — טסטים, תיקונים, integration testing
דקה 55: /compact — דחיסה שנייה
דקה 55-80: עובדים על ה-edge cases — token expiry, concurrent sessions, error states
דקה 80: "Run the full test suite" — בדיקה סופית
דקה 85: "Commit all changes with a descriptive message about the auth migration"
דקה 90: /quit — סיום. מחר אפשר claude --resume אם צריך להמשיך

שימו לב לדפוס: EXPLAIN → PLAN → DO → compact → DO → compact → DO → verify → commit. זו שגרת עבודה מקצועית.

טיפים מתקדמים לניהול סשנים

סשנים קצרים וממוקדים — 30-60 דקות על משימה אחת עדיף על 4 שעות על 5 משימות
Compact לפני שאלות קריטיות — לפני refactor גדול או ניתוח מורכב, דחסו קודם
CLAUDE.md = זיכרון קבוע — כל מה שרלוונטי לכל סשן עתידי, שימו ב-CLAUDE.md (נלמד בפרק 3)
git commit בתדירות — commit לפני כל שינוי גדול. אם Claude Code עושה טעות, אפשר לחזור
Checkpoint ו-Rewind — Claude Code יוצר checkpoints אוטומטיים. לחיצה כפולה על Escape מחזירה אתכם לנקודה קודמת — כולל שינויים בקוד. הזכרון נשמר 30 יום
שמות סשנים — השתמשו ב-claude -n "descriptive-name" כדי לתת שמות משמעותיים. כשתריצו --resume מאוחר יותר, תדעו בדיוק מה כל סשן עשה
פקודת /context — בודקת כמה מחלון ההקשר נוצל. הריצו אותה כשמרגישים שהתגובות נעשות פחות מדויקות — אם אתם מעל 60-70%, הגיע זמן ל-/compact

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

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

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

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

2.10 קיצורי מקלדת — תעבדו מהר יותר

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

קיצור	מה עושה	מתי שימושי
Enter	שולח את ההודעה	תמיד
Shift+Enter	שורה חדשה (בלי לשלוח)	כשרוצים לכתוב פרומפט מרובה שורות
Shift+Tab	החלפת מצב: normal → plan mode	כשרוצים לתכנן לפני ביצוע
Ctrl+R	חיפוש בהיסטוריית הפרומפטים	כשרוצים לחזור על פרומפט דומה
Ctrl+C	ביטול הפעולה הנוכחית	כש-Claude Code עושה משהו שלא רוצים
Escape (x2)	Rewind — חזרה לנקודת checkpoint	כשרוצים לבטל שינויים ולחזור אחורה
Tab	השלמה אוטומטית של פקודות /slash	כשמקלידים /com... ורוצים /compact

הקיצורים הכי חשובים להתחיל איתם

שלושת הקיצורים שישנו לכם את החיים:

Shift+Enter — מאפשר לכתוב פרומפטים מרובי שורות. במקום משפט אחד ארוך, תכתבו פרומפט מאורגן עם נקודות. עובד ישירות ב-iTerm2, Kitty, Ghostty, ו-WezTerm
Ctrl+R — חיפוש בהיסטוריית הפרומפטים, כמו bash history search. כתבתם פרומפט מושלם לפני שעה? חפשו אותו ושלחו שוב
Escape (x2) — הזכרון המובנה שלכם. Claude Code שינה משהו שלא אהבתם? לחיצה כפולה על Escape מחזירה את הקוד ואת השיחה לנקודה קודמת. Checkpoints נשמרים 30 יום

קיצורים נוספים שכדאי להכיר

מעבר ל-7 הקיצורים הבסיסיים, יש עוד כמה שמתגלים כשימושיים ביותר:

Ctrl+U — יציאה ממצב bash (!). אם הקלדתם ! בטעות ורוצים לחזור למצב רגיל
/copy — מציג picker אינטראקטיבי של בלוקי קוד מהתגובה. מושלם כשClaude Code נתן קטע קוד שרוצים לשמור. אפשר גם ללחוץ w כדי לכתוב ישירות לקובץ במקום ל-clipboard

טיפ: התאמה אישית של קיצורים

אם קיצור מסוים לא נוח, אפשר לשנות אותו. הקובץ ~/.claude/keybindings.json מאפשר להתאים את כל קיצורי המקלדת. אם אתם עובדים עם Vim — מצב Vim נתמך (מקש Escape מחליף מצבים). זה נושא מתקדם שנכסה בהמשך, אבל טוב לדעת שהאופציה קיימת.

פרומפטים מרובי שורות — למה זה חשוב

בזכות Shift+Enter, אפשר לכתוב פרומפטים מאורגנים:

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

לפני (שורה אחת ארוכה):

"Create a React component for a user profile card that shows the user's name, avatar, email, role, and last login date, with a modern dark theme and responsive design using Tailwind CSS."

אחרי (מאורגן עם Shift+Enter):

Create a React component: UserProfileCard

Fields to show:
- Name + Avatar
- Email + Role
- Last login date

Style: Dark theme, Tailwind CSS, responsive.
File: src/components/UserProfileCard.tsx

אותו תוכן, אבל הרבה יותר ברור. Claude Code מבין טוב יותר פרומפטים מאורגנים.

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

תרגלו 3 קיצורים:

Shift+Enter — כתבו פרומפט מרובה שורות ושלחו
Ctrl+R — חפשו פרומפט מההיסטוריה
Escape (x2) — נסו rewind אחרי שינוי

שגרת עבודה — היום הראשון, השבוע הראשון

תקופה	מה לעשות
יום 1	התקנה (פרק 1), הפעלת סשן אינטראקטיבי, ביצוע אחד מהתרחישים (2.8), תרגול ! prefix
ימים 2-3	עבודה עם EXPLAIN לפני כל DO. אישור הרשאות ידנית. זיהוי דפוסים
יום 4-5	הגדרת settings.json עם allow/deny. שימוש ב-/compact כל 20 דקות. ניסיון resume
שבוע 1 סוף	בדיקת הרשאות ב-settings.json — ייעול. למידת 3 קיצורי מקלדת. מעבר לפרק 3 (CLAUDE.md)
שוטף (יומי)	הפעלת סשן → משימה ממוקדת → compact → המשך → quit. 30-60 דקות לסשן
שוטף (שבועי)	סקירת הרשאות. ניקוי סשנים ישנים. בדיקת עלויות ב-/cost

אם אתם עושים רק דבר אחד מהפרק הזה 1 דקה

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

בדוק את עצמך — Check Yourself

ענו על 5 השאלות בלי להציץ בתשובות. 4 מתוך 5 = עבר. אם לא הצלחתם — חזרו לסעיפים הרלוונטיים ותרגלו. כל שאלה מכוונת לנושא ליבה מהפרק.

בדוק את עצמך — 5 שאלות

מה ההבדל בין claude לבין claude "do something"?
תשובה: הראשון פותח סשן אינטראקטיבי (שיחה מתמשכת). השני מצב one-shot — מבצע ויוצא.
יש קובץ auth.py שלא הכרתם. מה הפרומפט הנכון — "Fix auth.py" או "Explain auth.py"?
תשובה: "Explain auth.py" — תמיד EXPLAIN לפני DO על קוד לא מוכר.
מה ההבדל בין Edit לבין Write?
תשובה: Edit משנה חלק מקובץ (כירורגי). Write יוצר קובץ חדש או דורס קיים לחלוטין.
מתי להשתמש ב-/compact?
תשובה: כל 20-30 דקות בסשן פעיל, אחרי סיום שלב, כשתגובות יורדות באיכות, לפני שאלה חשובה.
מה עושה הקידומת ! ב-Claude Code?
תשובה: מריצה פקודת shell ישירות, בלי שClaude Code מעורב. לא צורכת tokens.

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

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

הפעלתי Claude Code במצב אינטראקטיבי ובמצב one-shot
מבין/ה את מערכת ההרשאות — allow/deny/ask — ויודע/ת להגדיר settings.json
מכיר/ה את שלוש הפעולות הבסיסיות: Understand, Change, Execute
מכיר/ה את 9 הכלים: Read, Edit, Write, Bash, Grep, Glob, Agent, WebSearch, WebFetch
יודע/ת את ההבדל הקריטי בין DO, EXPLAIN ו-PLAN
השתמשתי בקידומת ! להרצת פקודות shell ישירות
מכיר/ה את 7 הטעויות הנפוצות ויודע/ת את הפתרון לכל אחת
השלמתי לפחות אחד מהתרחישים (תוכן / מפתח / אנליסט) מתחילה ועד סוף
יודע/ת להשתמש ב-/compact, /clear, ו-claude --resume
מבין/ה את חלון ההקשר ואת Framework מחזור חיי הסשן
מכיר/ה את 7 קיצורי המקלדת — ותרגלתי לפחות 3
שמרתי את "מגן המתחיל" — 4 הכללים שמונעים טעויות
מרגיש/ה מוכן/ה לעבוד עם Claude Code באופן עצמאי

סיכום הפרק

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

הנוסחה EXPLAIN → PLAN → DO היא לא טיפ — היא עקרון יסוד. היא מבדילה בין משתמש שצורך פי 3 tokens ומקבל תוצאות בינוניות, למשתמש שחוסך ומקבל תוצאות מדויקות. בשילוב עם "מגן המתחיל" (4 הכללים), הגדרת settings.json חכמה, ושליטה בניהול סשנים — יש לכם את כל הכלים לעבודה יומית אמיתית.

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

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

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

1. מצב אינטראקטיבי — Interactive Mode

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

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

3. בחירת מודל ספציפי — Model Selection

4. המשכת סשן קודם — Resume

5. סשן עם שם — Session Naming

מה קורה מאחורי הקלעים כשמפעילים סשן

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

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

ארבע רמות ההרשאה

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

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

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

Wildcards בהרשאות — כלי חזק

טיפים פרקטיים להרשאות

2.3 שלוש הפעולות הבסיסיות — Read, Edit, Run

2.4 כל הכלים בארגז — תשעה כלים שצריך להכיר

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

Read

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

Edit

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

Write

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

Bash

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

Grep

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

Glob

7. Agent — סוכן משנה לחקירה עמוקה

Agent (Sub-agent)

8. WebSearch — חיפוש באינטרנט

WebSearch

9. WebFetch — הורדת תוכן מ-URL

WebFetch

מסגרת החלטה: הכלי הנכון למשימה

מתי Claude Code משלב כמה כלים ביחד

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

שלושת המצבים

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

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

הפעלת Plan Mode רשמית

Framework: EXPLAIN → PLAN → DO

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

2.6 הקידומת ! — פקודות Shell בלי Claude

מתי להשתמש ב-! ומתי לא

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

טעות 1: פרומפט עמום מדי

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

טעות 2: התעלמות משגיאות

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

טעות 3: "Allow Always" לכל דבר

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

טעות 4: חוסר הקשר

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

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

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

טעות 6: לא לבדוק תוצאות

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

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

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

הדפוס שחוזר: פרומפטים מדויקים = תוצאות מדויקות

Decision Framework: מגן המתחיל

2.8 שלוש משימות מעשיות — Walkthroughs

תרחיש A: יוצר תוכן — צור עותקים למודעות

תרחיש B: מפתח — מצא באג, תקן, commit

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

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

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

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

/compact — דחיסת הקשר (הכי חשוב)

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

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

מסגרת החלטה: מחזור חיי הסשן

מסגרת החלטה: מתי compact, מתי clear, מתי session חדש

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

טיפים מתקדמים לניהול סשנים

2.10 קיצורי מקלדת — תעבדו מהר יותר

הקיצורים הכי חשובים להתחיל איתם

2.6 הקידומת `!` — פקודות Shell בלי Claude

`/compact` — דחיסת הקשר (הכי חשוב)

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

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