Claude Code לאורך הלילה: הנדסת לולאות ו-Ralph Loop ב-2026

תיעוד העזר של Ailoot: ailoot.ai/docs/.

מהי הנדסת לולאות, ולמה זה צריך לעניין אתכם?#

אדי אוסמני, מנהל AI ב-Google Cloud (לאחר 14 שנים בצוות Chrome), הציג את העיקרון בפוסט מ-7 ביוני 2026:

באותו פוסט הוא מצטט ציוץ ויראלי של פיטר שטיינברגר (8 ביוני 2026):

שמונה חודשים בלי כתיבת קוד ביד. כל Claude Code, שבו אתם עובדים כרגע, נכתב על ידי Claude Code עצמו — בלולאות שצ'רני בנה.

וההצהרה השנייה מסבירה את ההיקף:

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

ארטמי מילר מתאר את הגישה שלו כ„להביא דברים לידי ביצוע”. הרעיון המרכזי הוא:

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

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

במה Ralph Loop שונה מבקשה רגילה ל-Claude Code#

הטכניקה נקראת על שם ראלף ויגם מ-משפחת סימפסון — דמות הידועה בהתמדה העליזה שלה למרות טעויותיה. ג'פרי האנטלי הגה אותה ב-14 ביולי 2025 כלולאת bash פשוטה סביב סוכן:

הקוד המקורי שהתחיל את כל הגל:

while :; do cat PROMPT.md | claude-code ; done

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

Anthropic ארזה את אותה הלוגיקה בתוסף ralph-loop ובפקודות /loop, /goal ו-/batch ב-Claude Code — הן זמינות ישירות בטרמינל בלי סקריפטים. עצם העובדה ש-Anthropic פרסמה תוסף להנחיה חוזרת אינסופית עוררה דיון ב-GitHub Issue #23084 בשאלה אם הדבר הוגן כלפי המודל. הדיון עדיין פתוח; התוסף עובד.

שלוש פקודות מובנות ב-Claude Code: /loop, /goal, /batch#

/goal היא הפקודה הדומה ביותר ל-Ralph Loop. מתחת למכסה המנוע, מודל מעריך (Haiku כברירת מחדל) בודק בכל תור אם היעד הושג. אם לא, האיטרציה הבאה כוללת רמז לגבי מה בדיוק צריך לתקן. אם כן, היא נעצרת. פירטתי את /goal במדריך על הפעלת Claude Code באופן אוטונומי לאורך הלילה עם /goal — הוא כולל תרחישים מוכנים לשימוש ל-14 שעות עבודה.

/batch היא פקודה נדירה אך רבת עוצמה. כשצריך לבצע אותו שינוי ביותר מ-100 קבצים (העברת API, החלפת רכיבים, שינוי שמות), /batch שולחת כל קובץ לתת-סוכן נפרד ב-git worktree משלו. השינויים אינם מתנגשים — כל סוכן עובד בעותק מבודד. מידע נוסף על תת-סוכנים מופיע במדריך על תת-סוכנים מקוננים.

בתיאור הגישה של המחבר, קוראים לכך פשוט:

המגבלות הקשיחות של /loop ו-/goal:

• משימה פועלת כל עוד Claude Code פתוח. סגרו את הטרמינל והלולאה נעצרת. למחזור לילה רציני, השתמשו בשרת מרוחק או במעטפת shell משלכם.
• משך החיים המרבי של משימה חוזרת הוא 7 ימים (לאחר מכן היא נמחקת אוטומטית כהגנה מפני לולאות שנשכחו).
• עד 50 משימות בו-זמנית בפעילות אחת.

רוצים לבנות מערך שיהפוך את Claude לאמין? Ralph Loop הוא רק חלק אחד ממנו. כדאי להתייחס לכל שלושת הרכיבים: שכפול AI + מוח שני + הנדסת הקשר — השילוב הזה הופך את Claude מ„עוזר שממציא דברים” לכלי שאפשר לתת לו משימה ואז להמשיך בענייניכם.

איך להפעיל את הלולאה האוטונומית הראשונה שלכם בתוך 5 דקות#

5 שלבים:

1. פתחו את הפרויקט ב-Claude Code

   עברו לשורש הפרויקט בטרמינל והריצו claude. המתינו עד ש-Claude יקרא את CLAUDE.md ויצור אינדקס של המאגר.

