SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor · עודכן 2026-10-26

מדוע סוכני תכנות מתעלמים מההנחיות שלך?

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

מדוע סוכני תכנות מתעלמים מההנחיות שלך

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

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

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

קובץ ההנחיות שלכם הוא הודעה, לא הגדרה

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

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

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

אילו קובצי הנחיות נטענים ומתי

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

קבצים בספריות משנה מתחת לספריית העבודה שלך מתנהגים אחרת. הם אינם נטענים בעת ההפעלה. הם נטענים כאשר הסוכן קורא קובץ באותה ספרייה. כך גם לגבי חוקים מוגבלי נתיב ב-.claude/rules/ המכילים שדה frontmatter מסוג paths:: הם נכנסים להקשר כאשר נקרא קובץ תואם, ולא בכל שלב. החל מגרסה v2.1.309, לקבצים הנטענים בדרך זו יש גם מגבלת גודל לכל קובץ (40,000 תווים בחלון הקשר של 200K), והסוכן מקבל רק את תחילתו של קובץ ארוך, לכן חוקים המופיעים בסוף קובץ מקונן גדול עלולים לעולם לא להגיע להקשר.

הבדל יחיד זה מסביר חלק גדול מהכשלים המדווחים. אתה מציב חוק ב-packages/api/CLAUDE.md, שואל שאלה על ה-API, והסוכן עונה מבלי לפתוח אף קובץ תחת packages/api/. החוק לא התעלם; הוא פשוט מעולם לא היה נוכח. אם המאגר שלך מפצל הנחיות בין קובצי הנחיות לכל חבילה ב-monorepo, זה הדבר הראשון שיש לבדוק, בכל פעם.

מלכודת טעינה נוספת משפיעה על מאגרים שסטנדרטיזציה שלהם מבוססת על AGENTS.md. החל מגרסה v2.1.277, Claude Code קורא את AGENTS.md כהנחיות הפרויקט שלך כברירת מחדל, אך רק כאשר אין CLAUDE.md, .claude/CLAUDE.md או CLAUDE.local.md בספריית העבודה שלך או בכל ספרייה מעליה (ה-~/.claude/CLAUDE.md האישי שלך אינו נחשב). הוספת אחד מאלה, אפילו CLAUDE.local.md להערות אישיות, גורמת ל-Claude Code לקרוא את קובצי ה-CLAUDE.md שלך במקום זאת ולהתעלם לחלוטין מ-AGENTS.md. כדי לטעון את שניהם, הגדר את Project instructions ל-claude-md-and-agents-md ב-/config. בגרסאות שלפני v2.1.277, או כאשר ברצונך לשמור על CLAUDE.md, הגישור מתבצע באמצעות CLAUDE.md שהשורה הראשונה שלו היא @AGENTS.md, המייבא את הקובץ בעת ההפעלה, עם כל הערה ספציפית ל-Claude מתחתיו. גם קישור סימבולי (symlink) יעבוד כאשר אין לך מה להוסיף. ההחלטה מה שייך לקובץ זה מלכתחילה היא שאלה נפרדת, המכוסה ב-הפרדת הנחיות סוכן מתיעוד אנושי.

אימות טעינת הקובץ לפני שכתובו

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

הריצו את /context בתוך הסשן. הפקודה מציגה את החלון הנוכחי בחלוקה לקטגוריות, והרשימה Memory files מפרטת את כל קובצי ההוראות שנטענו בעת ההפעלה. קובץ שאינו מופיע ברשימה זו לא נטען בעת ההפעלה, ולכן לכל שינוי שתבצעו בו לא תהיה השפעה עד שגורם כלשהו יטען אותו. קובץ מקונן בתיקיית משנה לעולם לא יופיע שם, כיוון שהוא נטען לפי דרישה; כאשר הוא נטען, שורת Loaded הכוללת את הנתיב שלו מופיעה בטרמינל. /memory מציגה את מיקומי הקבצים ופותחת אותם לעריכה, כולל קבצים שטרם נוצרו.

לקבלת תשובה מפורטת יותר, תעדו את הטעינות. אירוע ה-hook מסוג InstructionsLoaded מופעל בכל פעם שקובץ CLAUDE.md או קובץ חוקים נכנס להקשר, וה-matcher שלו יציין את סיבת הטעינה: session_start, nested_traversal, path_glob_match, include או compact. הוסיפו זאת ל-.claude/settings.json:

{
  "hooks": {
    "InstructionsLoaded": [
      {
        "matcher": "nested_traversal",
        "hooks": [
          {
            "type": "command",
            "command": "cat >> /tmp/instructions-loaded.log"
          }
        ]
      }
    ]
  }
}

