איך למנוע האטה ועלויות גבוהות ב-Claude Code

כיצד למנוע מהאטה ועלויות גבוהות בסשן ארוך של Claude Code

סשן ארוך של Claude Code הופך לאיטי ויקר מכיוון שכל תור (turn) שולח מחדש את כל ההקשר (context), וההקשר הזה רק הולך וגדל. הפתרון הוא שמירה על היגיינה בסדר קבוע. הריצו את /context כדי לראות מה ממלא את חלון ההקשר, הסירו פריטים שאתם משלמים עליהם בכל בקשה, ולאחר מכן השתמשו ב-/clear בין משימות שאינן קשורות, וב-/compact עם הוראה בתוך משימה ארוכה אחת. עבדו ברצף, מכיוון ש-cache קר של ה-prompt הופך קריאה זולה לכתיבה מחדש מלאה של כל מה שאמרתם.

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

קרא את ה-context לפני ביצוע שינויים

אל תנחש מה ממלא את החלון. Claude Code יספק לך את המידע.

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

• ה-system prompt. הוראות המעטפת של Claude Code. קבועות למשך הסשן.
• הגדרות כלים. הסכימה עבור כל כלי שהסוכן יכול להפעיל, כולל כל שרת MCP (Model Context Protocol) מחובר.
• קבצי זיכרון. CLAUDE.md וזיכרון אוטומטי, הנטענים בתחילת הסשן.
• קבצים ותוצאות כלים. כל קובץ שנקרא, וכל פלט שהפקודות שלך החזירו.
• היסטוריית הודעות. התורות שלך והתשובות של הסוכן.

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

שתי מחרוזות מסמנות שהחלון מלא:

Context exceeds the 200k-token limit by 94k tokens — run /compact or /clear to continue.
Context is 94k tokens past the 200k-token compaction window — run /compact to reduce usage.

הראשונה היא מגבלה קשיחה, והבקשה מסורבת; שגיאת ה-API (ממשק תכנות יישומים) המתאימה היא Prompt is too long. השנייה היא חלון דחיסה, שיכול להימצא מתחת לחלון ה-context האמיתי של המודל במודל של מיליון טוקנים. בקשות עדיין מצליחות מעבר לו, לכן זו אזהרה ולא סירוב.

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

CLAUDE.md הוא מס רבוע קבוע, לכן יש לשמור עליו תמציתי

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

העבירו נהלים לתוך מיומנויות (skills). מיומנות נטענת רק כאשר היא מופעלת, כך שזרימת עבודה שאתם מריצים פעמיים בשבוע לא עולה דבר בשאר הימים. למיומנויות יש תקציב משלהן לאחר דחיסה: גופים מוזרקים מחדש, עם תקרה של 5,000 אסימונים למיומנות ו-25,000 בסך הכל, כאשר הישנים ביותר נמחקים ראשונים. קיטום (truncation) שומר על תחילת הקובץ, לכן הציבו את ההוראות החשובות ביותר בראש ה-SKILL.md.

מה ששורד דחיסה קובע היכן הוראה צריכה להימצא.

• ה-system prompt וסגנון הפלט נותרים ללא שינוי, כיוון שהם אינם חלק מהיסטוריית ההודעות.
• ה-CLAUDE.md בשורש הפרויקט, חוקים ללא היקף (unscoped), וזיכרון אוטומטי מוזרקים מחדש מהדיסק.
• חוק עם frontmatter של paths: אובד עד שקובץ תואם נקרא שוב.
• CLAUDE.md מקונן בתת-ספרייה אובד עד שקובץ באותה תת-ספרייה נקרא שוב.
• Hooks אינם מושפעים, כיוון ש-hook רץ כקוד ולעולם אינו נכנס להקשר.

לכן, חוק שאתם מסתמכים עליו שייך ל-CLAUDE.md בשורש הפרויקט: Claude Code מנקה פלטי כלים ישנים תחילה ולאחר מכן מבצע סיכום, כך שהוראות מתחילת השיחה עלולות ללכת לאיבוד. ערכו את הזיכרון באמצעות /memory. Claude Code מחזיק בעותק שהוא טען בתחילת הסשן, לכן קיטום באמצע סשן שומר על ה-prompt cache ולא חל עד ה-/clear, ה-/compact או האתחול הבא. אובדן הקשר הוא רק סיבה אחת לכך שחוק מפסיק להיות מיושם, לכן כאשר החוק עדיין נמצא בבירור בחלון ומתעלמים ממנו בכל זאת, עבדו דרך הסיבות האחרות לפני שתכתבו אותו מחדש.