2. הגדירו יעד ותנאי עצירה

   היעד הוא מה שצריך לבצע. תנאי העצירה הוא הדרך שבה Claude יידע שסיים. רצוי שזה יהיה פקודה שמחזירה 0 או 1. דוגמה: „יעד: כל 23 הבדיקות ב-tests/api/*.test.ts עוברות. עוצרים כאשר pnpm test מחזירה קוד יציאה 0.”

3. הריצו /goal

   פקודה:

   /goal All tests in tests/api/*.test.ts must pass. Run pnpm test, read the errors, fix them, and run it again. Stop when the exit code = 0. Maximum 20 iterations.
   

   Claude מתחיל את הלולאה: מריץ בדיקות — מזהה כישלון — פותח קובץ — מתקן אותו — מריץ אותן שוב.

4. הגדירו תקרת תקציב

   בלשונית רקע, השתמשו ב-/usage כדי לעקוב אחר השימוש. הגדירו מגבלת טוקנים או כסף יומית כדי שלא תשרפו את כל היתרה בלולאה אחת. פרטים נוספים במדריך על איך לא לשרוף את מגבלות Claude Code.

5. המשיכו בענייניכם

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

תבנית המאמת: איך Claude בודק את העבודה שלו בלולאה#

יש שלושה סוגי מאמתים:

1. טכני (קוד יציאה) — האמין ביותר. pnpm test, npm run lint, tsc --noEmit, playwright test. הם מחזירים 0 או 1, בלי צורך בפרשנות. גם /goal פועלת כך — מתחת למכסה המנוע היא משתמשת במודל המעריך Haiku, שבודק בכל תור אם התנאי התקיים (עד 4000 תווים).

2. מודל מעריך — מודל שני בוחן את תוצאת המודל הראשון ומדרג אותה לפי מחוון. מתאים למשימות ללא בדיקה פורמלית („האם סגנון הכתיבה טוב?” „האם העיצוב תואם למותג?”). ב-Anthropic זה נקרא Claude Code Review — מצב שבו סוכן ביקורת נפרד מחפש שגיאות לוגיות, מקרי קצה ובעיות אבטחה בעבודת הסוכן הראשי. לפי נתונים פנימיים של Anthropic, הוא מוצא 84% מהבעיות בבקשות משיכה גדולות (לעומת 16% בגישת הבסיס).

3. בדיקה מותאמת אישית — סקריפט shell שאתם כותבים בעצמכם. „אם אין במקורות המילה ERROR, המשימה הושלמה.” „אם הקובץ output.json קיים וניתן לניתוח, המשימה הושלמה.” „אם הדף /pricing מחזיר 200, המשימה הושלמה.”

בגישה של המחבר, המיומנויות כוללות שלב ביקורתי נפרד עבור Claude אחרי כל שלב. הנה תבנית הנחיה שהכנסתי ל-CLAUDE.md או לפקודה:

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

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

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

איך לא לשרוף אלפי דולרים במהלך הלילה: תקרות תקציב ותנאי עצירה#

שלושה מעצורים חיוניים לכל לולאת לילה:

1. מגבלת איטרציות. --max-iterations 20. הלולאה לא יכולה לפעול יותר מ-N פעמים — גם אם המאמת לא הופעל. אם תנאי העצירה לא התקיים לאחר 20 איטרציות, המשימה תקועה ודורשת התערבות אנושית.

2. מגבלת טוקנים או כסף. /usage limit 50 — לא יותר מ-$50 ביום. כשהלולאה מתקרבת למגבלה, היא נעצרת בעצמה ושולחת התראה. כך נמנע תרחיש של הוצאה בלתי נשלטת.

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

מבנה מעטפת להמחשה עם שלוש הבדיקות האלה. שורות דיווח העלות והפעלת הסוכן הן דוגמאות שתלויות במריץ, ולא מתכון התקנה מאומת ל-CLI; אשרו את הממשקים בגרסה המותקנת לפני התאמה. בבדיקת התקדמות מבוססת commits, דרשו commit מקומי של נקודת ביקורת בכל איטרציה שמשנה קוד. אם המריץ משאיר עריכות ללא commit, עצרו לבדיקה במקום לתייג אותן כ״אין התקדמות״.

#!/bin/bash
PROMPT="$1"
MAX_ITER=20
MAX_COST_USD=50
COMPLETION="DONE"
PREV_HASH=""
STAGNATION=0

for i in $(seq 1 $MAX_ITER); do
  # מגבלת כסף
  CURRENT_COST=$(claude usage --json | jq '.cost_usd')
  if (( $(echo "$CURRENT_COST > $MAX_COST_USD" | bc -l) )); then
    echo "STOP: הגבלת תקציב $MAX_COST_USD הושגה"
    break
  fi

  # הפעלה
  OUTPUT=$(claude code -p "$PROMPT" --auto-accept)

  # בדיקת השלמה
  if echo "$OUTPUT" | grep -q "$COMPLETION"; then
    echo "STOP: אות השלמה"
    break
  fi

  # התקדמות commits בלבד: כל איטרציה שמשנה קוד חייבת לשמור commit של נקודת ביקורת.
  # HEAD אינו מזהה עריכות מועילות שטרם נשמרו ב-commit.
  CURRENT_HASH=$(git rev-parse HEAD 2>/dev/null)
  if [ "$CURRENT_HASH" = "$PREV_HASH" ]; then
    STAGNATION=$((STAGNATION + 1))
    if [ "$STAGNATION" -ge 3 ]; then
      echo "STOP: תקיעות במשך 3 איטרציות"
      break
    fi
  else
    STAGNATION=0
  fi
  PREV_HASH="$CURRENT_HASH"
done

אמתו את בדיקת ההתקדמות לפני הרחבת השלד: עריכה ללא commit חייבת להיחשב עבודה שלא תועדה; commit של נקודת ביקורת משנה את HEAD; ורק המאמת הנפרד יכול להוכיח הצלחה. שלוש השוואות רצופות של אותו commit מצביעות על היעדר שינויים מתועדים לפי ההסכם שנקבע, ולא מוכיחות שכל קובצי העבודה נשארו ללא שינוי. בהמשך אפשר להוסיף: התראת Slack בעת עצירה, דוח אוטומטי ב-Telegram בבוקר, או הודעת push כשהתקציב מגיע ל-80%. העיקרון זהה: לולאה זקוקה למעצורים, לא רק למאיץ.

5 תרחישים מוכנים לשימוש בלולאות לילה#

תרחיש 1: הפיכת בדיקות שנכשלות לירוקות

/goal יש 47 בדיקות שנכשלות בספריית tests/. היעד: להעביר את כולן.
הריצו pnpm test, קראו את stderr, פתחו את הקובץ עם השגיאה, תקנו אותו והריצו שוב pnpm test.
עצרו כשהקוד הוא 0. לכל היותר 30 איטרציות.

תרחיש 2: שכתוב גדול ב-200 קבצים

/batch החליפו את לקוח ה-API הישן apiV1 ב-apiV2 החדש בכל הקבצים תחת src/**/*.ts.
לכל קובץ יהיה worktree משלו. לאחר ההחלפה, הריצו tsc --noEmit; תקנו שגיאות כלשהן.
מזגו את ה-worktrees בסוף.