ה-hook מקבל את המידע שלו כ-JSON דרך הקלט הסטנדרטי, לכן cat מצרפת את הרשומה המלאה. עקבו אחר הפלט באמצעות tail -f /tmp/instructions-loaded.log בזמן העבודה. סטטוס היציאה של אירוע זה אינו נלקח בחשבון, כך שה-hook יכול רק לצפות, אך לא לחסום. אם הקובץ המקונן שלכם לעולם לא מופיע בלוג במהלך סשן שבו ציפיתם לראותו, הפסיקו את עריכת התוכן. הבעיה היא במיקום הקובץ. חריג אחד: קובץ AGENTS.md ש-Claude Code קורא ישירות אינו מפעיל אירוע זה, לכן חפשו את הנתיב שלו ב-/memory במקום זאת. קובץ AGENTS.md המיובא מתוך CLAUDE.md מפעיל את האירוע כרגיל.

השפעת סשן ארוך על הכללים שלכם

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

מרחק. עד להרצת דחיסה (compaction), כלל שהוגדר בתור 1 עדיין נמצא בתוך ה-window בתור 90, אך כעת הוא מתחרה ב-90 תורות של טקסט עדכני וספציפי יותר למה שאתם עושים כרגע. לאחר הרצת דחיסה, כלל שהקלדתם בצ'אט בלבד עלול שלא להימצא ב-window כלל: התיעוד של Claude Code מזהיר שהוראות מתחילת השיחה עלולות ללכת לאיבוד, וזו ההשפעה השנייה המפורטת מטה. לא ניתן להגדיר את המרחק, אך ניתן למדוד אותו. הריצו את אותה משימה בסשן חדש. אם הכלל נשמר שם אך נכשל עמוק בתוך סשן ארוך, המרחק או הדחיסה הם התשובה.

דחיסה. כאשר ה-window מתמלא, המנגנון מסכם את השיחה עד כה וממשיך מהסיכום הזה. מה ששורד הוא מה שהמסכם שפט כחשוב, וזה לא בהכרח מה שאתם מחשיבים כחשוב. Claude Code מתעד את התוצאה לפי מנגנון, וההבדלים גדולים. שורש הפרויקט CLAUDE.md וכללים ללא טווח (unscoped) מוזרקים מחדש מהדיסק לאחר דחיסה. זיכרון אוטומטי מוזרק מחדש מהדיסק. כללים עם frontmatter מסוג paths: הולכים לאיבוד עד לקריאה חוזרת של קובץ תואם. קובצי CLAUDE.md מקוננים בספריות משנה הולכים לאיבוד עד לקריאה חוזרת של קובץ באותה ספריית משנה.

דרגו את ההוראות שלכם לפי הטבלה הזו, וסדר השבריריות יתבהר. כלל שהקלדתם בצ'אט בלבד הוא הפריט השברירי ביותר בסשן: הוא נשמר רק אם הסיכום בחר להשאיר אותו. כלל בתוך packages/api/CLAUDE.md נמצא במקום הבא, כיוון שהוא נטען פעם אחת, סוכם החוצה, וחוזר רק בקריאה הבאה באותה ספרייה. כלל בקובץ שורש הפרויקט הוא העמיד ביותר, כיוון שהוא נקרא מחדש מהדיסק בכל פעם.

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

מדוע הקוד הקיים גובר על הכלל

זהו הכשל שאנשים מתארים בתדירות הגבוהה ביותר ומאבחנים בתדירות הנמוכה ביותר. הקובץ שלכם מציין שגישה למסד הנתונים עוברת דרך שכבת ה-repository. הסוכן כותב handler שקורא ל-ORM (מיפוי אובייקטיבי-יחסי) ישירות. לא התעלמו מכם משיקולי סגנון. הראיות הכריעו אתכם.

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

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

גישה חדשה למסד הנתונים עוברת דרך app/repositories/. קבצים תחת app/legacy/ עדיין קוראים ל-ORM ישירות. זהו קוד ישן, לא התבנית. אל תעתיקו אותו.

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

