⚠️ פרק 14

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

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

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

כשסשן לא הולך כמו שציפיתם, זה כמעט תמיד אחד מאלה:

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

הנחיה שכותבים, בשיחה, ב-CLAUDE.md או בסקיל, היא לא דטרמיניסטית: המודל בדרך כלל מקיים אותה, ואין הבטחה. hook, כלל deny והגדרה מנוהלת הם דטרמיניסטיים: קלוד קוד מפעיל אותם בכל פעם, בלי קשר למה שהמודל החליט.

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

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

#איפה להתחיל

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

אם לא ברור איזה שורה מתאימה, הריצו /doctor בתוך Claude Code. אם claude אינו עולה כלל, הריצו claude doctor מהמעטפת. לבדיקת סטטוס שרתי MCP הריצו /mcp.

#ביצועים ויציבות

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

#שימוש גבוה במעבד או בזיכרון

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

1. הריצו /compact באופן קבוע כדי להקטין את גודל ההקשר. אם מוחזר Not enough messages to compact., בשיחה יש מעט מדי תורות לסיכום. זה יכול לקרות גם כשההקשר מלא, אחרי הדבקה גדולה אחת שמילאה אותו.
2. סגרו והפעילו מחדש את Claude Code בין משימות גדולות.
3. שקלו להוסיף תיקיות בנייה גדולות לקובץ .gitignore.
4. הפעילו מחדש עם claude --safe-mode כדי לבדוק אם תוסף, שרת MCP או Hook הוא המקור. המצב מבטל את כל ההתאמות האישיות לסשן. אם השימוש יורד, פנו לניפוי שגיאות בהגדרות כדי לזהות איזה רכיב גורם לזה.

אם זיכרון ה-heap של סשן עובר 2.5GB, מופיעה אזהרת שימוש קריטי בזיכרון. כדי לשחרר את הזיכרון, הפעילו מחדש את Claude Code והריצו claude --continue כדי לחדש את השיחה בתהליך חדש.

מחוץ ל-fullscreen rendering, גם /compact משחרר זיכרון. האזהרה נעלמת כשהשימוש יורד שוב מתחת ל-2.5GB.

אם השימוש בזיכרון נשאר גבוה אחרי הצעדים האלה, הריצו /heapdump כדי לכתוב שני קבצים אל ~/Desktop: snapshot של JavaScript heap בשם <session-id>.heapsnapshot, ופירוט זיכרון בשם <session-id>-diagnostics.json. Claude Code מסתיר את הפקודה מתפריט הפקודות. הקלידו אותה במלואה. ב-Linux בלי תיקיית Desktop, הקבצים נכתבים לתיקיית הבית.

אזהרה: קובץ .heapsnapshot מכיל כל מחרוזת בתהליך, כולל השיחה המלאה ופרטי הזדהות. אל תצרפו אותו ל-issue ציבורי ואל תשתפו אותו.

הפקודה גם מדפיסה סיכום בשיחה: סך הזיכרון של התהליך, כמה ממנו נמצא ב-JS heap, וכמה יושב מחוץ ל-heap. הסיכום מציין גם מדדי דליפה, למשל קצב גידול זיכרון גבוה או מספר חריג של handles פתוחים, ואומר אם רוב הזיכרון ב-JS heap, שה-snapshot קולט, או בזיכרון native, שהוא אינו קולט.

דיווח או חקירה עצמית:

• דיווח: פתחו GitHub issue וצרפו רק את קובץ -diagnostics.json, שמכיל את הסטטיסטיקה מאחורי הסיכום המודפס בלי תוכן שיחה או פרטי הזדהות.
• חקירה עצמית: אם הסיכום מציין שרוב הזיכרון הוא JS heap, פתחו את קובץ .heapsnapshot ב-Chrome DevTools תחת Memory, Load, ומיינו לפי retained size כדי לראות מה מחזיק את הזיכרון.

אם הסיכום מציין שרוב הזיכרון הוא native, ה-snapshot אינו מציג אותו. צרפו לדיווח את מדדי הדליפה מהסיכום.

#טבלאות גדולות נחתכות בטרמינל

טבלת Markdown עם יותר מ-200 שורות מציגה את 200 השורות הראשונות ואחריהן שורה … N more rows not shown. התצוגה מוגבלת. הטבלה המלאה נשארת בשיחה, ו-/copy מעתיק את כל השורות. לטבלה גדולה מדי לקריאה בטרמינל, בקשו מקלוד לכתוב אותה לקובץ. לפני גרסה v2.1.208 Claude Code צייר כל שורה, וחידוש סשן עם טבלה גדולה מאוד עלול היה להיתקע בזמן ציור מחדש.

#דחיסה אוטומטית נעצרת עם שגיאת thrashing