תרחיש 3: ניטור סביבת ייצור לאורך הלילה

/loop 30m כל 30 דקות, בדקו את https://your-app.example.com/api/health.
אם הוא לא מחזיר 200, קראו את היומנים, מצאו את הסיבה, תקנו אותה ופרסו מחדש.
תעדו כל איטרציה ב-/tmp/night-monitor.log.

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

/goal ייבאו את קובץ ה-CSV /tmp/import.csv (12,000 שורות) לטבלת clients.
לכל שורה, בדקו אם קיימת כפילות לפי כתובת אימייל; אם אין, הוסיפו אותה; אם יש, עדכנו אותה.
תעדו התנגשויות ב-/tmp/conflicts.log. עצרו כשעובדה השורה האחרונה.

תרחיש 5: צינור מאמרים (מערך טיפוסי)

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

/loop 8h כל 8 שעות: פתחו את קובץ המשימות הממתינות לנושאים עם הסטטוס 'queued'.
אם יש נושא זמין, הפעילו את המיומנות לכתיבת מדריך.
פרסמו בסביבת הפיתוח. שנו את הסטטוס ל-'review'. הודיעו לאדם האחראי ב-Telegram.

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

מה לספק בכל איטרציה: CLAUDE.md והמוח השני כמצב#

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

