`.
4. **קובץ הגדרות**: השדה `model` ב-`~/.claude/settings.json`.
פקודות בסיסיות:
```bash
# הפעלה עם המודל הבכיר (כיום Opus 5.5)
claude --model opus
# מעבר ל-Sonnet במהלך הפעלה
/model sonnet
# פתיחת תפריט הבחירה (לבחירה אינטראקטיבית)
/model
# מעבר ל-Opus עם הקשר של 1M
/model opus[1m]
# מעבר לגרסה מסוימת (הצמדה)
/model claude-opus-5-5
```
כינויים ולאן הם מפנים ב-Anthropic API (נכון ל-23 בספטמבר 2026):
- `opus` → Opus 5.5 (נדרש Claude Code v2.1.280 ואילך)
- `sonnet` → Sonnet 5
- `haiku` → Haiku 4.5
- `best` → המודל החכם ביותר הזמין
- `default` → Opus 5.5 ב-Pro, Max, Team, Enterprise וב-Anthropic API
- `opusplan` → שילוב היברידי של Opus + Sonnet (יידון בנפרד בהמשך)
⚠️ ברירות המחדל שונות אצל ספקי ענן: ב-Amazon Bedrock וב-Google Cloud, הכינוי `sonnet` מצביע על Sonnet 4.5; ב-Microsoft Foundry, `opus` עדיין מתייחס ל-Opus 4.6. אם אתם עובדים דרך ספק ענן, הצמידו גרסה מסוימת (`claude-opus-5-5`) או הגדירו את המשתנה `ANTHROPIC_DEFAULT_OPUS_MODEL`.
החל מגרסה 2.1.144, השינוי המרכזי הוא ש-`/model` כבר לא כותבת את הבחירה להגדרות. היא חלה על ההפעלה הנוכחית ונעלמת כשהיא נסגרת. כדי לשמור ברירת מחדל לצמיתות, לחצו על `d` בשורה המסומנת בתפריט הבחירה. הפעולה כותבת את השדה `model` אל `~/.claude/settings.json`.
הפעלות שסוכמו (`claude --resume`, `--continue`, `/resume`) שומרות את המודל ששימש בהפעלה, ללא קשר להגדרה הנוכחית. כך נמנע מצב שבו הפעלה אחרת משנה את המודל שלכם כשאתם ממשיכים שיחה.
כדי לבדוק איזה מודל פעיל כרגע, השתמשו ב-`/status` — הוא מציג גם את החשבון וגם את המודל הנוכחי.
## `/model opusplan`: השוו בנפרד את עלויות התכנון והביצוע
הנקודות המרכזיות
`opusplan` הוא כינוי היברידי: בזמן שאתם ב-Plan Mode, Claude חושב באמצעות Opus (ארכיטקטורה וניתוח משימות); ברגע שיוצאים מ-Plan Mode ומתחיל ביצוע בפועל, הוא עובר אוטומטית ל-Sonnet. החיסכון תלוי בתעריפים ובשימוש בטוקנים בפועל בכל שלב. בדוגמה ההיסטורית שלהלן, תעריפי Sonnet של $3/$15 לקלט ולפלט הם 60% מתעריפי Opus של $5/$25: הפחתה של 40% בחלק הביצוע שהוחלף, ולא 75–80% מהמשימה כולה.
בפרקטיקה המתוארת כאן משתמשים במצב הזה למשימות שיימשכו יותר מ-10 שלבים.
ההיגיון:
- ב-Plan Mode (`/plan`), דנים בארכיטקטורה ובאפשרויות ומסכימים על גישה. Opus יקר כאן, אך מצדיק את מחירו כי החשיבה שלו שונה באופן מהותי.
- ברגע ש-Plan Mode מסתיים ו-Claude מתחיל לערוך קבצים, לכתוב בדיקות ולהריץ פקודות, מתחיל הביצוע. בביצוע, Sonnet 4.6 משתווה ל-Opus באיכות.
כדי להפעיל:
```bash
# בעת ההפעלה
claude --model opusplan
# או במהלך הפעלה
/model opusplan
```
חישוב ספציפי. נניח ש-refactoring בן 50 שלבים מתחלק בדרך כלל כך:
- תכנון (5 שלבים, ~30,000 אסימוני קלט + 8,000 אסימוני פלט): Opus 4.7
- ביצוע (45 שלבים, ~200,000 אסימוני קלט + 50,000 אסימוני פלט): Sonnet 4.6
| אפשרות | עלות תכנון | עלות ביצוע | סך הכול |
|----|----|----|----|
| Opus בלבד | \$0.15 + \$0.20 = \$0.35 | \$1.00 + \$1.25 = \$2.25 | **\$2.60** |
| Opusplan (Opus + Sonnet) | \$0.15 + \$0.20 = \$0.35 | \$0.60 + \$0.75 = \$1.35 | **\$1.70** |
קו הבסיס משתמש ב-230,000 טוקני קלט ו-58,000 טוקני פלט: $2.60 בתעריפי Opus ההיסטוריים שבטבלה. Opusplan משאיר 30,000 טוקני קלט ו-8,000 טוקני פלט ב-Opus ($0.35) ומשתמש ב-200,000 טוקני קלט ו-50,000 טוקני פלט ב-Sonnet ($1.35), ובסך הכול $1.70. החיסכון הוא ($2.60 − $1.70) / $2.60 = 34.6%. באותן ספירות טוקנים ובתעריפים האלה, החלפת הביצוע חוסכת 40% מאותו חלק; גם אם הביצוע היה 90% מעלות הבסיס, החיסכון הכולל היה 36%. הבדל בטוקנייזר דורש ספירות קלט ופלט מפורשות לכל מודל ואינו מצדיק לבדו טענה ל-75–80%.
⚠️ פרט אחד: Opus במצב תכנון של `opusplan` משתמש בהקשר הרגיל של 200K. השדרוג האוטומטי ל-1M, הזמין עם הכינוי `opus`, **אינו** חל על `opusplan`. אם אתם מתכננים משימה ענקית עם מיליוני אסימוני הקשר (למשל, ניתוח monorepo גדול), השתמשו במפורש ב-`/model opus[1m]` או עברו ל-opusplan אחרי התכנון.
## הפקודה `/effort`: 5 רמות של חשיבה מסתגלת
הנקודות המרכזיות
`/effort` שולטת בעומק החשיבה של המודל בכל שלב. הרמות הן low, medium, high, xhigh (Opus 4.7 בלבד) ו-max. החל מגרסה 2.1.117, ברירות המחדל הן xhigh ל-Opus 4.7 ו-high לשאר המודלים. low/medium/high/xhigh נשמרות בין הפעלות; max חלה רק על ההפעלה הנוכחית. ברמת low, Opus נעשה כמעט מהיר וזול כמו Sonnet.
זוהי הפקודה השנייה בחשיבותה אחרי `/model`. מאמץ הוא חשיבה מסתגלת: בכל שלב המודל מחליט כמה לעומק לחשוב בהתאם למורכבות המשימה. ככל שהרמה גבוהה יותר, החשיבה מעמיקה יותר והוא משתמש ביותר אסימונים.
הרמות (בהתאם למשימה):
| רמה | מתי להשתמש בה | מה משתנה |
|----|----|----|
| **low** | משימות קצרות ללא דרישות אינטלקטואליות: שינוי שמות קבצים, grep פשוט, “מה הפונקציה הזאת עושה?”, פקודת build | המודל כמעט לא חושב ועונה במהירות ובזול |
| **medium** | עבודה שבה חיסכון באסימונים חשוב יותר מאובדן קטן של דיוק | מפחיתה שימוש באסימונים; לפעמים מאבדת דיוק בניואנסים |
| **high** | המינימום למשימות שדורשות חשיבה ממשית: כתיבת קוד, refactoring, סקירת קוד | מאזנת בין אסימונים לאיכות. ברירת המחדל של Sonnet 4.6 ו-Opus 4.6 |
| **xhigh** | התוצאות הטובות ביותר ברוב משימות הקוד והעבודה עם סוכנים | ברירת המחדל של Opus 4.7. זמינה רק ב-Opus 4.7 |
| **max** | משימות תובעניות במיוחד. עשויה לשפר תוצאות, אך נוטה לחשיבת יתר | אין מגבלת אסימונים. מתאפסת בסוף ההפעלה |
שלושה מודלים נתמכים: Opus 4.7, Opus 4.6 ו-Sonnet 4.6. המאמץ אינו זמין באחרים.
מה השתנה עד ספטמבר 2026. הרמות `low`, `medium`, `high`, `xhigh` ו-`max` זמינות ב-Opus 5.5, Opus 5, Sonnet 5, Opus 4.8 ו-Opus 4.7; ל-Opus 4.6 ול-Sonnet 4.6 אין `xhigh`, ובקשה לרמת `xhigh` מופעלת בהם כ-`high`. רמת ברירת המחדל היא `high` בכל המודלים שתומכים במאמץ, למעט Opus 5.5 (`medium`) ו-Opus 4.7 (`xhigh`). המשמעות היא שיש לבקש במפורש ניתוח מעמיק מהמודל הבכיר הנוכחי. הופיע גם מצב `ultracode` נפרד: זוהי הגדרה של Claude Code, לא רמת מודל — היא שולחת `xhigh` וגם מבקשת מ-Claude לבנות זרימות עבודה דינמיות למשימות גדולות.
איך מגדירים:
```bash
# פתיחת המחוון האינטראקטיבי
/effort
# הגדרת הרמה ישירות
/effort high
/effort xhigh
# חזרה לברירת המחדל של המודל
auto
# באמצעות דגל בעת ההפעלה
claude --effort high
# באמצעות משתנה סביבה (חל בעת ההפעלה)
export CLAUDE_CODE_EFFORT_LEVEL=high
# בהגדרות (max לא עובד — max חל רק על ההפעלה)
{
"effortLevel": "high"
}
# ב-frontmatter של skill / סוכן משנה
---
name: my-skill
effort: low
---
```
הרמה מופיעה לצד הלוגו וה-spinner ב-Claude Code, לדוגמה, “עם מאמץ נמוך”, כך שאין צורך לפתוח את `/model` כדי לבדוק.
מחוון המאמץ מופיע גם בתפריט הבחירה של `/model` — השתמשו בחצים ימינה ושמאלה כדי להגדיר אותו.
פרט חשוב. כשעוברים ל-Opus 4.7 מכל מודל אחר, המאמץ מוגדר בכפייה ל-xhigh — גם אם הגדרתם high עבור Opus 4.6 או Sonnet 4.6. כדי להחזיר את הרמה הרצויה, הפעילו שוב את `/effort`.
טכניקה נוספת: **ultrathink** בהנחיה. אם תכללו את המילה `ultrathink` בטקסט ההנחיה, Claude ישתמש בחשיבה מעמיקה יותר באותו תור בלי לשנות את המאמץ של ההפעלה. ביטויים דומים (“think”, “think hard”, “think more”) אינם מפעילים את ההתנהגות הזאת — הם פשוט מועברים כטקסט רגיל.
## הפקודה `/fast`: Opus מהיר פי 2.5 במחיר גבוה פי 6 — מתי זה משתלם?
הנקודות המרכזיות
`/fast` היא הגדרת API חלופית למודלי Opus הבכירים. זה אינו מודל אחר — זה אותו Opus, אך מהיר עד פי 2.5 בהפקת פלט. נכון ל-23 בספטמבר 2026, היא נתמכת ב-Opus 5.5, Opus 5 ו-Opus 4.8; מחירה \$8 / \$40 למיליון אסימונים ב-Opus 5.5 ו-\$10 / \$50 ב-Opus 5 וב-Opus 4.8. היא אינה זמינה ב-Sonnet וב-Haiku, והוסרה מ-Opus 4.7 ב-24 ביולי 2026. היא מיועדת לניפוי באגים חי ולעבודה אינטראקטיבית שבה זמן ההמתנה חשוב יותר מהכסף.
מצב Fast הוא תכונת preview למחקר. הוא דורש Claude Code v2.1.36+ ואפשר לבדוק זאת באמצעות `claude --version`.
כדי להפעיל:
```bash
# הפעלה או כיבוי של מצב Fast (זמין ב-CLI של Claude Code ובהרחבת VS Code)
/fast
# או בהגדרות
{
"fastMode": true
}
```
אחרי ההפעלה:
- אם אתם משתמשים במודל אחר, Claude Code יעבור אוטומטית ל-Opus.
- תופיע הודעת אישור “Fast mode ON”.
- סמל `↯` יופיע לצד ההנחיה.
אפשרויות ופרטים:
- מודל ברירת המחדל במצב Fast הוא Opus הזמין והמתקדם ביותר. נכון ל-23 בספטמבר 2026, זהו Opus 5.5; מצב Fast אינו עובד כלל ב-Opus 4.7, והמעבר אליו מכבה את מצב Fast.
- מצב Fast נשמר בין הפעלות כברירת מחדל. מנהלי Team/Enterprise יכולים לדרוש אישור מפורש בכל הפעלה באמצעות `fastModePerSessionOptIn: true`.
- כשמכבים את מצב Fast באמצעות הפעלה חוזרת של `/fast`, נשארים ב-Opus — המודל אינו חוזר לקודם. כדי לעבור מודל, השתמשו ב-`/model`.
- הפעלת מצב Fast באמצע שיחה מחייבת את מחיר מצב Fast עבור כל הקשר השיחה. לכן חסכוני יותר להפעיל את מצב Fast בתחילת ההפעלה, ולא באמצע.
מתי להשתמש במצב Fast:
- **ניפוי באגים חי**: אתם צופים ב-trace וזמן התגובה קריטי.
- **מועד קרוב לעבודה אינטראקטיבית**: אתם כותבים הדגמה עד 18:00 וזקוקים לאיטרציות מהירות.
- **איטרציה מהירה בקוד**: אתם בודקים השערות בזו אחר זו.
מתי לא להשתמש בו:
- **משימות אוטונומיות ארוכות** שבהן המהירות אינה קריטית. משלמים פי 6 עבור מהירות גבוהה פי 2.5 — אין בכך כדאיות אם אתם יוצאים לארוחת צהריים בזמן ש-Claude עובד.
- **עיבוד אצווה, צינורות CI/CD** — לא מיועד כלל למצב אינטראקטיבי.
- **עומסי עבודה רגישים לעלות** — הבחירה ברורה.
זמינות:
- לא עובד ב-Bedrock, ב-Vertex או ב-Foundry.
- נדרשות **נקודות שימוש** בחשבון (חיוב מעבר למכסה הכלולה בתוכנית). בחשבונות פרטיים מפעילים זאת בהגדרות החיוב של Console. ב-Team/Enterprise מנהל חייב להפעיל זאת.
- אסימוני מצב Fast **אינם** מנוכים מהמכסה הכלולה בתוכנית. הם נלקחים ישירות מנקודות השימוש, לפי מחירי מצב Fast החל מהאסימון הראשון.
אם מגיעים למגבלת הבקשות של מצב Fast או שנגמרות נקודות השימוש, מצב Fast עובר אוטומטית למהירות ולתמחור רגילים, סמל `↯` מאפיר והעבודה נמשכת. כשהמגבלה מתאפסת, מצב Fast מופעל מחדש בעצמו.
מצב Fast ומאמץ אינם הגדרות מתחרות. אפשר לשלב ביניהם: מצב Fast + low effort = מהירות מרבית במשימות פשוטות.
## כמה באמת עולה כל מודל: פירוט החשבון החודשי
הנקודות המרכזיות
מחירי בסיס למיליון אסימונים: Haiku 4.5 — \$1 / \$5, Sonnet 4.6 — \$3 / \$15, Opus 4.7 — \$5 / \$25. מצב Fast — \$30 / \$150. שמירת הנחיות במטמון מפחיתה קלט חוזר ל-0.1x. ה-Batch API מעניק הנחה של 50%. מקור החיסכון העיקרי אינו המודל עצמו, אלא הימנעות משימוש ב-Opus כש-Sonnet מספיק.
מחירים למיליון אסימונים (Anthropic API, USD):
| מודל | קלט | כתיבה למטמון ל-5 דקות | כתיבה למטמון לשעה | פגיעה במטמון | פלט |
|------------------|-------|-------------------|-----------------|-----------|--------|
| Haiku 4.5 | \$1 | \$1.25 | \$2 | \$0.10 | \$5 |
| Sonnet 4.6 | \$3 | \$3.75 | \$6 | \$0.30 | \$15 |
| Opus 4.6 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Opus 4.7 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| מצב Fast (Opus) | \$30 | לא זמין | לא זמין | לא זמין | \$150 |
מה באמת מפחית את החשבון:
1. **שמירת הנחיות במטמון.** Anthropic שומרת במטמון חלקים חוזרים של ההנחיות: הנחיית המערכת, CLAUDE.md ותיאורי כלים. פגיעה במטמון עולה 10% ממחיר הקלט. ב-Sonnet, המחיר יורד מ-\$3 למיליון אסימונים ל-\$0.30 — זול פי 10. האפשרות מופעלת אוטומטית באמצעות `cache_control: { type: "ephemeral" }` בבקשת ה-API. ב-Claude Code היא פועלת כברירת מחדל.
2. **Batch API**: הנחה של 50% על קלט ופלט למשימות שאפשר להמתין להן (דוחות, יצירת טקסט בכמויות ובאצוות). Sonnet דרך Batch API עולה \$1.50 / \$7.50. הוא אינו פועל ישירות ב-Claude Code, אבל אם אתם בונים אוטומציות באמצעות Anthropic SDK, השתמשו בו.
3. **opusplan במקום Opus בלבד**: חיסכון של כ-34.6% בדוגמה ההיסטורית המחושבת; הסכום בפועל תלוי בחלק הביצוע, בספירות טוקנים, בתעריפים, במטמון ובניסיונות חוזרים.
4. **Sonnet כברירת מחדל + Opus בעת הצורך**: מקור החיסכון העיקרי. אם Opus מופעל “ליתר ביטחון”, בפרקטיקה המתוארת כאן עוברים ל-Sonnet. אם המשימה דורשת Opus, הדבר מתברר עד השלב השלישי או הרביעי, ואז אני עובר אליו במפורש באמצעות `/model opus`.
5. **זכרו את ה-tokenizer החדש של Opus 4.7.** באותו קובץ, Opus 4.7 משתמש בעד 35% יותר אסימונים מ-Sonnet 4.6. העלות האמיתית של אותה משימה עולה יותר מכפי שהטבלה עשויה לרמוז.
דוגמה ספציפית: משימה טיפוסית של משרד תיווך שבונה אבטיפוס לאתר עבור לקוח חדש: “צור עמוד עם שלושה מקטעים, טופס ושילוב של שער תשלומים.” התוצאות היו:
- Opus 4.7 בלבד (מאמץ high): ~\$4.80 להפעלה (1.5 שעות עבודה).
- opusplan: ~\$1.90 (Opus מתכנן, Sonnet מבצע).
- Sonnet 4.6 בלבד (מאמץ high): ~\$1.30, אבל ההחלטה הארכיטקטונית הייתה פחות טובה (Sonnet בחר בגישה מבוססת תבנית, בעוד Opus ב-opusplan הציע פתרון משלו לדרישות הלא סטנדרטיות).
הבחירה הטובה ביותר למשימה הזאת היא opusplan. החיסכון הוא 60%, עם האיכות של Opus בחלק הקריטי.
Claude Code אינו מציג ישירות ספירת אסימונים עבור המכסות — הן דינמיות ותלויות בתוכנית. אבל ב-`/status` אפשר לראות את התוכנית ואת השימוש הנוכחי. למעקב מפורט יותר, יש מדריך מקיף: [איך להימנע משריפת מכסות Claude Code ביום אחד](https://ailoot.ai/blog/he/claude-code-token-limits-saving/).
## איזו זרימת עבודה יומיומית כדאי להגדיר? 4 קביעות מוכנות מראש
הנקודות המרכזיות
ארבע קביעות מוכנות מראש לסוגי משימות שונים. כתיבת קוד יומיומית — Sonnet + מאמץ high. Refactoring כבד — opusplan. תיקון מהיר — Haiku + מאמץ low. מפגש ארכיטקטורה — Opus 4.7 + מאמץ xhigh + Plan Mode. אפשר לשמור כל אחת ככינוי, לצרף אותה ל-skill או פשוט לשמור אותה כפקודה הראשונה בעת תחילת הפעלה.
אפשר לעבור בין ארבע הקביעות האלה בהתאם ליום העבודה ולמשימה.
**קביעה 1. כתיבת קוד יומיומית — 80% מזמן העבודה בפרקטיקה המתוארת כאן.**
```bash
claude --model sonnet --effort high
# בתוך ההפעלה, עברו ל-Opus אם צריך
/model opus
```
למה היא מיועדת: תכונות חדשות, refactoring קטן, ניפוי באגים פשוטים ותיעוד. Sonnet במאמץ high הוא הנקודה המתוקה.
**קביעה 2. Refactoring כבד — שינוי ארכיטקטוני גדול.**
```bash
claude --model opusplan
# תחילה השתמשו ב-/plan כדי לדון במבנה
# לאחר היציאה מ-Plan Mode, Sonnet מטפל בביצוע
```
למה היא מיועדת: כתיבה מחדש של מודול ביותר מ-15 קבצים, מעבר משילוב אחד עם שער תשלומים לאחר. Opus מטפל בארכיטקטורה (ניתוח התלויות), ו-Sonnet בביצוע (עריכת קבצים במהירות). במשימות כאלה אפשר לחסוך יותר מ-70%.
**קביעה 3. תיקון מהיר — עריכות של שורה אחת וסקריפטים.**
```bash
claude --model haiku --effort low
```
למה היא מיועדת: “שנה שם של משתנה בכל הקבצים”, “כתוב סקריפט bash להפעלה מחדש של nginx”, “מה הפונקציה הזאת עושה?” Haiku מטפל במשימות האלה ועולה פי שלושה פחות מ-Sonnet.
**קביעה 4. מפגש ארכיטקטורה — החלטה אסטרטגית.**
```bash
claude --model opus --effort xhigh
# השתמשו במאמץ מרבי בכניסה ל-Plan Mode:
/plan
# הוסיפו את המילה ultrathink להנחיה עבור שאלות קריטיות
```
למה היא מיועדת: “האם X צריך להיות שירות נפרד?”, “באילו כלים כדאי להשתמש לאבטיפוס?”, “איך לארגן סכמת מסד נתונים לשימוש של כמה דיירים?” כאן Opus 4.7 יקר — ושווה את המחיר, כי טעות כאן עולה שבועות של עבודה.
אפשר לשמור את הקביעות האלה כ-Skills (מודל אחד לכל skill) או ככינויים ב-`~/.zshrc`:
```bash
alias claude-daily='claude --model sonnet --effort high'
alias claude-refactor='claude --model opusplan'
alias claude-quick='claude --model haiku --effort low'
alias claude-architect='claude --model opus --effort xhigh'
```
אם אתם עובדים בצוות, אפשר ליצור תקן באמצעות הגדרות מנוהלות. מנהל מגדיר `availableModels: ["sonnet", "haiku", "opusplan"]` במדיניות הארגונית, והמשתמשים אינם יכולים לבחור Opus ישירות — רק באמצעות הסכמה מפורשת. זו הגנה טובה מפני שרפה לא מכוונת של המכסה.
למי שבונים [סוכני משנה](https://ailoot.ai/blog/he/claude-code-subagents/), אפשר גם להגדיר מודלים שונים לסוכני משנה שונים באמצעות `CLAUDE_CODE_SUBAGENT_MODEL` או השדה `model` ב-frontmatter של הגדרת הסוכן. כך אפשר לבצע אופטימיזציה ברמה נוספת.
## מה לעשות כשנגמרת הקיבולת: 5 טכניקות מעשיות
הנקודות המרכזיות
כשמגיעים למגבלת Opus, אל תיבהלו. יש חמש דרכים להמשיך לעבוד: לעבור ל-Sonnet, להשתמש ב-opusplan, להפעיל שמירת הנחיות במטמון, להעביר חלק מהעבודה ל-Batch API או לעבור ל-Haiku למשימות צדדיות. המכסות הוכפלו במאי 2026 וההאטה בשעות העומס הוסרה, ולכן קשה יותר לנצל את כל קיבולת Opus.
אם `/status` מציג שהגעתם למגבלת Opus:
1. **עברו ל-Sonnet 4.6**: `/model sonnet`. יש לו מאגר נפרד, ולא תרגישו בהבדל ב-80% מהמשימות. ב-Anthropic API, גם כשמגיעים למגבלת Opus, Claude Code עשוי לעבור אוטומטית ל-Sonnet אם מתקרבים לסף.
2. **השתמשו ב-opusplan לעבודה שנותרה**: `/model opusplan`. אם נותרו לכם משימות Plan Mode להיום, הן ישתמשו ב-Opus במידה מועטה (לתכנון בלבד); הביצוע יתבצע כולו ב-Sonnet.
3. **בדקו את שמירת ההנחיות במטמון**: ודאו שלא השבתתם אותה באמצעות `DISABLE_PROMPT_CACHING=1`. אם CLAUDE.md או הנחיית המערכת שלכם מכילים מגה-בייט של הגדרות, יש לשמור אותן במטמון. ב-90% מהקריאות, כך מצמצמים את השימוש פי עשרה.
4. **העבירו משימות אצווה**: אם יש לכם יצירה בכמויות (דוחות, טקסטים, תרגומים), העבירו אותה לסקריפט עם Batch API — הנחה של 50% על קלט ופלט. הוא אינו עובד ישירות ב-Claude Code, אבל אפשר להגדיר אותו בתוך 30 דקות באמצעות סקריפט `tsx` ו-Anthropic SDK.
5. **השתמשו ב-Haiku למשימות משניות**: למשימות שגרתיות כמו “כתוב הודעת commit” או “הסבר מה הקובץ הזה עושה”, העבירו את Claude Code ל-Haiku. הוא משתמש בשליש מהאסימונים של Sonnet ובחמישית מאלה של Opus.
והתזכורת המרכזית: **מאז 6 במאי 2026, המכסות ב-Pro, Max, Team ו-Enterprise הוכפלו**, וההאטה בשעות העומס הוסרה. אם Opus מכלה את הקיבולת שלכם בחצי יום, הבעיה אינה במכסות — משתמשים ב-Opus במקום שבו Sonnet מספיק. מפת ההחלטה בסעיף השני של המדריך הזה תחזיר לכם את השליטה.
לסקירה מעמיקה של המכסות ושל שמונה כללים מעשיים לחיסכון באסימונים, ראו את מאמר העוגן הזה: [איך להימנע משריפת מכסות Claude Code ביום אחד: 8 כללים לחיסכון באסימונים בשנת 2026](https://ailoot.ai/blog/he/claude-code-token-limits-saving/). מדריך משלים מועיל נוסף הוא [Plan Mode ב-Claude Code: מדריך שלב אחר שלב](https://ailoot.ai/blog/he/claude-code-plan-mode/), כי opusplan אינו עובד בלי Plan Mode. והיסוד לכל מודל הוא [איך להגדיר את CLAUDE.md בשנת 2026](https://ailoot.ai/blog/he/claude-md-template/).
### מקורות
- [Anthropic — הכרזה על Claude Opus 5.5 (22 בספטמבר 2026)](https://www.anthropic.com/news/claude-opus-5-5)
- [Anthropic API: סקירת מודלים, תמחור ורמות מאמץ](https://platform.claude.com/docs/en/about-claude/models/overview)
- [Anthropic Claude Code: הגדרת מודל](https://code.claude.com/docs/en/model-config)
- [Anthropic Claude Code: האצת התגובות באמצעות מצב Fast](https://code.claude.com/docs/en/fast-mode)
- [Anthropic Claude Code: מה חדש](https://code.claude.com/docs/en/whats-new)
- [Anthropic API: תמחור](https://platform.claude.com/docs/en/about-claude/pricing)
- [Anthropic API: רמות מאמץ](https://platform.claude.com/docs/en/build-with-claude/effort)
- [Anthropic API: חלון הקשר של מיליון אסימונים](https://platform.claude.com/docs/en/build-with-claude/context-windows)
- [Anthropic Support: מודלים, שימוש ומכסות ב-Claude Code](https://support.claude.com/en/articles/14552983-models-usage-and-limits-in-claude-code)
- [Anthropic Blog: חדש ב-Claude Managed Agents (Code with Claude 2026)](https://claude.com/blog/new-in-claude-managed-agents)
מערך עבודה יעיל ל-vibe coding: **שכפול AI + מוח שני + הנדסת הקשר**. חומרים מעשיים: [התיעוד של Ailoot](https://ailoot.ai/docs/).
חומרים וכלים נוספים: [Ailoot](https://ailoot.ai/).
## שאלות ותשובות: Sonnet, Opus ורמות מאמץ ב-Claude Code: בחירת מודל | Ailoot
### כמה חוסכת דוגמת opusplan המחושבת?
בתעריפים ובספירות ההיסטוריים שבטבלה, Opus בלבד עולה $2.60 ו-opusplan עולה $1.70. החיסכון הוא $0.90 / $2.60, כלומר כ-34.6%; אין בכך ראיה לחיסכון אוניברסלי של 75–80%.
### האם בחירת מודל ביצוע זול יותר מבטיחה משימה מוצלחת זולה יותר?
לא. השתמשו בספירות הקלט, הפלט, המטמון והניסיונות החוזרים בפועל לפי התעריפים החלים והפעילו אותן בדיקות הצלחה. תעריף טוקנים נמוך הוא רק חלק מהעלות הסופית.
## Ailoot · החברה ופורטפוליו הפרויקטים שלה
Ailoot נשענת על ניסיון תפעולי מצטבר, בסיס לקוחות רחב, שירות יציב ובקרה שוטפת של KPI.
החברה ופורטפוליו הפרויקטים שלה: מיליוני לקוחות; מכירות בהיקף של מיליארדים מדי חודש.
Ailoot משתמשת בניסיון התפעולי הזה כדי לספק גישת API ליכולות AI במוצרי לקוחות, בסוכנים, באפליקציות ובאוטומציות.