אם מופיע Autocompact is thrashing: the context refilled to the limit..., הדחיסה האוטומטית הצליחה, ואז קובץ או פלט כלי מילאו מחדש את חלון ההקשר כמה פעמים ברצף. Claude Code מפסיק לנסות כדי לא לבזבז קריאות API על לולאה שאינה מתקדמת.

הליך התאוששות:

1. בקשו מקלוד לקרוא את הקובץ החורג בחלקים קטנים יותר, כגון טווח שורות מסוים או פונקציה, במקום את הקובץ כולו.
2. הריצו /compact עם מיקוד שמשמיט את הפלט הגדול, למשל /compact keep only the plan and the diff.
3. העבירו את העבודה על הקובץ הגדול ל-subagent כדי שתרוץ בחלון הקשר נפרד.
4. הריצו /clear אם אין צורך בהמשך השיחה הקודמת.

אם השגיאה חוזרת לאחר /clear, הריצו /context והשוו את שורת Messages לשורות שמעליה:

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

#פקודה נתקעת או קופאת

אם Claude Code אינו מגיב:

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

ההפעלה מחדש שומרת על השיחה. הריצו claude --resume באותה תיקייה כדי לחזור לסשן.

#טקסט משובש או פגום בטרמינל המשולב של עורך

אם תווים מופיעים כתיבות, מריחות או גליפים שגויים כשמריצים את Claude Code בטרמינל המשולב של VS Code, Cursor או Devin Desktop, מעבד ה-GPU של הטרמינל הוא כנראה הסיבה. הריצו /terminal-setup בתוך Claude Code כדי להגדיר את terminal.integrated.gpuAcceleration ל-"off", או הגדירו זאת ידנית בהגדרות העורך וטענו מחדש את החלון. ההגדרות הנוספות ש-/terminal-setup כותב מתוארות בתיעוד הרשמי של הגדרות הטרמינל.

#תווים תועים >0q בהפעלה או >4m אחרי יציאה

התווים האלה מודפסים על ידי טרמינלים שנבנו על ספריית VTE מגרסה קודמת ל-0.53, והם הקצוות של שני רצפי בקרה של Claude Code. כדי להפסיק את הטקסט, עדכנו את Claude Code לגרסה v2.1.301 ואילך: הגרסה הזו מדלגת על שני הרצפים כשהיא מזהה טרמינל כזה.

אם הטקסט נשאר, הדפיסו את גרסת VTE ממעטפת הטרמינל:

echo $VTE_VERSION

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

#גלגל העכבר גולל שורה אחת בכל פעם ב-fullscreen rendering

ב-fullscreen rendering, Claude Code גולל את השיחה עצמו. אם כל תקתוק של הגלגל מזיז פחות שורות ממה שרציתם, הריצו /scroll-speed כדי להעלות את מספר השורות לתקתוק ולשמור, או הגדירו את משתנה הסביבה CLAUDE_CODE_SCROLL_SPEED. בטרמינל של JetBrains IDE, Claude Code מפעיל גלילה משלו, ושתי ההגדרות האלה אינן נכנסות לתוקף. הערכים שכל אחת מהן מקבלת מתוארים בתיעוד הרשמי של גלילת גלגל העכבר.

כדי להתקדם מהר בלי לשנות את המהירות, לחצו PgUp ו-PgDn לגלילה של חצי מסך בכל פעם. כדי להשתמש ב-scrollback המקורי של הטרמינל, הריצו /tui default כדי לעבור למעבד התצוגה הקלאסי.

#פקודות לוח כמו pbcopy נכשלות בתוך ה-sandbox

כש-sandboxing פועל, כלי לוח כמו pbcopy, xclip ו-wl-copy עלולים להיכשל בהגעה ללוח המערכת מתוך פקודת Bash ב-sandbox, והלוח נשאר ללא שינוי אחרי שקלוד מזרים אליהם טקסט.

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

כשקלוד מזרים טקסט לאחד הכלים האלה, הוספת pbcopy *, wl-copy * או xclip * ל-excludedCommands אינה מוציאה את הקריאה מה-sandbox בפני עצמה.

#טקסט שהועתק לא מגיע ללוח המקומי דרך SSH

כש-Claude Code רץ על מכונה מרוחקת דרך SSH, הוא אינו יכול להריץ כלי לוח על המכונה המקומית שלכם. מחוץ ל-tmux, כשבוחרים טקסט ב-fullscreen rendering או מריצים /copy, Claude Code שולח את הטקסט לטרמינל כרצף escape מסוג OSC 52. הטרמינל מחליט אם לשים אותו בלוח. הפקודה /copy מדווחת Copied to clipboard גם אם הטקסט לא הגיע, ומחוץ ל-tmux הודעת הבחירה היא sent N chars via OSC 52.

חלק מהטרמינלים אינם מגיבים ל-OSC 52. התוכנה iTerm2 מתעלמת ממנו עד שמפעילים Settings > General > Selection > Applications in terminal may access clipboard, והתוכנה macOS Terminal.app אינה תומכת בזה.