/clear בין משימות, /compact בתוך משימה אחת

שתי הפקודות הללו נראות דומות, אך העלויות שלהן שונות משמעותית.

/clear [name] מתחיל שיחה חדשה עם הקשר ריק. הוא אינו שולח בקשה, ולכן אינו כרוך בעלות. ניתן להעביר שם כדי לתייג את השיחה הקודמת בבורר ה-/resume; /reset ו-/new הם כינויים (aliases) לאותה פקודה. השתמשו בה ברגע שאתם עוברים למשימה שאינה קשורה לקודמת, שכן אחרת המשימה הישנה תישלח מחדש ותחויב שוב בכל הודעה חדשה.

/compact [instructions] מפנה מקום בהקשר תוך המשך אותה שיחה: הפקודה מסכמת את ההיסטוריה עד כה ומחליפה אותה בסיכום. השתמשו בה בתוך משימה ארוכה שבה אתם עדיין זקוקים לרצף העבודה.

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

/compact focus on the auth bug fix
/compact keep only the plan and the diff

אם אתם מבצעים דחיסה מאותה סיבה בכל פעם, הוסיפו הנחיה קבועה בתוך ה-CLAUDE.md של הפרויקט שלכם תחת כותרת # Compact instructions. בסשן חדש, /compact מדפיס Not enough messages to compact., שמשמעותו היחידה היא שעדיין אין היסטוריה.

ישנו בלבול נפוץ בין שני סוגי עלויות. בקשת הסיכום חולקת את ה-prefix שלכם, כך שהיא קוראת את ה-cache הקיים במקום לעבד מחדש את ההיסטוריה, ורוב הזמן מושקע ביצירת הסיכום. דחיסת הקשר גדול היא עדיין בקשה גדולה, כיוון שהשיחה שמסוכמת מהווה את הקלט. התור (turn) שלאחר הדחיסה אינו החלק האיטי: הוא בונה מחדש את ה-cache עבור prompt קצר בהרבה.

קיימות שתי פקודות זולות יותר. /rewind [description] מחזירה את הקוד והשיחה לנקודת ביקורת (checkpoint); עבור נתיב שברצונכם לנטוש לחלוטין, היא עדיפה על דחיסה, כיוון שהיא מקצרת את השיחה חזרה ל-prefix שכבר נמצא ב-cache. /recap מצרפת סיכום כפלט פקודה במקום להחליף את ההיסטוריה, כך שה-prefix השמור נשאר ללא שינוי.

דחיסה אוטומטית שמופעלת שוב ושוב מדפיסה את ההודעה הבאה:

Autocompact is thrashing: the context refilled to the limit...

הדחיסה הצליחה, אך פלט של קובץ או כלי מילא את חלון ההקשר מספר פעמים ברצף, ולכן Claude Code הפסיק לנסות. ניתן להתאושש על ידי קריאת הקובץ הגדול בטווח שורות, הרצת /compact עם מיקוד שמתעלם מהפלט הגדול, העברת העבודה לסוכן משנה (subagent), או שימוש ב-/clear אם השיחה הקודמת הסתיימה.

שרתי MCP הם בעלי תקורה קבועה

כל שרת MCP שאתם מחברים מוסיף למטען של כל בקשה לאורך כל ה־session. אתם משלמים על כך בין אם אתם קוראים לכלים שלו ובין אם לא.

Claude Code מקל על כך. הגדרות הכלים של MCP נדחות כברירת מחדל, כך שרק שמות הכלים נכנסים ל־context עד ש־Claude משתמש בכלי ספציפי. הריצו את /context כדי לראות מה העלות האמיתית של השרתים שלכם, ואת /mcp disable <name> כדי להסיר שרת שלא תשתמשו בו היום. אם אתם מריצים שרתי MCP משלכם על גבי VPS, אותו חישוב מגביל את מספר הכלים ששרת אחד צריך לחשוף.

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

סינון פלט מפורט של כלי לפני כניסתו להקשר

