לדלג לתוכן

4.1 ניהול הקשר הרצאה

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

מהו חלון ההקשר - context window

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

לפי התיעוד הרשמי של Claude Code, הcontext window מחזיק את הרכיבים הבאים:

- System instructions (system prompt) - how Claude Code works
- CLAUDE.md file - the project's rules and context
- Auto memory - things learned in previous sessions
- Settings for available tools and skills
- Conversation history - all your messages and Claude's
- Content of files that were read and output of commands that ran

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

מה ממלא את הcontext - what fills context

חשוב להבין שלא כל הרכיבים שווים בגודלם. חלקם קבועים וחלקם גדלים ללא הרף תוך כדי עבודה.

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

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

> /context

# Shows a visual breakdown:
# System prompt, Tools, MCP, Skills, Memory (CLAUDE.md),
# Messages (the conversation) - each with percentage of the window

בנוסף, הגדרות של שרתי MCP יכולות לתפוס מקום רב. Claude Code דוחה כברירת מחדל את טעינת ההגדרות המלאות של MCP tools (deferred), כך שרק שמות הtools נכנסים להcontext עד שמשתמשים בtool ספציפי. עדיין, שרת MCP שלא בשימוש הוא נטל - אפשר לראות עלויות לפי שרת עם /mcp ולכבות מה שלא צריך.

דחיסה וסיכום - compaction

מה קורה כשהcontext מתקרב לגבול? Claude Code מנהל את זה אוטומטית, ובסדר מדורג. לפי התיעוד, כשמתקרבים לגבול המערכת קודם מנקה פלטים ישנים של tools, ורק אם צריך עוד מקום - היא מסכמת את השיחה. התהליך הזה נקרא דחיסה, compaction, או auto-compaction כשהוא אוטומטי.

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

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

אפשר גם להשפיע על מה שנשמר בדחיסה. הפקודה /compact מפעילה דחיסה יזומה, ואפשר לתת לה מיקוד:

# Regular compaction - the system decides what's important
/compact

# Compaction with a prompt - keep what matters to me
/compact focus on the API changes and the failing tests

אפשר גם להגדיר prompts דחיסה קבועות בקובץ CLAUDE.md, בקטע ייעודי:

# Compact instructions

When you are using compact, please focus on test output and code changes

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

מתי לנקות ומתי להמשיך - clear vs continue

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

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

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

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

# Finished the task, moving to something else
/rename fix-network-retry-bug   # gave the current session a name
/clear                          # start clean

# and if I need to come back later
/resume                         # pick the session from the list

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

לשמור על הagent ממוקד - keeping focus

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

  • פרומפטים ספציפיים במקום סריקה רחבה: בקשה מעורפלת כמו "שפר את הקוד" גורמת ל-Claude לסרוק המון קבצים ולנפח את הcontext. בקשה ממוקדת כמו "הוסף ולידציה לפונקציית ההתחברות ב-auth.ts" מאפשרת עבודה יעילה עם מינימום קריאות.
  • סשן אחד למשימה אחת: אל תערבבו שלוש משימות שונות בשיחה אחת. כל משימה נקייה בסשן שלה.
  • האצלה לסוכני משנה - subagents: כשמשימה דורשת המון קריאה או פלט (למשל, לחקור ספרייה שלמה או להריץ בדיקות מרובות), אפשר להאציל אותה לsub-agent. לsub-agent יש context משלו, נפרד לגמרי מהשיחה הראשית, והוא מחזיר רק סיכום. כך הפלט המפורט לא מנפח את הcontext שלכם. זו אחת הסיבות המרכזיות שsub-agents עוזרים בסשנים ארוכים, ונרחיב על כך בפרק נפרד.
  • סקילים במקום הכל ב-CLAUDE.md: הוראות לזרימות עבודה ספציפיות עדיף לשים בסקיל שנטען לפי דרישה, ולא ב-CLAUDE.md שנטען תמיד.

תרחיש מהחיים - a session gone wrong

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

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

הפתרון הנכון היה לעצור אחרי תיקון הבאג, לתת לסשן שם עם /rename fix-auth-bug, ולהתחיל נקי עם /clear לפני המשימה החדשה. אם הביניים היה קשור - למשל, המשכתם לעבוד על אותו מודל אימות - אז /compact היה מכווץ את ההיסטוריה ושומר את הcontext הרלוונטי. ההבחנה בין שני המקרים היא כל האמנות של ניהול context.