כדי לקבל את הטקסט בלי OSC 52:

• החזיקו את מקש הבחירה המקורית של הטרמינל בזמן גרירה, ואז העתיקו בקיצור הרגיל של הטרמינל, למשל Cmd+C. המקש הוא Fn ב-Terminal.app ו-Option ב-iTerm2. מפתחות של טרמינלים נוספים מופיעים בתיעוד הרשמי תחת שמירת בחירת טקסט מקורית.
• הגדירו CLAUDE_CODE_DISABLE_MOUSE=1 על המכונה המרוחקת כדי שהטרמינל יטפל בבחירה לאורך כל הסשן.

#בעיות חיפוש וגילוי

אם כלי Search, אזכורי @file, סוכנים מותאמים אישית או כישורים מותאמים אישית אינם מוצאים קבצים, ייתכן שהבינארי המצורף של ripgrep אינו רץ במערכת. התקינו את חבילת ripgrep של הפלטפורמה והורו ל-Claude Code להשתמש בה:

הכלי ripgrep נמצא במאגר community של Alpine. אם apk מדווח שהחבילה חסרה, ראו את סעיף Alpine Linux בתיעוד הרשמי.

אחר כך הגדירו את USE_BUILTIN_RIPGREP ל-0, במשתני הסביבה של המעטפת או בבלוק env של settings.json:

{
  "env": {
    "USE_BUILTIN_RIPGREP": "0"
  }
}

כדי לוודא שההחלפה נכנסה לתוקף, הריצו claude doctor בטרמינל ובדקו ששורת Search מציגה את נתיב ה-ripgrep של המערכת במקום OK (bundled).

#תוצאות חיפוש איטיות או חלקיות ב-WSL

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

הפקודה claude doctor מציגה את Search כ-OK במקרה הזה.

פתרונות:

1. חיפושים ספציפיים יותר: צמצמו את מספר הקבצים בחיפוש באמצעות ציון תיקיות או סוגי קבצים, למשל "Search for JWT validation logic in the auth-service package" או "Find use of md5 hash in JS files".
2. העברת הפרויקט למערכת הקבצים של Linux: אם אפשר, שימו את הפרויקט במערכת הקבצים של Linux (/home/) ולא במערכת הקבצים של Windows (/mnt/c/).
3. הרצה מקורית ב-Windows: שקלו להריץ את Claude Code באופן מקורי ב-Windows, לביצועי מערכת קבצים טובים יותר.

#עזרה נוספת

אם הבעיה אינה מכוסה כאן:

1. הריצו /doctor לבדיקת ההקמה ו-/mcp לבדיקת סטטוס שרתי MCP.
2. השתמשו בפקודה /feedback בתוך Claude Code כדי לדווח על בעיות ישירות ל-Anthropic.
3. בדקו במאגר GitHub של Claude Code בעיות ידועות.
4. שאלו את קלוד ישירות על היכולות והתכונות שלו. לקלוד יש גישה מובנית לתיעוד שלו.

לבעיות חשבון, חיוב או מנוי, פנו לתמיכה של Anthropic: התחברו ב-claude.ai (משתמשי Console: בכתובת platform.claude.com), לחצו על ראשי התיבות שלכם בפינה השמאלית התחתונה, ובחרו Get help. הזרימה המלאה, כולל מי יכול להגיע לנציג אנושי בכל מסלול, נמצאת בתיעוד How to get support.

#1. תנו לקלוד דרך לאמת את העבודה

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

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

אחרי שהבדיקה קיימת, קובעים כמה חזק היא חוסמת עצירה:

• בפרומפט אחד: בקשו מקלוד להריץ את הבדיקה ולחזור עליה באותה הודעה, כמו בטבלה למעלה.
• לאורך סשן: הגדירו את הבדיקה כתנאי יעד באמצעות /goal. מעריך נפרד בודק אותה מחדש אחרי כל תור, וקלוד ממשיך לעבוד עד שהיעד נפתר. אם קלוד נתקע, Claude Code עוצר בסוף את הריצה כשהיעד עדיין מוגדר. אופן ההערכה מתואר בתיעוד הרשמי של /goal.
• כשער דטרמיניסטי: מנגנון Stop hook מריץ את הבדיקה כסקריפט וחוסם את סיום התור עד שהיא עוברת. התיעוד Stop input מכסה את התקרה על חסימות רצופות.
• באמצעות חוות דעת שנייה: סוכן משנה לאימות (verification subagent), או dynamic workflow שבודק את הממצאים שלו, מביא מודל חדש שמנסה להפריך את התוצאה, כך שהסוכן שעשה את העבודה אינו זה שמדרג אותה.