תוצאה של כלי היא קלט, וקלט זה נשלח מחדש בכל תור עוקב. הרצת בדיקה שפולטת 20,000 אסימונים (tokens) אינה עלות חד-פעמית: אתם משלמים עליה שוב בכל תור עד שהיא יוצאת מהחלון.

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

npm test 2>&1 | grep -E "FAIL|Error:" | head -40

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

הגדרת היקף הקריאה של הסוכן והאצלת משימות רועשות

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

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

שעון המטמון: עבודה במקטעים

מנגנון ה-prompt caching הוא מה שהופך את השליחה החוזרת למשתלמת: 0.1x מתעריף הקלט הבסיסי לקריאת הקידומת, לעומת 1.25x לכתיבתה, או 2x לכתיבתה בטווח חיים של שעה. כל שימוש מרענן את הרשומה ללא עלות נוספת, כך שהשעון מתחיל להיספר מהשימוש האחרון. המכפילים האלו מציגים את מבנה החיוב אך לא את גובהו, לכן יש להצליב אותם עם מה העלות האמיתית של מיליון טוקנים כדי לתרגם חלון הקשר מלא לסכום בדולרים.

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

• במנוי Claude, בקשות Claude Code מקבלות אוטומטית טווח חיים של שעה.
• ברגע שעברת את מכסת התוכנית שלך ואתה משתמש בקרדיטים, אתה מחויב על השימוש הזה, ולכן הטווח חוזר לחמש דקות.
• בשימוש ב-API key או דרך ספק ענן, הטווח נשאר חמש דקות. ENABLE_PROMPT_CACHING_1H=1 מאפשר בחירה בטווח של שעה, ו-FORCE_PROMPT_CACHING_5M=1 מאלץ חזרה לטווח הקצר.

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

פעולות מסוימות מוחקות את המטמון גם כשאתה עדיין עובד: החלפת מודלים, שינוי רמת המאמץ, הפעלת מצב מהיר, חיבור או ניתוק של שרת MCP, הפעלה או ביטול של תוסף, דחיית כלי, דחיסה, ושדרוג Claude Code. /model הוא הגורם המפתיע הנפוץ ביותר, כיוון שלכל מודל יש מטמון משלו; לכן הבקשה הבאה תקרא את כל ההיסטוריה ללא פגיעות במטמון, גם אם התוכן זהה. קריאה חוזרת זו מחויבת לפי התעריפים של מודל היעד, כך שמעבר באמצע סשן ל-Fable יחייב אותך על כל ההיסטוריה שנצברה לפי תעריף הקלט המפורסם של Fable 5.

עריכת קבצים, עריכת CLAUDE.md, הפעלת מיומנויות ופקודות, הרצת /recap, חזרה לאחור (rewind) והפעלת סוכן משנה (subagent) – כל אלו שומרים על המטמון. המטמון מוגבל למכונה אחת ולספרייה אחת, כך ששני סשנים בספריות שונות לא יחלקו את אותו המטמון. היקף זה עוקב אחר ה-CLI ולא אחר החשבון שלך, לכן דבר מזה לא עובר לאפליקציית הדסקטופ של Claude, אשר בלינוקס היא התקנת בטא נפרדת לצד ה-CLI.

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

האם חלון הקשר גדול יותר פותר זאת?

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

עריכת הקשר ודחיסה ב-API הם דברים שונים

אם אתם בונים סוכן משלכם על גבי ה-Messages API, לא קיימות פקודות slash ואתם מממשים זאת בעצמכם. תכננו תקציב לעבודה זו מראש, כיוון ש-ל-API אין מסלול חינמי מעבר לקרדיט הרשמה קטן, כך שכל סבב של היסטוריה לא מקוצרת מחויב במלואו. ספק השירות עליו אתם בונים קובע את החישוב הזה עוד לפני שמתבצע קיצור כלשהו, לכן אם הבחירה עדיין פתוחה, חשבו את עלות אותו עומס עבודה בשני ה-APIs במקום להשוות רק את מחירי ה-per-token המוצהרים. שתי תכונות בצד השרת מבצעות את העבודה, והן אינן אותה תכונה.