1. CLAUDE.md — חוקת הפרויקט. מהו המוצר, מהי סביבת הפיתוח, מהם הכללים ומה אסור לעשות בשום אופן. Claude קורא את הקובץ הזה כשהוא מתחיל כל פעילות וכל איטרציה של הלולאה. בלעדיו, Claude צריך „לפתוח מחדש” את הפרויקט בכל פעם — לבזבז הקשר ולהגדיל את הסיכון להזיות. תמצאו תבנית מוכנה ו-6 כללים במדריך CLAUDE.md.

כך עושה זאת בוריס צ'רני:

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

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

העיקרון התפעולי המרכזי שהייתי צריך להטמיע דרך טעויות:

שלוש השכבות האלה הן שלושת עמודי התווך של המתודולוגיה: שכפול AI (לימדתם את Claude את הסגנון והכללים שלכם באמצעות מיומנויות ו-CLAUDE.md), מוח שני (המשמעות העסקית שבקבצים) והנדסת הקשר (מה שאתם מספקים בכל בקשה). בלי שלושתם, הלולאה הופכת למעגל אינסופי עם חשבון הולך וגדל.

מה בוריס צ'רני עושה בלילה: 5 טרמינלים, 10–15 פעילויות, אלפי סוכנים#

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

המסגור מחדש המרכזי:

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

עבור יזם ללא מתכנתים, המשמעות מעשית. יש לכם חשבון Claude אחד ב-$200 לחודש ומחשב נייד רגיל. אפשר להפעיל 5 לולאות במקביל — תמיכה, מאמרים, מדדים, בדיקת מוצר חדש ומעקב אחר מתחרים. כל אחת פועלת בלשונית Claude Code משלה. בבוקר אתם קוראים את הסיכום. זו כבר נורמת העבודה בקיץ 2026.

ארבע תקלות נפוצות בלולאות אוטונומיות#

כשל 1: „לולאת הזיות”

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

תיקון: מאמת קשיח (הפקודה exit code), לא בדיקה מילולית.

כשל 2: „התקציב נשרף במהלך הלילה”

בלי תקרת תקציב, לולאה היא רימון ללא נצרה.

תיקון: /usage limit או סקריפט חיצוני שמשתמש ב-claude usage --json כדי לעצור את הלולאה כשהיא מגיעה לסף.

כשל 3: „הלולאה איבדה את ההקשר בין איטרציות”

באיטרציה 1, Claude קיבל החלטה ארכיטקטונית. באיטרציה 7 הוא שכח אותה והחליט את ההפך. אחרי 15 איטרציות, הקוד הוא ערימה מבולגנת.

תיקון: שכבת מצב באמצעות CLAUDE.md ותיקיית המוח השני. הלולאה כותבת כל החלטה ארכיטקטונית לקובץ שהיא קוראת באיטרציה הבאה.

כשל 4: „תנאי העצירה אינו מדויק — הלולאה פועלת לנצח”

/goal "Make the page beautiful" — מה פירוש „יפה”? בלי מדד חד-משמעי, הלולאה לא תעצור לעולם. היא תמשיך לפעול עד שתגיע למגבלת האיטרציות או התקציב.

תיקון: תנאי העצירה חייב תמיד להיות מדיד. לא „יפה”, אלא „Lighthouse Performance ≥ 90, Accessibility ≥ 95”. לא „עובד”, אלא „הבדיקות ב-tests/pricing.test.ts עוברות”.

מתי אין צורך בהנדסת לולאות#

המשימות הבאות אינן מתאימות ללולאה אוטונומית:

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

והכלל המרכזי שלמדתי דרך טעויות:

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

הנדסת לולאות היא שכבה מעל כל מה שאתם כבר יודעים על Claude Code. קודם כול דרושים שלושת עמודי התווך: שכפול AI + מוח שני + הנדסת הקשר. בלעדיהם, הלולאה מידרדרת עד איטרציה 5. המשיכו להכיר את Ailoot ב-ailoot.ai.