כל שלב מחליף השקעת הגדרה בתשומת לב. גרסת הפרומפט עובדת על כל משימה כבר עכשיו. גרסאות /goal ו-Stop hook הן מה שמאפשר לריצה בלי השגחה להסתיים נכון בלי שאתם נוכחים.

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

#2. קודם חוקרים, אחר כך מתכננים, ואז כותבים קוד

• המלכודת: מתן אפשרות לקלוד לקפוץ ישר לכתיבת קוד עלולה לייצר קוד שפותר את הבעיה הלא נכונה.
• הפתרון: הפרידו בין חקירה ותכנון לבין ביצוע באמצעות plan mode.

סדר העבודה המומלץ כולל ארבעה שלבים:

1. חקירה (Explore): היכנסו ל-plan mode בלחיצה על Shift+Tab עד ששורת הסטטוס מציגה ⏸ plan mode on, או פתחו את הסשן עם claude --permission-mode plan. קלוד קורא קבצים ועונה על שאלות בלי לבצע שינויים.

read /src/auth and understand how we handle sessions and login.
also look at how we manage environment variables for secrets.

2. תכנון (Plan): בקשו מקלוד ליצור תוכנית מימוש מפורטת.

I want to add Google OAuth. What files need to change?
What's the session flow? Create a plan.

לחצו Ctrl+G כדי לפתוח את התוכנית בעורך הטקסט לעריכה ישירה לפני שקלוד ממשיך.

3. מימוש (Implement): צאו מ-plan mode באישור התוכנית או בלחיצה על Shift+Tab, ואז תנו לקלוד לקודד תוך אימות מול התוכנית שלו.

implement the OAuth flow from your plan. write tests for the
callback handler, run the test suite and fix any failures.

4. שמירה ב-Git (Commit): בקשו מקלוד לבצע commit עם הודעה תיאורית ולפתוח PR.

commit with a descriptive message and open a PR

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

#3. תנו הקשר מדויק בפרומפטים

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

פרומפטים מעורפלים יכולים להועיל כשאתם חוקרים ויכולים להרשות לעצמכם לתקן כיוון. פרומפט כמו "what would you improve in this file?" יכול להעלות דברים שלא חשבתם לשאול עליהם.

#ספקו תוכן עשיר

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

• הפניה לקבצים באמצעות @ במקום לתאר איפה הקוד נמצא. קלוד קורא את הקובץ לפני שהוא עונה.
• הדבקת תמונות ישירות. העתקה והדבקה או גרירה ושחרור של תמונות לתוך הפרומפט.
• מסירת כתובות URL לתיעוד ולמקורות API. השתמשו ב-/permissions כדי להוסיף דומיינים בשימוש תדיר לרשימת המותרים.
• הזרמת נתונים בהרצת cat error.log | claude -p "explain this error" כדי לשלוח תוכן קובץ ישירות.
• מתן אפשרות לקלוד להביא בעצמו את מה שהוא צריך. בקשו מקלוד למשוך הקשר באמצעות פקודות Bash, כלי MCP, או קריאת קבצים.

#4. הגדירו את סביבת העבודה

כמה צעדי הקמה הופכים את Claude Code ליעיל בהרבה בכל הסשנים. סקירה מלאה של יכולות ההרחבה ומתי להשתמש בכל אחת נמצאת בתיעוד Extend Claude Code.

#כתבו CLAUDE.md יעיל

הריצו /init כדי לייצר קובץ CLAUDE.md התחלתי המבוסס על מבנה הפרויקט הנוכחי, ואז לטשו אותו עם הזמן.

קובץ CLAUDE.md הוא קובץ מיוחד שקלוד קורא בתחילת כל שיחה. כללו בו פקודות Bash, סגנון קוד וכללי תהליכי עבודה. זה מעניק לקלוד הקשר קבוע שהוא אינו יכול להסיק מהקוד לבדו.

אין פורמט חובה לקבצי CLAUDE.md, אך שמרו עליו קצר וקריא לאדם. לדוגמה:

# Code style
- Use ES modules (import/export) syntax, not CommonJS (require)
- Destructure imports when possible (eg. import { foo } from 'bar')

# Workflow
- Be sure to typecheck when you're done making a series of code changes
- Prefer running single tests, and not the whole test suite, for performance

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

שמרו על קיצור. לכל שורה שאלו: "Would removing this cause Claude to make mistakes?" אם התשובה שלילית, מחקו אותה. קבצי CLAUDE.md מנופחים גורמים לקלוד להתעלם מההוראות האמיתיות שלכם.