עריכת הקשר (Context editing) מוחקת באופן סלקטיבי תוכן ספציפי מהיסטוריית השיחה ככל שהיא גדלה, ומחליפה כל תוכן שנמחק בטקסט מציין מקום כדי ש-Claude ידע שמשהו הוסר. זוהי גרסת בטא: שלחו anthropic-beta: context-management-2025-06-27 והגדירו אסטרטגיות תחת context_management.edits. clear_tool_uses_20250919 מוחק תוצאות של כלים, ו-clear_thinking_20251015 מנהל בלוקים של חשיבה (thinking blocks). ערך ה-trigger כברירת מחדל הוא 100,000 טוקנים של קלט, ה-keep מוגדר ל-3 השימושים האחרונים בכלים, ו-clear_tool_inputs מוגדר ל-false, כך שהקלט נשאר ורק התוצאות מוסרות.

דחיסה (Compaction) מייצרת סיכום ומחליפה בו את כל היסטוריית השיחה המלאה. גם זו גרסת בטא: שלחו anthropic-beta: compact-2026-01-12 והשתמשו בסוג העריכה compact_20260112. הטריגר מוגדר כברירת מחדל ל-{"type": "input_tokens", "value": 150000}, והערך חייב להיות לפחות 50,000.

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

התיעוד של Anthropic מגדיר דחיסה בצד השרת כאסטרטגיה העיקרית לניהול הקשר בשיחות ארוכות טווח, ואת עריכת ההקשר כאופציה לשליטה מדויקת יותר על מה שנמחק. בדקו תחילה את תמיכת המודל. דגמי Opus, Sonnet ו-Fable הנוכחיים תומכים בדחיסה; claude-haiku-4-5 אינו תומך בכך, ודף הדחיסה מכיל את הרשימה המעודכנת. אף אחת מגרסאות הבטא הללו אינה מפעילה את ה-/compact של Claude Code, אשר התיעוד שלו מתאר אותו כבקשת סיכום חד-פעמית שהלקוח שולח.

FAQ

מדוע סשן Claude Code שלי הופך לאיטי ויקר יותר ככל שהוא רץ זמן רב יותר?

מכיוון שכל השיחה נשלחת מחדש בכל תור, שאלה של שורה אחת בסשן שהיה פתוח כל היום גוררת איתה את כל היום. Prompt caching שומר על עלות נמוכה כל עוד ה-cache חם, בשיעור של 0.1x מעלות הקלט הבסיסית עבור קריאה; ברגע שתור מפספס את ה-cache, אותו קידומת נכתבת מחדש ב-1.25x. הריצו את /context כדי לראות מה ממלא את החלון, וקראו את על מה מחייב אתכם סשן Claude Code כדי להבין את המנגנון.

מה ההבדל בין /clear לבין /compact ב-Claude Code?

/clear מתחיל שיחה חדשה עם הקשר ריק. הוא לא שולח בקשה, לכן הוא לא עולה דבר, וזו הבחירה הנכונה בין משימות שאינן קשורות. /compact שומר על אותה שיחה ומחליף את ההיסטוריה בסיכום, לכן זו הבחירה הנכונה בתוך משימה אחת ארוכה. תנו לו מיקוד, כמו ב-/compact keep only the plan and the diff, מכיוון שההנחיה קובעת מה נשמר.

איך אוכל לראות מה צורך את חלון ההקשר (context window) של Claude Code שלי?

הריצו את /context, או את /context all עבור פירוט מלא לפי פריט. הוא מציג את ה-system prompt, הגדרות כלים, שרתי MCP, קובצי זיכרון והיסטוריה כרשת צבעונית, עם הצעות לגבי כלים עתירי הקשר ונפיחות בזיכרון. בתוכנית בתשלום, /usage גם משייך שימוש אחרון למיומנויות בודדות, סוכני-משנה ושרתי MCP.

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

חלון גדול יותר רק דוחה את הבעיה במקום לפתור אותה. כמה מודלים נוכחיים מריצים חלון הקשר של 1 מיליון טוקנים, ביניהם Opus 4.8 ו-Sonnet 5, והדחיסה מתנהגת שם באותו אופן. כל תור עדיין שולח מחדש את ה-prompt המלא ועדיין מחייב עליו, לכן שיחה של 400,000 טוקנים היא יקרה בין אם היא נכנסת לחלון ובין אם לא.

מה ההבדל בין עריכת הקשר (context editing) לבין דחיסה (compaction) ב-Claude API?

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