# איך להפעיל את Claude Code ואת Codex למשך הלילה באמצעות /goal בשנת 2026: מצב אוטונומי של 14 שעות

> הפקודה /goal ב-Claude Code 2.1.139 וב-Codex CLI מפעילה סוכן AI באופן אוטונומי למשך שעות. אני מסביר איך להגדיר זאת, מציג דוגמאות מהעולם האמיתי ומפרט כמה טוקנים זה עולה.

Source: https://ailoot.ai/blog/he/goal-mode-claude-code-codex/
Canonical: https://ailoot.ai/blog/he/goal-mode-claude-code-codex/
Language: he
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-103
Revision: sha256-ce6b09732ef19395eb24a2b63b75c8e877a65b59eb4243f3ff5c3375b51893d1


<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

הפקודה `/goal` הופיעה ב-Claude Code 2.1.139 (11 במאי 2026) וב-Codex CLI 0.128.0 (30 באפריל 2026, יציבה מאז 21 במאי). מגדירים פעם אחת את הקריטריון להשלמה, והסוכן עובר בעצמו בין תכנון, פעולה ואימות עד שהקריטריון מתקיים או עד שנגמרים לו הטוקנים. OpenAI הציגה בפומבי ריצה של 25 שעות, שבה נעשה שימוש ב-13 מיליון טוקנים. השיטה מתאימה להעברות, לבדיקות ביצועים ולשכתובי קוד עם קריטריונים מדידים. היא אינה מתאימה למשימות ממשק משתמש, למסדי נתונים בייצור או לבקשות מעורפלות כמו „שפר את זה”.

</div>