אם קלוד ממשיך לעשות משהו שלא רציתם למרות שיש כלל נגדו, הקובץ כנראה ארוך מדי והכלל הולך לאיבוד. אם קלוד שואל אתכם שאלות שכבר נענות ב-CLAUDE.md, הניסוח עשוי להיות דו משמעי. התייחסו ל-CLAUDE.md כמו לקוד: סקרו אותו כשמשהו משתבש, גזמו אותו באופן קבוע, ובדקו שינויים לפי השאלה אם ההתנהגות של קלוד אכן משתנה. עבור קובץ CLAUDE.md שנמצא ב-git, הריצו /doctor וקלוד יציע קיצוצים לתוכן שהוא יכול להסיק מבסיס הקוד.

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

קבצי CLAUDE.md יכולים לייבא קבצים נוספים באמצעות תחביר @path/to/import. לכללי ייבוא ולמקומות שבהם קבצי CLAUDE.md יכולים לשבת, ראו את התיעוד CLAUDE.md files.

#הגדירו הרשאות

כדי לקבל פחות בקשות בלי לוותר על שליטה, אשרו מראש כלים שאתם סומכים עליהם באמצעות /permissions, ותנו לפקודות בסביבת sandbox לרוץ בלי לשאול באמצעות /sandbox. עברו למצב Manual mode כשאתם רוצים לאשר בעצמכם עריכות ופקודות.

החל מגרסה v2.1.283 של Claude Code ואילך, auto mode הוא מצב הרשאות ברירת המחדל בהפעלה לסשנים אינטראקטיביים בטרמינל וב-VS Code: מודל מסווג נפרד בודק את רוב הפעולות במקומכם וחוסם רק מה שנראה מסוכן, כגון הסלמת הרשאות והיקף (scope escalation), תשתית לא מוכרת, או פעולות הנובעות מתוכן עוין. בגרסאות קודמות, auto mode הוא מצב הפתיחה המובנה רק במסלולי Pro, Max ו-Team.

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

• רשימות היתר להרשאות (Permission allowlists): התרת כלים ספציפיים שידועים כבטוחים, כגון npm run lint או git commit.
• Sandboxing: הפעלת בידוד ברמת מערכת ההפעלה המגביל גישה למערכת הקבצים ולרשת, ומאפשר לקלוד לעבוד בחופשיות רבה יותר בתוך גבולות מוגדרים.

קראו עוד בתיעוד הרשמי על מצבי הרשאות, כללי הרשאות ו-sandboxing.

#השתמשו בכלי CLI

הורו ל-Claude Code להשתמש בכלי CLI כמו gh, aws, gcloud ו-sentry-cli בעת אינטראקציה מול שירותים חיצוניים.

כלי CLI הם הדרך החסכונית ביותר בהקשר לעבודה מול שירותים חיצוניים. אם אתם משתמשים ב-GitHub, התקינו את ה-CLI של gh. קלוד יודע להשתמש בו ליצירת issues, לפתיחת pull requests ולקריאת תגובות. בלי gh, קלוד עדיין יכול להשתמש ב-API של GitHub, אך בקשות לא מאומתות נתקלות לעיתים קרובות במגבלות קצב.

קלוד יעיל גם בלימוד כלי CLI שהוא אינו מכיר עדיין. נסו פרומפטים כמו:

Use 'foo-cli-tool --help' to learn about foo tool, then use it to solve A, B, C.

#חברו שרתי MCP

הריצו claude mcp add עם שם שרת וכתובת URL או פקודה כדי לחבר כלים חיצוניים כמו Notion, Figma, או מסד הנתונים שלכם. לדוגמה:

claude mcp add --transport http notion https://mcp.notion.com/mcp

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

#הגדירו hooks

השתמשו ב-hooks לפעולות שחייבות לקרות בכל פעם ללא יוצא מן הכלל.

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

קלוד יכול לכתוב hooks עבורכם. נסו פרומפטים כמו "Write a hook that runs eslint after every file edit" או "Write a hook that blocks writes to the migrations folder.". ערכו את .claude/settings.json ישירות כדי להגדיר hooks באופן ידני, והריצו /hooks כדי לצפות במה שמוגדר.

#צרו כישורים (skills)

צרו קבצי SKILL.md בתוך .claude/skills/ כדי להעניק לקלוד ידע תחומי ותהליכי עבודה לשימוש חוזר.

כישורים (skills) מרחיבים את הידע של קלוד במידע ייעודי לפרויקט, לצוות או לתחום שלכם. קלוד מחיל אותם אוטומטית כשהם רלוונטיים, או שתוכלו להפעיל אותם ישירות עם /skill-name.

צרו skill על ידי הוספת תיקייה עם SKILL.md אל .claude/skills/:

---
name: api-conventions
description: REST API design conventions for our services
---
# API Conventions
- Use kebab-case for URL paths
- Use camelCase for JSON properties
- Always include pagination for list endpoints
- Version APIs in the URL path (/v1/, /v2/)

כישורים יכולים גם להגדיר תהליכי עבודה שניתנים לחזרה שאתם מפעילים ישירות:

---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---
Analyze and fix the GitHub issue: $ARGUMENTS.