כלל מעורפל אינו ניתן לבדיקה, ולכן לא ניתן לציית לו

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

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

  • לא בר-בדיקה: "שמור על פונקציות קטנות." בר-בדיקה: "פונקציה שאורכה עולה על 60 שורות מחייבת הערה מעליה המסבירה את הסיבה לכך."
  • לא בר-בדיקה: "בדוק את השינויים שלך." בר-בדיקה: "הרץ את npm test והדבק את מספר הכשלים לפני הכרזה על סיום משימה."
  • לא בר-בדיקה: "שמור על קבצים מאורגנים." בר-בדיקה: "מטפלי HTTP נמצאים ב-src/api/handlers/. שום דבר אחר לא נכנס לספרייה זו."
  • לא בר-בדיקה: "עצב את הקוד כראוי." בר-בדיקה: "השתמש בהזחה של 2 רווחים בקובצי .ts."

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

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

כיצד לאבחן זאת בתוך עשר דקות

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

  1. ודאו שהקובץ נטען. הריצו את /context ועיינו ברשימת קובצי ה-Memory, או עבור קובץ מקונן, חפשו את שורת ה-Loaded שלו בטרמינל. אם הקובץ אינו שם, תקנו את המיקום ועצרו. שום דבר אחר ברשימה זו אינו רלוונטי עדיין.
  2. שחזרו את הבעיה בסשן חדש. התחילו סשן חדש ובצעו את המשימה הקטנה ביותר שאמורה להפעיל את החוק. אם הפעולה מצליחה כאן אך נכשלת בסשן ארוך, הבעיה נעוצה במרחק או בדחיסה (compaction). אם היא נכשלת גם כאן, הבעיה היא בחוק עצמו.
  3. הסירו גורמים מתחרים. בקשו את אותו השינוי בספרייה שבה הקוד הקיים כבר מציית לחוק. אם הציות חוזר, הקוד שמסביב "הצביע" נגד ההנחיה שלכם.
  4. חפשו התנגשות. שני קבצים שנותנים הנחיות שונות לאותה התנהגות הם כשל מתועד: המודל עשוי לבחור אחד מהם באופן שרירותי, והוא לא יודיע לכם על כך.
  5. הפכו את החוק לבדיק ובצעו בדיקה חוזרת. שכתבו את החוק עם נתיב קונקרטי ותנאי. קפיצה גדולה בציות מעידה על כך שהניסוח היה הגורם לבעיה.

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

grep -rni "migration" --include="CLAUDE.md" --include="CLAUDE.local.md" --include="AGENTS.md" .
grep -rni "migration" .claude/rules/ ~/.claude/CLAUDE.md ~/.claude/rules/ 2>/dev/null

מציאת התאמה בשני קבצים שאומרים דברים שונים היא הבאג שלכם. מחקו אחד מהם. אל תנסו לדרג אותם באמצעות ניסוח חזק יותר, כיוון שאין מנוע דירוג שניתן לפנות אליו. בגרסה Claude Code v2.1.283 ומעלה, /doctor prompt-audit מריץ גרסה רחבה יותר של חיפוש זה על פני קובצי ההנחיות, החוקים והכישורים שלכם, ומדווח על סתירות עם עריכות מוצעות מבלי לשנות דבר עד שתבקשו זאת.

התיקונים, לפי סדר השפעה

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

  1. הפכו את הכלל לקונקרטי. ציינו נתיב, פקודה או תנאי. הוסיפו את הראיות הנגדיות שהסוכן ימצא במאגר, כפי שהוצג קודם לכן. זה בחינם ומתקן חלק מפתיע מהמקרים.
  2. קרבו את הכלל למה שהוא מנהל. CLAUDE.md מקונן, כלל מוגבל נתיב בתוך .claude/rules/, או הערה בראש הקובץ עצמו. הכלל מגיע באותה קריאה של הקוד שעליו הוא חל. קבלו את הפשרה: כל מה שנטען בדרך זו נמחק בדחיסה הבאה וחוזר בקריאה התואמת הבאה.
  3. העבירו את האכיפה לתוך hook. פרוזה מבקשת. hook מחליט. hooks רצים כקוד באירועי מחזור חיים קבועים וחלים ללא קשר למה שהמודל מסיק.
  4. תנו את הכלל לכלי דטרמיניסטי ומחקו את הפרוזה. עיצוב, סדר ייבוא, אורך שורה, ייבואים אסורים, מבנה הודעת commit. ruff format, prettier --write, eslint, או hook מסוג pre-commit. המעצב (formatter) צודק בכל פעם ועולה אפס tokens. המשפט צודק ברוב הפעמים ועולה tokens בכל תור.

שלב 3 במלואו. נניח שקבצי הגירה (migration) לעולם לא צריכים להיערך על ידי הסוכן. הציבו זאת בתוך .claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/guard-migrations.sh"
          }
        ]
      }
    ]
  }
}

וזאת בתוך .claude/hooks/guard-migrations.sh:

#!/usr/bin/env bash
set -euo pipefail

path=$(jq -r '.tool_input.file_path // empty')

case "$path" in
  */migrations/*)
    echo "Files under migrations/ are written by hand. Stop and ask first." >&2
    exit 2
    ;;
esac

exit 0

הריצו את chmod +x .claude/hooks/guard-migrations.sh, לאחר מכן התחילו סשן חדש ובקשו מהסוכן לערוך קובץ תחת migrations/. העריכה תסורב וההודעה שלכם תחזור כסיבה. סטטוס יציאה 2 ב-PreToolUse חוסם את קריאת הכלי לפני שהיא רצה, וטקסט ה-stderr שלכם מועבר למודל כהודעת החסימה. ${CLAUDE_PROJECT_DIR} מתורגם לשורש הפרויקט, כך שה-hook עובד בכל ספרייה שבה הסוכן נמצא. הסוכן לא צריך להסכים עם הכלל, לזכור את הכלל, או להחזיק את הכלל בהקשר. העריכה לא מתבצעת.

עבור איסור גורף ללא לוגיקה, permissions.deny בהגדרות שלכם עושה את אותה עבודה ללא סקריפט לתחזוקה, ו-מצבי ההרשאות מחליטים מה רץ בלי לשאול אתכם קודם. אם הוראה חייבת באמת לשבת ברמת ה-system prompt ולא בהודעת משתמש, --append-system-prompt מציב אותה שם, אם כי זהו flag הפעלה שכל סשן חדש צריך לקבל שוב, מה שמתאים יותר לסקריפטים מאשר לעבודה אינטראקטיבית.

מה שלא ניתן לפתור באמצעות הנחיות

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

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

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

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

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

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

FAQ

מדוע Claude Code מתעלם מהקובץ CLAUDE.md שלי?

בדקו אם הקובץ נטען לפני שתניחו שהוא התעלם ממנו. הריצו את /context ובדקו את רשימת ה-Memory files; קובץ שאינו מופיע שם לא נטען בעת ההפעלה. קובצי הנחיות מועברים כהודעת משתמש לאחר ה-system prompt ומתייחסים אליהם כאל הקשר (context) ולא כאל תצורה מחייבת, לכן אין ערובה לאכיפה קפדנית. רוב המקרים נובעים מאחת מארבע סיבות: הקובץ נמצא בתת-תיקייה שהסוכן מעולם לא קרא ממנה, שני קבצים סותרים זה את זה והמודל בחר אחד מהם באופן שרירותי, הכלל מעורפל מדי מכדי לבדוק פעולה מולו, או שהקוד שמסביב מדגים את ההפך ממה שהכלל קובע.

האם עריכת קובץ ההנחיות במהלך סשן משנה משהו?

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

איזה קובץ גובר כאשר קיים CLAUDE.md ב-root וקובץ מקונן סותר אותו?

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

האם ההנחיות שלי שורדות את הפקודה /compact?

זה תלוי באופן שבו הן נטענו. קובץ CLAUDE.md ב-project root, כללים ללא הגדרת היקף (unscoped) וזיכרון אוטומטי מוזרקים מחדש מהדיסק לאחר compaction. כללים עם frontmatter מסוג paths: וקבצי CLAUDE.md מקוננים בתת-תיקיות הולכים לאיבוד עד שקובץ תואם נקרא שוב. כל דבר שהקלדתם בצ'אט בלבד ישרוד רק אם כלי הסיכום (summariser) שמר אותו במקרה. אם כלל חייב להישמר לאורך כל הסשן, הציבו אותו בקובץ ה-project root ללא frontmatter מסוג paths:.

מתי כלל צריך להפוך ל-hook במקום לטקסט חופשי?

כאשר הבדיקה היא דטרמיניסטית והמחיר של פספוס גבוה מהמחיר של כתיבת סקריפט קטן. הגבלות על נתיבי קבצים, פקודות נדרשות לפני commit, וקריאות אסורות לכלים – כולם עומדים בקריטריונים אלו. PreToolUse hook שיוצא עם סטטוס 2 חוסם את קריאת הכלי לחלוטין ומחזיר את טקסט ה-stderr שלכם למודל כסיבה, כך שהוא נשמר ללא קשר לשאלה אם הכלל עדיין קיים איפשהו בהקשר. כל דבר שפורמטר (formatter) או linter יכולים להחליט לגביו צריך להיות מנוהל על ידי אותו כלי ולהימחק מקובץ ההנחיות לחלוטין.

האם המאמר הזה היה מועיל?