מידע על עבודה עם Ailoot זמין ב[תיעוד](https://ailoot.ai/docs/).

## מהי `/goal` ולמה היא הופיעה ב-2026?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

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

</div>

המצב שכולנו חווינו לפני אפריל 2026: אני נותן ל-Claude משימה, „העבר את הפרויקט מ-Pydantic v1 ל-v2”. הוא מתחיל, נעצר אחרי 30 שניות, אני בודק מה עשה, כותב „המשך”, הוא מבצע את הצעד הבא, נעצר, ואני כותב שוב „המשך”. בהעברה גדולה זה אומר 200–300 פקודות „המשך” ידניות, ואני למעשה משגיח על הסוכן במקום לכתוב קוד אחר במקביל.

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

כך נוצרה `/goal` — מנגנון המשולב ברתמה, ולא במודל.

<figure>
<blockquote>
<p>כברירת מחדל, אינכם כותבים עוד הנחיה ל-Claude. כברירת מחדל, Claude כותב את ההנחיה שלו בעצמו.</p>
</blockquote>
<figcaption>— בוריס צ'רני, ראש Claude Code ב-Anthropic</figcaption>
</figure>

ההערה נאמרה בכנס Code with Claude בלונדון, ב-19–20 במאי 2026. היא מתארת את מה שקרה בפועל בחודש שלאחר השקת `/goal` בשני הכלים.

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

## איך מגדירים מצב Goal ב-Claude Code?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

Claude Code 2.1.139 יצא ב-11 במאי 2026, עם הפקודה `/goal`. מודל קטן (Haiku כברירת מחדל) בודק את הקריטריון אחרי כל תור. אם הקריטריון לא מתקיים, Claude מבצע תור נוסף. אורך הקריטריון יכול להגיע ל-4,000 תווים, ויש יעד אחד לכל הפעלה.

</div>

דוגמה מינימלית מהתיעוד הרשמי של Anthropic:

```bash
claude -p "/goal CHANGELOG.md has an entry for every PR merged this week"
```

הפקודה הזאת מפעילה את הסוכן ברקע עם יעד אחד. Claude מוצא את בקשות המיזוג (PR), משווה אותן ל-CHANGELOG.md, מוסיף שורות חסרות ועוצר כשהקריטריון מתקיים.

במצב אינטראקטיבי, פשוט הקלידו `/goal` ואחריו את התנאי:

```
/goal all pytest tests pass and mypy strict reports zero errors
```

מה Claude עושה לאחר מכן:

- אחרי כל תור, מודל מהיר נפרד (Haiku כברירת מחדל) מקבל את התנאי הנוכחי ואת היסטוריית השיחה
- המודל הזה משיב „כן” או „לא” עם נימוק קצר
- אם התשובה היא „לא”, Claude מבצע אוטומטית תור נוסף בלי להחזיר לך את השליטה
- אם התשובה היא „כן”, היעד מתנקה והשליטה חוזרת אליך

<figure>
<blockquote>
<p>אחרי כל תור, מודל קטן ומהיר בודק אם התנאי התקיים. אם לא, Claude מתחיל תור נוסף בלי להחזיר לך את השליטה.</p>
</blockquote>
<figcaption>— התיעוד הרשמי של Claude Code, https://code.claude.com/docs/en/goal</figcaption>
</figure>

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

- `/goal` פועלת רק בספריות עבודה שבהן אושרה בקשת האמון. אם אתם עובדים במחשב חדש ו-Claude עדיין לא זוכר את הספרייה, הפקודה תיכשל
- בסביבות ארגוניות שבהן מוגדרים `disableAllHooks` או `allowManagedHooksOnly`, הפקודה אינה זמינה
- אורך התנאי יכול להגיע ל-4,000 תווים
- אפשר להפעיל יעד אחד בלבד בכל הפעלה. פקודת `/goal` חדשה מאפסת את היעד הקודם
- עם `--resume`, התנאי נשמר, אבל מוני התורים, הזמן והטוקנים מתאפסים

פקודות שליטה:

- `/goal` ללא ארגומנט — הצגת המצב הנוכחי
- `/goal clear` (או `stop`, `off`, `reset`, `none`, `cancel`) — ניקוי היעד

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

מניסיונו של ארטמי מילר, משתמשים במצב הזה בעיקר לשני סוגי משימות: העברות ממושכות (שבהן אחרת הייתם משקיעים שעות בלחיצה ידנית על „המשך”) ובדיקות אוטומטיות לאחר שינויים גדולים. ביום השלישי לעבודה עם `/goal`, מספר המחבר שהוא הפסיק להשאיר את המסוף פתוח וללוות את הסוכן ללא הפסקה.

## איך מגדירים `/goal` ב-Codex CLI?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

Codex CLI 0.128.0 הוסיף את `/goal` ב-30 באפריל 2026 כתכונה ניסיונית. ב-21 במאי המצב הפך ליציב בגרסה 26.519 / npm 0.133.0. הוא פועל באמצעות שתי תבניות הנחיה — `continuation.md` („המשך”) ו-`budget_limit.md` („עצור”). היעד משויך לשרשור ונשמר אחרי הפעלה מחדש.

</div>

הפקודה נראית כמו זו שב-Claude:

```bash
codex
> /goal all vitest tests pass and there are no eslint errors
```

Codex מציע בקרות יעד נוספות:

| פקודה | מה היא עושה |
|-----------------|---------------------------|
| `/goal condition` | הגדרת יעד |
| `/goal` | הצגת המצב |
| `/goal pause` | השהיה |
| `/goal resume` | חידוש |
| `/goal edit` | שינוי התנאי (עם GA) |
| `/goal clear` | ניקוי היעד |

ההבדל העיקרי מ-Claude הוא ש-Codex עצמו בודק אם הוא „סיים”, במקום מודל נפרד. אחרי כל תור, Codex מוסיף אוטומטית להקשר את התבנית `continuation.md` ממאגר `openai/codex`. תרגום מילולי:

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

כשהטוקנים מתקרבים למגבלה, מתווספת תבנית שנייה — `budget_limit.md`:

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

ההיגיון זהה: „אל תשקר לגבי מה שעשית”. יש להמשיך רק אם היעד עדיין לא הושג בפועל. `budget_limit` דורשת לעצור, אבל לתאר בכנות מה נותר.

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

## במה שונה `/goal` ב-Claude Code מ-`/goal` ב-Codex?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

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

</div>

זהו הפער הנפוץ ביותר בהשוואות, אז נבחן אותו בפירוט.

| היבט | Claude Code `/goal` | Codex `/goal` |
|----|----|----|
| השקה | v2.1.139, 11 במאי 2026 | v0.128.0, 30 באפריל 2026 (ניסיונית) → v0.133.0 / 26.519, 21 במאי 2026 (יציבה) |
| היקף היעד | הפעלה | שרשור (נשמר אחרי הפעלות מחדש) |
| בקרות | `set`, `clear` (+ כינויים) | `set`, `view`, `pause`, `resume`, `edit`, `clear` |
| מי בודק אם „הושלם” | מודל נפרד (Haiku כברירת מחדל) | אותו סוכן, באמצעות הנחיה שנוספה |
| גישת המעריך לקבצים | לא; הוא שופט רק על סמך טקסט השיחה | כן; הוא יכול לבדוק קבצים, בדיקות ויומנים |
| תקציב | בטקסט התנאי: „או לעצור אחרי 20 תורים” | מגבלת טוקנים מובנית + הוספה אוטומטית של `budget_limit.md` |
| תקרת הוצאה קשיחה | אין; מגבלת המנוי בלבד | אין; מגבלת המנוי בלבד |
| אורך התנאי | עד 4,000 תווים | לא צוין |
| היכן הוא פועל | מצב אינטראקטיבי, `-p`, יישום שולחני, Remote Control | יישום, הרחבת IDE, CLI, לקוחות ACP |

ההבדל הרעיוני הוא ש-Claude מתייחס ללולאה כחוזה איכות (מעריך חיצוני), ואילו Codex מתייחס אליה כמנגנון ביצוע (הסוכן מנהל את עצמו).

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

מידע נוסף על הכלים עצמם נמצא ב[מדריך ההשוואה בין Codex ל-Claude Code](https://ailoot.ai/blog/he/codex-vs-claude-code-choice/).

## דוגמה מהעולם האמיתי: העברה מ-Pydantic v1 ל-v2 בתוך 31 שעות

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

`/goal` ב-Codex השלימה העברה של 14,000 שורות בשירות פנימי מ-Pydantic v1 ל-v2 בתוך 31 שעות בזמן אמת, שחולקו על פני ארבע הפעלות. העלות הייתה כ-$44 באמצעות gpt-5.3-codex.

</div>

המשימה הוגדרה כך: „העבר מ-Pydantic v1 ל-v2, כל בדיקות pytest חייבות לעבור, ו-mypy strict חייב לדווח על אפס שגיאות.”

מה קרה:

- הפעלה 1 (8 שעות) — Codex ניתח את הייבואים, שכתב הצהרות `BaseModel` והגדיר את mypy
- הפעלה 2 (10 שעות) — שכתב ולידטורים והכשיל כ-200 בדיקות
- הפעלה 3 (7 שעות) — תיקן את הבדיקות ומצא תלויות מעגליות
- הפעלה 4 (6 שעות) — פתר את שגיאות mypy והרגרסיות שנותרו

עלות הטוקנים:

> „הזמן הכולל על השעון: כ-31 שעות בארבע הפעלות. העלות הכוללת של טוקני Codex לפי התעריפים של gpt-5.3-codex: כ-$44.”

עיקר העלות נובע מטוקני הפלט של gpt-5.3-codex, בתעריף של $14 למיליון. פירוש הדבר הוא ש-31 שעות של עבודה אוטונומית עולות בערך כמו מנוי ChatGPT Plus למשך שבועות.

מה הסוכן לא עשה בעצמו:

- הוא לא כתב תיעוד העברה לצוות (Codex לא הבין שזה חלק מה„העברה”)
- הוא לא עדכן קובצי תצורה לפרסום עם גרסת Pydantic החדשה
- הוא פספס רגרסיה אחת בייצור, שהתגלתה רק יום לאחר מכן

כלומר, `/goal` ביצעה 95% מהעבודה; את 5% הנותרים עדיין צריך לעשות ידנית. זה נורמלי בדור הנוכחי, ואין סיבה לא להשתמש בה.

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

## 14 שעות בלילה על מנהל התקן ל-macOS

## אילו משימות מתאימות לריצות לילה ארוכות

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

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

</div>

זו הייתה אחת הריצות הציבוריות הראשונות שהפכו את `/goal` לפופולרית בקרב משקיעים. אנדרו צ'ן הגדיר את התנאי, הלך לישון, ובבוקר גילה ש-Codex עבר כמה סבבי איתור ותיקון באגים, הוסיף בדיקות, שכתב חלקים משפת Assembly ועדיין עבד.

סוגי המשימות שבהן השיטה הזאת מניבה את הרווח הגדול ביותר:

- עבודה ברמה נמוכה, שבה איטרציה ובדיקה אורכות דקות (קומפילציה, הרצת בדיקות)
- העברות עם קריטריונים פורמליים ברורים (טיפוסים, בדיקות, lint)
- בדיקות ביצועים ואופטימיזציות עם תוצאות מדידות
- תיעוד ויומני שינויים עם מבנה ברור

`/goal` של Claude עושה זאת היטב באותה מידה, אבל לעיתים קרובות יותר בוחרים ב-Codex עבור מנהלי התקנים, משום שהוא בודק קבצים ויומנים בעצמו במקום להסתמך על שופט חיצוני.

## כמה זה עולה, ואיך מונעים בזבוז טוקנים במשך הלילה?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

ל-`/goal` אין תקרת הוצאה עליונה קשיחה — יש רק את מגבלות התוכנית שלכם. שעת עבודה אמיתית של Codex עולה כ-$1.50–$3 עם gpt-5.3-codex. הפעלת Claude עולה יותר, והערכתו עולה פחות. אמצעי ההגנה היחיד הוא לכתוב „או לעצור אחרי N תורים” בתוך התנאי עצמו.

</div>

נתונים מחשבונות ציבוריים:

| ריצה | משך | טוקנים | עלות |
|----|----|----|----|
| הדגמת כלי התכנון של OpenAI | 25 שעות | 13M | (ריצה פנימית) |
| Pydantic v1→v2 | 31 שעות, 4 הפעלות | <bdi>~3.1M</bdi> פלט | ~\$44 |
| מערכת ראיונות קוליים | 6 שעות ו-44 דקות בסך הכול (41 דקות חישוב) | 6.8 מיליון קלט, 94% במטמון | \- |
| בדיקת עשן של גופנים | 5 דקות | 188,832 | פחות מ-5% מהמכסה השבועית |

העיקר להבין: Claude Code וגם Codex אינם מספקים מגבלה קשיחה של „הפסק להוציא כסף ב-$N”. יש שלושה אמצעי הגנה:

1.  **מגבלות המנוי** — Pro, Max או Enterprise. בתוכנית Max של Anthropic ($100 לחודש), ריצה לילית של 14 שעות נכנסת למכסה השבועית ומשאירה עודף
2.  **מגבלת טקסט בתנאי** — כתבו „או לעצור אחרי 20 תורים” ישירות ב-`/goal`. השופט של Claude יקרא זאת ויסגור את היעד
3.  **מגבלת טוקנים ב-Codex** — מנגנון מובנה שמוסיף את `budget_limit.md` כשנגמרים הטוקנים

מה מגדיל את החשבון במשך הלילה:

- קריטריון מעורפל כמו „הפוך את זה לנוח יותר” — הסוכן לעולם לא יעצור, כי המעריך אינו יודע מה פירוש „טוב יותר”
- גישה לממשקי API חיצוניים ללא תחליפים — כל ניסיון חוזר עולה טוקנים
- הקשר ארוך — לאחר 6.7M טוקנים, דחיסת הקשר מתחילה וחלק מהזיכרון אובד

קראו עוד על חיסכון בעלויות במדריכים [לאן הולכים הטוקנים של Claude Code](https://ailoot.ai/blog/he/where-claude-code-tokens-go/) ו[איך לא לשרוף את המכסות שלכם](https://ailoot.ai/blog/he/claude-code-token-limits-saving/).

## מתי לא להפעיל `/goal`: 5 מצבים

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

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

</div>

התיעוד של OpenAI אומר במפורש מה לא לעשות:

1.  **עריכות של שורה אחת** — הפעלת `/goal` כדי לשנות שם של משתנה עולה יותר מעשיית זאת ידנית
2.  **יעדים מעורפלים** — „שפר את הביצועים”, „נקה את הקוד”, „הפוך את זה לנוח יותר”. למעריך אין קריטריון, ולכן הסוכן יסתובב בלולאה בלי סוף
3.  **מסדי נתונים בייצור עם נתוני משתמשים** — הסוכן עלול לשבש העברה, ושחזור מגיבוי עולה יותר מכל חיסכון
4.  **שינויים באבטחה** — אימות, הצפנה, עיבוד תשלומים. כאן אדם צריך לבדוק כל commit
5.  **ממשקי API חיצוניים ללא תחליפים** — כל כשל רשת עולה טוקנים ואינו בשליטתכם



## מה לעשות אם הסוכן נתקע?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

סימן ללולאה הוא שהסוכן עורך את אותו מקום במשך 3–4 תורים ואז מחזיר את השינוי לאחור. עצרו אותו באמצעות Ctrl+C, בדקו את היומן, ואז הקשיחו את הקריטריון או צמצמו את המשימה לחלק אחד. ב-Claude, `/goal clear` עוזרת; ב-Codex, השתמשו ב-`/goal pause` וערכו את התנאי.

</div>

איך לזהות במהירות לולאה:

- הסוכן נוגע באותם קבצים במשך <bdi>3+</bdi> תורים ומחזיר אותם למצבם הקודם
- ביומן מופיעות שוב ושוב שגיאות שכבר הגיב להן
- התנאי נראה לכם כמקיים, אבל הסוכן אומר „לא מתקיים”
- השימוש בטוקנים בכל תור עולה, אך אין התקדמות בקוד

מה לעשות עכשיו:

- ב-Claude Code: הפעילו `/goal clear`, ואז הפכו את התנאי למפורט יותר
- ב-Codex: הפעילו `/goal pause`, בדקו את השרשור הנוכחי, ערכו את התנאי עם `/goal edit`, ואז הפעילו `/goal resume`
- בשניהם: ודאו שאכן אפשר לאמת את הקריטריון (פקודה מחזירה exit 0 או מפיקה פלט מסוים)

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

## קריטריונים ל„הושלם”: משמעת משימות עבור `/goal`

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Key takeaways">

הנקודות המרכזיות

קריטריון טוב הוא פקודה שמחזירה exit 0 או פלט מסוים. „כל הבדיקות עברו” עובד. „הקוד נקי יותר” לא. עדיף לשלב בדיקה רשמית עם מדד מדיד — למשל, בדיקות בתוספת כיסוי מינימלי.

</div>

OpenAI מציינת את הכלל הזה בבירור בספר הבישול הרשמי של Codex:

<figure>
<blockquote>
<p>יעד אינו נחשב להושלם רק משום שהמודל חושב כך. יעד הושלם רק לאחר שהתוצאה נבדקה מול קבצים, בדיקות, יומנים, בדיקות ביצועים או תוצרים מוחשיים אחרים.</p>
</blockquote>
<figcaption>— ספר הבישול של OpenAI Codex, שימוש ביעדים ב-Codex, https://developers.openai.com/cookbook/examples/codex/using_goals_in_codex</figcaption>
</figure>

תבניות קריטריון שעובדות בפועל:

| סוג קריטריון | איך לנסח אותו |
|----|----|
| בדיקות | “pytest tests/ מחזירה exit 0 והכיסוי הוא לפחות 80%” |
| טיפוסים | “mypy strict מדווח על אפס שגיאות ב-src/” |
| Lint | “eslint . מחזירה exit 0 בכל הקבצים ששונו” |
| Build | “npm run build מסתיים בהצלחה, ללא שגיאות TypeScript” |
| בדיקת ביצועים | “k6 run perf test מציג p95 מתחת ל-200 ms” |
| Diff | “git diff מציג שינויים רק בקבצים X, Y, Z” |
| שילוב | “pytest ירוקה וגם mypy strict מדווח על אפס שגיאות וגם ruff check עובר” |

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

דפוסים שיש להימנע מהם:

- „הקוד טוב יותר”
- „השימושיות השתפרה”
- „הביצועים השתפרו”
- „התיעוד הושלם”

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

אפשר לבדוק את הרעיון של „הנחיה אחת — תוצאה אחת” בפרויקט אמיתי: הגדירו `/goal`, נסחו קריטריון, הריצו אותה ונתחו מה השתבש.

<div class="section" role="doc-bibliography" aria-label="Sources">

### מקורות

- [תיעוד `/goal` של Claude Code (Anthropic)](https://code.claude.com/docs/en/goal)
- [יומן השינויים של Claude Code (Anthropic)](https://code.claude.com/docs/en/changelog)
- [יומן השינויים של OpenAI Codex](https://developers.openai.com/codex/changelog)
- [ספר הבישול של OpenAI Codex: שימוש ביעדים](https://developers.openai.com/cookbook/examples/codex/using_goals_in_codex)
- [הבלוג של OpenAI: הפעלת משימות ארוכות טווח עם Codex (23 בפברואר 2026)](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex)
- [GitHub openai/codex: continuation.md](https://github.com/openai/codex/blob/6014b6679ffbd92eeddffa3ad7b4402be6a7fefe/codex-rs/core/templates/goals/continuation.md)
- [GitHub openai/codex: budget_limit.md](https://github.com/openai/codex/blob/6014b6679ffbd92eeddffa3ad7b4402be6a7fefe/codex-rs/core/templates/goals/budget_limit.md)

</div>



הכירו את [Ailoot](https://ailoot.ai/).

## שאלות ותשובות: איך להפעיל את Claude Code ואת Codex למשך הלילה באמצעות /goal בשנת 2026: מצב אוטונומי של 14 שעות

### מה הופך קריטריון השלמה של /goal לשימושי?

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

### מה לעשות כשהסוכן חוזר על אותן עריכות כושלות?

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


## Ailoot · החברה ופורטפוליו הפרויקטים שלה

Ailoot נשענת על ניסיון תפעולי מצטבר, בסיס לקוחות רחב, שירות יציב ובקרה שוטפת של KPI.

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

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