1. Use `gh issue view` to get the issue details
2. Understand the problem described in the issue
3. Search the codebase for relevant files
4. Implement the necessary changes to fix the issue
5. Write and run tests to verify the fix
6. Ensure code passes linting and type checking
7. Create a descriptive commit message
8. Push and create a PR

הריצו /fix-issue 1234 כדי להפעיל זאת. השתמשו ב-disable-model-invocation: true עבור תהליכי עבודה עם תופעות לוואי שברצונכם להפעיל ידנית בלבד.

#צרו סוכני משנה מותאמים אישית (custom subagents)

הגדירו עוזרים ייעודיים בתוך .claude/agents/ שקלוד יוכל להאציל אליהם משימות מבודדות.

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

---
name: security-reviewer
description: Reviews code for security vulnerabilities
tools: Read, Grep, Glob, Bash
model: opus
---
You are a senior security engineer. Review code for:
- Injection vulnerabilities (SQL, XSS, command injection)
- Authentication and authorization flaws
- Secrets or credentials in code
- Insecure data handling

Provide specific line references and suggested fixes.

הורו לקלוד להשתמש בסוכני משנה במפורש: "Use a subagent to review this code for security issues.".

#התקינו תוספים (plugins)

הריצו /plugin כדי לעיין במאגר התוספים (marketplace). תוספים מוסיפים כישורים, כלים ואינטגרציות ללא צורך בהגדרה ידנית.

תוספים מאגדים כישורים, hooks, סוכני משנה ושרתי MCP לחבילת התקנה אחת מהקהילה ומ-Anthropic. אם אתם עובדים עם שפה בעלת טיפוסים (typed language), התקינו תוסף בינה לקוד (code intelligence plugin) כדי לתת לקלוד ניווט מדויק בסמלים וזיהוי שגיאות אוטומטי לאחר עריכות.

לבחירה בין כישורים, סוכני משנה, hooks ו-MCP, ראו את סעיף Match features to your goal בתיעוד Extend Claude Code.

#5. תקשורת יעילה

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

#שאלו שאלות על בסיס הקוד

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

• איך עובד ה-logging?
• איך אני יוצר endpoint חדש ב-API?
• מה עושה async move { ... } בשורה 134 בקובץ foo.rs?
• באילו מקרי קצה מטפל CustomerOnboardingFlowImpl?
• מדוע הקוד הזה קורא ל-foo() במקום ל-bar() בשורה 333?

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

#תנו לקלוד לראיין אתכם

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

קלוד שואל על דברים שאולי לא חשבתם עליהם עדיין, כולל מימוש טכני, ממשק וחוויית משתמש (UI/UX), מקרי קצה ושיקולי פשרה (tradeoffs). החליפו את [brief description] בתיאור התכונה שלכם לפני שליחת הפרומפט:

I want to build [brief description]. Interview me in detail using the AskUserQuestion tool.

Ask about technical implementation, UI/UX, edge cases, concerns, and tradeoffs. Don't ask obvious questions, dig into the hard parts I might not have considered.

Keep interviewing until we've covered everything, then write a complete spec to SPEC.md.

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

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

#6. נהלו את הסשן שלכם

שיחות הן מתמשכות וניתנות להחזרה לאחור. השתמשו בזה לטובתכם.

#תקנו כיוון מוקדם ובתדירות גבוהה

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

• מקש Esc: עוצר את קלוד באמצע הפעולה. ההקשר נשמר, כך שניתן לכוון אותו מחדש.
• לחיצה כפולה Esc + Esc או הפקודה /rewind: פותחות את תפריט ה-rewind כדי לשחזר מצב שיחה וקוד קודם, או לסכם מהודעה נבחרת.
• אמירה כמו "Undo that": מורה לקלוד לבטל את השינויים שביצע.
• הפקודה /clear: מאפסת את ההקשר בין משימות שאינן קשורות. סשנים ארוכים עם הקשר לא רלוונטי עלולים להפחית ביצועים.

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

#נהלו הקשר באופן אגרסיבי

הריצו /clear בין משימות שאינן קשורות כדי לאפס את ההקשר.

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

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

• השתמשו ב-/clear בתדירות גבוהה בין משימות כדי לאפס לחלוטין את חלון ההקשר.
• כשדחיסה אוטומטית (auto compaction) מופעלת, קלוד מסכם את מה שהכי חשוב, כולל דפוסי קוד, מצב קבצים והחלטות מפתח.
• לשליטה רבה יותר, הריצו /compact <instructions>, למשל /compact Focus on the API changes.
• כדי לדחוס רק חלק מהשיחה, השתמשו ב-Esc + Esc או ב-/rewind, בחרו נקודת ביקורת של הודעה, ובחרו Summarize from here או Summarize up to here. האפשרות הראשונה מתמצתת הודעות מאותה נקודה והלאה ושומרת על ההקשר המוקדם ללא שינוי, והשנייה מתמצתת הודעות מוקדמות ושומרת על ההודעות האחרונות במלואן. ראו את אפשרויות הסיכום בתפריט ה-rewind בתיעוד הרשמי.
• התאימו אישית את התנהגות הדחיסה ב-CLAUDE.md עם הוראות כמו "When compacting, always preserve the full list of modified files and any test commands" כדי להבטיח שהקשר קריטי יישמר גם לאחר סיכום.
• עבור שאלות שאינן צריכות להישאר בהקשר, השתמשו ב-/btw. התשובה לעולם אינה נכנסת להיסטוריית השיחה, כך שתוכלו לבדוק פרט מסוים מבלי להגדיל את ההקשר.