זיכרון אוטומטי מול context - auto memory

יש עוד רכיב שכדאי להכיר, כי הוא נכנס לcontext: הזיכרון האוטומטי (auto memory). לפי התיעוד, Claude Code שומר אוטומטית "לקחים" תוך כדי עבודה - דפוסים בפרויקט והעדפות שלכם - ובתחילת כל סשן נטענות ה-200 השורות הראשונות או 25KB של קובץ הזיכרון, לפי מה שקורה קודם.

הנקודה החשובה: סשנים הם עצמאיים. כל סשן חדש מתחיל עם context window טרי, בלי היסטוריית השיחה של סשנים קודמים. מה שכן עובר בין סשנים הוא רק שני דברים: הזיכרון האוטומטי, וההוראות הקבועות שלכם ב-CLAUDE.md. זו עוד סיבה לכך שחוקים חשובים חייבים לשבת ב-CLAUDE.md - זה המקום היחיד (יחד עם הזיכרון האוטומטי) ששורד גם /clear וגם מעבר לסשן חדש. כל דבר שנאמר רק בשיחה נעלם ברגע שהשיחה נדחסת או נסגרת.

המחיר של context מנופח - the cost of bloat

למה כל זה חשוב? כי לcontext מנופח יש מחיר כפול, ושניהם מורגשים.

מחיר כספי וזמן: Claude Code מתמחר לפי צריכת טוקנים, ועלות עולה עם גודל הcontext - ככל שיש יותר context לעבד, כך צורכים יותר טוקנים בכל הודעה. שיחה מנופחת משלמת את המחיר הזה שוב ושוב, בכל תור. אפשר לעקוב אחרי הצריכה עם /cost (שהוא כינוי ל-/usage), שמציג עלות משוערת, משך זמן, ופירוט לפי סקילים, sub-agents ושרתי MCP:

> /cost

Total cost:            $0.55
Total duration (API):  6m 19.7s
Total duration (wall): 6h 33m 10.2s
Total code changes:    0 lines added, 0 lines removed

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

כדי לראות את הצריכה כל הזמן ולא רק כשמריצים פקודה, אפשר להגדיר את שורת הסטטוס (status line) להציג את ניצול הcontext window באופן רציף. כך שמים לב להתנפחות עוד לפני שהיא הופכת לבעיה.

לסיכום העיקרון: התייחסו לcontext כמו לתקציב. כל קובץ שנקרא, כל פקודה שרצה, כל הודעה - הם הוצאה. נהלו את התקציב הזה במודעות: נקו כשעוברים משימה, דחסו כשצריך להמשיך, האצילו פעולות רועשות לsub-agents, ושמרו את החוקים הקבועים ב-CLAUDE.md. זה ההבדל בין agent שמשרת אתכם לבין agent שנחנק בזיכרון שלו.

סיכום

  • הcontext window מחזיק את הוראות המערכת, CLAUDE.md, זיכרון אוטומטי, tools, סקילים, היסטוריית השיחה, תוכן קבצים ופלט פקודות. הוא משאב סופי ויקר.
  • הcontext מתמלא בעיקר מהיסטוריית שיחה, קריאות קבצים ופלט פקודות - אלה גדלים ללא הרף. /context מראה בדיוק מה תופס מקום.
  • כשהcontext מתמלא, Claude Code מנקה פלטים ישנים ואז מסכם את השיחה (compaction). הבקשות וקטעי קוד נשמרים, אבל הוראות מתחילת השיחה עלולות ללכת לאיבוד - לכן חוקים קבועים שמים ב-CLAUDE.md.
  • /compact מכווץ ושומר את השיחה (אפשר עם מיקוד: /compact focus on ...); /clear מתחיל נקי. משתמשים ב-/clear כשעוברים למשימה לא קשורה, ב-/compact כשממשיכים אותה משימה.
  • לשמירה על מיקוד: פרומפטים ספציפיים, סשן אחד למשימה, האצלה של פעולות רועשות לsub-agents, והוראות בסקילים במקום ב-CLAUDE.md.
  • הcontext מנופח עולה יותר כסף וזמן (/cost), ובעיקר פוגע באיכות התשובות. הcontext קטן וממוקד עדיף כמעט תמיד.