#השתמשו בסוכני משנה (subagents) לחקירה

האצילו מחקר באמצעות "use subagents to investigate X". הם חוקרים בחלון הקשר נפרד, מה שמשאיר את השיחה הראשית נקייה עבור המימוש.

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

Use subagents to investigate how our authentication system handles token
refresh, and whether we have any existing OAuth utilities I should reuse.

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

#חזרו לאחור עם נקודות ביקורת (checkpoints)

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

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

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

אזהרה: נקודות ביקורת עוקבות רק אחרי שינויים שבוצעו באמצעות כלי עריכת הקבצים של קלוד. שינויים שנעשו באמצעות פקודות Bash או תהליכים חיצוניים אינם נלכדים. זה אינו תחליף ל-git.

#חידוש שיחות

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

קלוד קוד שומר שיחות באופן מקומי, כך שכאשר משימה מתפרסת על פני מספר ישיבות אינכם צריכים להסביר שוב את ההקשר. הריצו claude --continue כדי להמשיך מהמקום שבו עצרתם, או claude --resume כדי לבחור שיחה מרשימה. תנו לסשנים שמות תיאוריים כמו oauth-migration כדי שתוכלו לאתר אותם מאוחר יותר. ראו בתיעוד Manage sessions את הסט המלא של בקרי החידוש, הפיצול לענפים ומתן השמות.

#7. אוטומציה והרחבה (Automate and scale)

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

#הרצה במצב לא אינטראקטיבי (non-interactive mode)

השתמשו ב-claude -p "prompt" בתוך CI, ב-pre-commit hooks או בסקריפטים. הוסיפו את הדגלים --output-format stream-json --verbose כדי לקבל פלט JSON מוזרם.

באמצעות claude -p "your prompt", תוכלו להריץ את קלוד באופן לא אינטראקטיבי, ללא בקשת קלט אינטראקטיבית. ההרצה עדיין יוצרת סשן שניתן לחדש, אלא אם תעבירו את הדגל --no-session-persistence. מצב לא אינטראקטיבי מאפשר לשלב את קלוד בצינורות CI, ב-pre-commit hooks או בכל תהליך עבודה אוטומטי. פורמטי הפלט מאפשרים לפענח תוצאות בצורה תוכנתית: טקסט רגיל, JSON, או streaming JSON.

# One-off queries
claude -p "Explain what this project does"

# Structured output for scripts
claude -p "List all API endpoints" --output-format json

# Streaming for real-time processing
claude -p "Analyze this log file" --output-format stream-json --verbose

הפקודה הראשונה מדפיסה טקסט רגיל. הפורמט json מחזיר אובייקט JSON בודד עם שדה result. הפורמט stream-json מדפיס אובייקט JSON אחד בכל שורה, החל מאירוע init.

#הרצת מספר סשנים במקביל

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

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

• עצי עבודה (Worktrees): הרצת סשני CLI נפרדים בתוך עותקי בדיקה (checkouts) מבודדים של git כדי שעריכות לא יתנגשו.
• העברת הודעות בין סשנים (Cross-session messaging): מאפשרת לסשנים שאתם מריצים בעצמכם להעביר ממצאים זה לזה.
• אפליקציית שולחן העבודה (Desktop app): ניהול מספר סשנים מקומיים בצורה ויזואלית, כאשר כל אחד יכול לשבת ב-worktree משלו.
• שימוש ב-Claude Code בענן: הרצת סשנים על תשתית מנוהלת של Anthropic כברירת מחדל.
• תצוגת סוכנים (Agent view): תצוגה מקדימה למחקר (research preview). הריצו claude agents כדי לשגר סשנים שממשיכים לרוץ ברקע ולצפות בהם ממסך אחד.
• צוותי סוכנים (Agent teams): ניסיוני ומנוטרל כברירת מחדל. תיאום אוטומטי של מספר סשנים עם משימות משותפות, העברת הודעות ומוביל צוות.

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

לדוגמה, השתמשו בדפוס כותב וסוקר (Writer/Reviewer):

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

#פיצול עבודה בין קבצים (Fan out across files)

בצעו לולאה בין משימות תוך קריאה ל-claude -p עבור כל אחת. השתמשו ב---allowedTools כדי לאשר מראש כלים עבור פעולות אצווה (batch).

עבור הגירות (migrations) גדולות או ניתוחים נרחבים, תוכלו לחלק את העבודה בין הפעלות מקביליות רבות של קלוד. הריצו /batch <instruction> כדי שקלוד יפצל את השינוי בין 5 ל-30 סוכני משנה. כל סוכן משנה עובד ב-worktree משלו. כדי להריץ את הפיצול מתוך סקריפט משלכם, בצעו לולאה מעל claude -p:

1. יצירת רשימת משימות: בקשו מקלוד לכתוב לקובץ את רשימת הקבצים שדורשים הגירה, כדי שהלולאה בשלב הבא תוכל לקרוא אותה, עם פרומפט כמו list all 2,000 Python files that need migrating and save the list to files.txt.
2. כתיבת סקריפט לביצוע לולאה על הרשימה:

for file in $(cat files.txt); do
  claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \
    --allowedTools "Edit,Bash(git commit *)" \
    --permission-mode dontAsk
done

3. בדיקה על מספר קבצים, ולאחר מכן הרצה על כולם: דייקו את הפרומפט שלכם על סמך מה שמשתבש ב-2 עד 3 הקבצים הראשונים, ואז הריצו על כל הסט. הדגל --allowedTools מאשר מראש את הכלים הדרושים להגירה, והדגל --permission-mode dontAsk דוחה כל פעולה אחרת שדורשת אישור, דבר שחשוב בריצה ללא השגחה. mod שהתקנתם עדיין יכול לאשר חלק מהקריאות האלה.

ניתן גם לשלב את קלוד בצינורות עיבוד נתונים קיימים:

claude -p "<your prompt>" --output-format json | your_command

#הרצה אוטונומית עם auto mode

להרצה רציפה ללא הפרעות עם בדיקות בטיחות ברקע, השתמשו ב-auto mode. מודל מסווג בודק פקודות לפני הרצתן, חוסם הסלמת היקף (scope escalation), תשתית לא מוכרת ופעולות המונעות מתוכן עוין, תוך שהוא מאפשר לעבודה שגרתית להתקדם ללא בקשות אישור:

claude --permission-mode auto -p "fix all lint errors"

כאשר המסווג חוסם שוב ושוב פעולות בריצה לא אינטראקטיבית עם הדגל -p, קלוד קוד אינו עוצר את הריצה. ראו בתיעוד הרשמי תחת when auto mode falls back מה קורה במקום זאת ואת ספי החסימה.

#הוספת שלב סקירה ביקורתי (adversarial review)

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

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

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

Use a subagent to review the rate limiter diff against PLAN.md. Check that
every requirement is implemented, the listed edge cases have tests, and
nothing outside the task's scope changed. Report gaps, not style preferences.

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

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

#8. הימנעו מדפוסי כשל נפוצים

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

• סשן "הכל מהכל" (The kitchen sink session): אתם מתחילים במשימה אחת, שואלים את קלוד משהו לא קשור, ואז חוזרים למשימה הראשונה. ההקשר מלא במידע לא רלוונטי.

  תיקון: הריצו /clear בין משימות שאינן קשורות.

• תיקון שוב ושוב (Correcting over and over): קלוד עושה משהו שגוי, אתם מתקנים אותו, זה עדיין שגוי, ואתם מתקנים שוב. ההקשר מזוהם בגישות שנכשלו.

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

• קובץ CLAUDE.md עם עודף הגדרות (The over-specified CLAUDE.md): אם הקובץ CLAUDE.md ארוך מדי, קלוד מתעלם מחצי ממנו כי כללים חשובים הולכים לאיבוד ברעש.

  תיקון: גזמו ללא רחמים. אם קלוד כבר עושה משהו נכון בלי ההוראה, מחקו אותה או המירו אותה ל-hook.

• פער האמון והאימות (The trust-then-verify gap): קלוד מייצר מימוש שנראה משכנע אך אינו מטפל במקרי קצה.

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

• חקירה אינסופית (The infinite exploration): אתם מבקשים מקלוד "לחקור" משהו מבלי לתחום את ההיקף שלו. קלוד קורא מאות קבצים וממלא את ההקשר.

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

#9. פתחו את האינטואיציה שלכם

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

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

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

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

#מקורות קשורים

• How Claude Code works: לולאת הסוכן, כלים וניהול הקשר.
• Extend Claude Code: כישורים (skills), מנגנוני hooks, שרתי MCP, סוכני משנה (subagents) ותוספים (plugins).
• Common workflows: מתכונים שלב אחר שלב לניפוי שגיאות, בדיקות, PRs ועוד.
• CLAUDE.md: אחסון מוסכמות פרויקט והקשר מתמשך.