📘 תיעוד 8

כיצד קלוד זוכר את הפרויקט שלך

ספקו לקלוד הנחיות קבועות באמצעות קובצי CLAUDE.md או AGENTS.md, ואפשרו לקלוד לצבור תובנות באופן אוטומטי בעזרת זיכרון אוטומטי (auto memory).

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

• קובצי CLAUDE.md: הנחיות שאתם כותבים כדי לתת לקלוד הקשר קבוע. קלוד יכול לקרוא גם קובצי AGENTS.md של מאגר, בפני עצמם או לצד CLAUDE.md.
• זיכרון אוטומטי (auto memory): הערות שקלוד רושם בעצמו על סמך התיקונים וההעדפות שלכם.

דף זה מסביר כיצד:

• לכתוב ולארגן קובצי CLAUDE.md
• להשתמש ב-AGENTS.md קיים בתור הנחיות הפרויקט שלכם, בפני עצמו או לצד CLAUDE.md
• להגדיר היקף כללים לסוגי קבצים מסוימים בעזרת .claude/rules/
• להגדיר זיכרון אוטומטי (auto memory) כך שקלוד ירשום הערות באופן אוטומטי
• לפתור תקלות כאשר הנחיות אינן מבוצעות

#CLAUDE.md לעומת זיכרון אוטומטי (auto memory)

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

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

סוכני משנה (subagents) יכולים גם הם לתחזק זיכרון אוטומטי משלהם. לפרטים נוספים, ראו תצורת סוכני משנה.

#קובצי CLAUDE.md

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

#מתי להוסיף ל-CLAUDE.md

התייחסו אל CLAUDE.md כמקום שבו אתם רושמים את מה שאלמלא כן הייתם צריכים להסביר שוב ושוב. הוסיפו אליו כאשר:

• קלוד מבצע את אותה טעות בפעם השנייה
• סקירת קוד (code review) תופסת משהו שקלוד היה צריך לדעת על בסיס הקוד הזה
• אתם מקלידים בצ'אט את אותו תיקון או הבהרה שהקלדתם בהפעלה הקודמת
• חבר צוות חדש היה זקוק לאותו הקשר כדי להיות פרודוקטיבי

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

#בחירת המיקום לקובצי CLAUDE.md

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

קובצי CLAUDE.md ו-CLAUDE.local.md בהיררכיית התיקיות שמעל תיקיית העבודה נטענים בעת ההפעלה. קבצים בתת-תיקיות נטענים לפי דרישה כאשר קלוד קורא קבצים בתיקיות אלה. ראו כיצד נטענים קובצי CLAUDE.md לסדר הפענוח המלא.

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

#הגדרת CLAUDE.md לפרויקט

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

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

הגדירו CLAUDE_CODE_NEW_INIT=1 כדי להפעיל תהליך אינטראקטיבי רב שלבי. הפקודה /init שואלת אילו תוצרים להגדיר: קובצי CLAUDE.md, מיומנויות (skills) והוקים (hooks). לאחר מכן היא חוקרת את בסיס הקוד שלכם בעזרת סוכן משנה, משלימה פערים באמצעות שאלות המשך, ומציגה הצעה שניתן לסקור לפני כתיבת קבצים כלשהם.

#כתיבת הנחיות יעילות

קובצי CLAUDE.md נטענים אל חלון ההקשר בתחילת כל הפעלה, וצורכים אסימונים (tokens) לצד השיחה שלכם. המחשת חלון ההקשר מראה היכן CLAUDE.md נטען ביחס לשאר הקשר ההפעלה. מאחר שמדובר בהקשר ולא בתצורה מחייבת, האופן שבו אתם כותבים את ההנחיות משפיע על המידה שבה קלוד מקפיד עליהן. הנחיות ספציפיות, תמציתיות ומובנות היטב פועלות בצורה הטובה ביותר.

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

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

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

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

עקביות: אם שני כללים סותרים זה את זה, קלוד עלול לבחור באחד מהם באופן שרירותי. סקרו את קובצי ה-CLAUDE.md שלכם, קובצי CLAUDE.md מקוננים בתת-תיקיות, ואת .claude/rules/ מעת לעת כדי להסיר הנחיות מיושנות או סותרות. במאגרי מונוריפו (monorepos), השתמשו ב-claudeMdExcludes כדי לדלג על קובצי CLAUDE.md של צוותים אחרים שאינם רלוונטיים לעבודתכם.

#ייבוא קבצים נוספים

קובצי CLAUDE.md יכולים לייבא קבצים נוספים באמצעות התחביר @path/to/import. קבצים מיובאים נפרסים ונטענים אל ההקשר בעת ההפעלה לצד קובץ ה-CLAUDE.md שמפנה אליהם.

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

פענוח הייבוא מדלג על מקטעי קוד פנימיים (code spans) ועל גושי קוד (fenced code blocks) ב-Markdown. כדי לציין נתיב בתוך CLAUDE.md מבלי לייבא אותו, עטפו אותו בגרשיים נטויים (backticks): כתיבת `@README` שומרת על הטקסט כמחרוזת פשוטה, בעוד ש-@README מחוץ לגרשיים נטויים מייבא את הקובץ.

כדי לייבא קובץ README, קובץ package.json ומדריך תהליכי עבודה, הפנו אליהם באמצעות תחביר @ בכל מקום בתוך CLAUDE.md:

See @README for project overview and @package.json for available npm commands for this project.

# Additional Instructions
- git workflow @docs/git-instructions.md

עבור העדפות פרטיות ספציפיות לפרויקט שאינן אמורות להיכנס לבקרת הגרסאות, צרו קובץ CLAUDE.local.md בתיקיית השורש של הפרויקט. הוא נטען לצד CLAUDE.md ומטופל באותו אופן. הוסיפו את CLAUDE.local.md לקובץ .gitignore כדי שלא ייכנס למאגר. כאשר CLAUDE_CODE_NEW_INIT=1 מוגדר, הרצת /init ובחירה באפשרות האישית עושה זאת עבורכם.

אם אתם עובדים על פני כמה עצי עבודה (worktrees) של אותו מאגר git, קובץ CLAUDE.local.md שמוגדר ב-.gitignore קיים רק בעץ העבודה שבו יצרתם אותו. כדי לשתף הנחיות אישיות בין עצי עבודה, ייבאו במקום זאת קובץ מתיקיית הבית שלכם:

# Individual Preferences
- @~/.claude/my-project-instructions.md

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

Claude Code מציג את החלון כדי להגן עליכם מפני קבצים שאנשים אחרים מבצעים להם commit לפרויקט משותף. קובצי זיכרון בהיקף משתמש, כגון ~/.claude/CLAUDE.md ו-~/.claude/rules/, הם קבצים שכתבתם בעצמכם. למעט בהפעלות Cowork במחשב שלכם, Claude Code טוען את פעולות הייבוא שלהם ללא חלון האישור ונותן בהם אמון כמו בשאר התצורה האישית שלכם.

בהפעלות Cowork במחשב שלכם, Claude Code מדלג על כל ייבוא בקובץ ברמת המשתמש שמפוערך לנתיב מחוץ לתיקיית העבודה של ההפעלה, וטוען את שאר הקובץ. בהפעלות אלה הוא מדלג גם על קובץ ~/.claude/CLAUDE.md שהוא בעצמו קישור סימבולי (symlink) או קישור קשיח (hard link), וכן על תיקיית ~/.claude/rules/ מקושרת סימבולית או קובץ כללים מקושר סימבולית המצביעים מחוץ לתיקיית העבודה.

#כיצד נטענים קובצי CLAUDE.md

Claude Code טוען את CLAUDE.md ואת CLAUDE.local.md מתיקיית העבודה הנוכחית שלכם ומכל תיקייה מעליה. אם תריצו את Claude Code ב-foo/bar/, הוא יטען הנחיות מ-foo/bar/CLAUDE.md, מ-foo/CLAUDE.md, ומכל קובץ CLAUDE.local.md שלצדם.

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

קלוד מגלה גם קובצי CLAUDE.md ו-CLAUDE.local.md בתת-תיקיות תחת תיקיית העבודה הנוכחית שלכם. במקום לטעון אותם בהפעלה, הם נכללים כאשר קלוד קורא קבצים באותן תת-תיקיות.

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

הערות HTML ברמת בלוק (<!-- maintainer notes -->) בקובצי CLAUDE.md מוסרות לפני שהתוכן מוזרק אל ההקשר של קלוד. השתמשו בהן כדי להשאיר הערות למתחזקים אנושיים מבלי לבזבז עליהן אסימוני הקשר. הערות בתוך גושי קוד נשמרות. כאשר אתם פותחים קובץ CLAUDE.md ישירות באמצעות הכלי Read, ההערות נשארות גלויות.

#טעינה מתיקיות נוספות

הדגל --add-dir מעניק לקלוד גישה לתיקיות נוספות מחוץ לתיקיית העבודה הראשית שלכם. כברירת מחדל, קובצי CLAUDE.md מתיקיות אלה אינם נטענים.

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

CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1 claude --add-dir ../shared-config

פעולה זו טוענת את CLAUDE.md, .claude/CLAUDE.md, .claude/rules/*.md ואת CLAUDE.local.md מהתיקייה הנוספת. המערכת מדלגת על CLAUDE.local.md אם החרגתם את local מתוך --setting-sources.

#ארגון כללים באמצעות .claude/rules/

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

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

#הגדרת כללים

הניחו קובצי markdown בתיקייה .claude/rules/ של הפרויקט שלכם. כל קובץ צריך לכסות נושא אחד, עם שם קובץ תיאורי כמו testing.md או api-design.md. כל קובצי ה-.md מתגלים באופן רקורסיבי, כך שתוכלו לארגן כללים בתת-תיקיות כמו frontend/ או backend/:

your-project/
├── .claude/
│   ├── CLAUDE.md           
# Main project instructions
│   └── rules/
│       ├── code-style.md   
# Code style guidelines
│       ├── testing.md      
# Testing conventions
│       └── security.md     
# Security requirements

כללים ללא שדה paths ב-frontmatter נטענים בעת ההפעלה באותה עדיפות כמו .claude/CLAUDE.md.

המערכת מדלגת על כללי פרויקט אם אתם מחריגים את project מתוך --setting-sources. לפני גרסה v2.1.211, כללים שנטענו לפי דרישה, כולל כללים מוגבלי נתיב וכללים בתיקיות .claude/rules/ מקוננות, נטענו גם כאשר project הוחרג.

#כללים ספציפיים לנתיב

ניתן להגדיר את היקף הכללים לקבצים ספציפיים באמצעות YAML frontmatter עם השדה paths. כללים מותנים אלה חלים רק כאשר קלוד עובד עם קבצים התואמים לתבניות שצוינו.

---
paths:
  - "src/api/**/*.ts"
---

# API Development Rules

- All API endpoints must include input validation
- Use the standard error response format
- Include OpenAPI documentation comments

כללים ללא שדה paths נטענים ללא תנאי וחלים על כל הקבצים. כללים מוגבלי נתיב מופעלים כאשר קלוד קורא קבצים התואמים לתבנית, ולא בכל שימוש בכלי. החל מגרסה v2.1.198, ההתאמה פועלת גם כאשר קלוד מגיע לקובץ דרך נתיב קישור סימבולי (symlink) אל תיקיית הפרויקט, למשל בעותק (checkout) המקושר ב-symlink.

השתמשו בתבניות glob בשדה paths כדי להתאים קבצים לפי סיומת, תיקייה, או כל שילוב ביניהן:

באפשרותכם לציין מספר תבניות ולהשתמש בהרחבת סוגריים מסולסלים (brace expansion) כדי להתאים מספר סיומות בתבנית אחת:

---
paths:
  - "src/**/*.{ts,tsx}"
  - "lib/**/*.ts"
  - "tests/**/*.test.ts"
---

כל קבוצת סוגריים מסולסלים מכפילה את מספר התבניות המורחבות: src/*.{ts,tsx} מורחבת לשתי תבניות, ו-{a,b}/{c,d}/*.{ts,tsx} לשמונה. כדי לשמור על הרחבה מוגבלת, רשימת ה-paths כולה של כלל חולקת תקציב יחיד של 1,000 תבניות מורחבות ו-4 MiB, ותבניות ללא סוגריים מסולסלים אינן נספרות כנגד תקציב זה.

Claude Code משתמש בכל תבנית שחורגת מהתקציב ללא הרחבה, והסוגריים המסולסלים המילוליים שלה אינם תואמים לקבצים כלשהם. לפני גרסה v2.1.217, ערך paths עם קבוצות סוגריים מסולסלים רבות תקע או הפיל את ה-CLI בעת ההפעלה.

תחביר glob מתייחס ל-[ כאל תחילתו של ביטוי סוגריים מרובעים כגון [abc]. תבנית עם [ שאינה ניתנת לקריאה כביטוי סוגריים מרובעים, כגון photos [2024/**, אינה חוקית: היא אינה מתאימה לשום דבר, ושאר התבניות של הכלל ממשיכות לפעול. כדי להתאים תו [ מילולי בשם קובץ, בצעו לו escape כך: photos \[2024/**. לפני גרסה v2.1.207, תבנית אחת לא חוקית גרמה לכלי Read להיכשל עבור כל קובץ שהכלל נבדק מולו, במקום לא להתאים לשום דבר.

#שיתוף כללים בין פרויקטים באמצעות symlinks

התיקייה .claude/rules/ תומכת בקישורים סימבוליים (symlinks), כך שתוכלו לתחזק קבוצת כללים משותפת ולקשר אותם למספר פרויקטים. קישורים סימבוליים מעגליים מזוהים ומטופלים באופן חלק.

Claude Code מתייחס ל-symlink שהיעד שלו נמצא מחוץ לתיקיית העבודה שלכם כמו אל ייבוא חיצוני. הכללים המקושרים אינם נטענים עד שתאשרו ייבוא חיצוני עבור הפרויקט, וגם לאחר מכן נטענים רק אלה שללא שדה paths. Claude Code מבקש אישור זה רק כאשר קובץ זיכרון של הפרויקט מייבא קובץ מחוץ לתיקיית העבודה באמצעות @path, ולא עבור קישורים סימבוליים בלבד. כדי לטעון כללים משותפים ללא אישור זה, שמרו אותם ב-~/.claude/rules/, שם הם יחולו על כל פרויקט במחשב שלכם.

דוגמה זו מקשרת הן תיקייה משותפת והן קובץ בודד:

ln -s ~/shared-claude-rules .claude/rules/shared
ln -s ~/company-standards/security.md .claude/rules/security.md

#כללים ברמת המשתמש

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

~/.claude/rules/
├── preferences.md    
# Your personal coding preferences
└── workflows.md      
# Your preferred workflows

כללים ברמת המשתמש נטענים לפני כללי פרויקט, מה שמעניק לכללי הפרויקט עדיפות גבוהה יותר.

#ניהול CLAUDE.md עבור צוותים גדולים

עבור ארגונים הפורסים את Claude Code בין צוותים שונים, ניתן לרכז את ההנחיות ולשלוט באילו קובצי CLAUDE.md ייטענו.

#פריסת CLAUDE.md כלל-ארגוני

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

1. צרו את הקובץ במיקום המדיניות המנוהלת (managed policy):

   • macOS: /Library/Application Support/ClaudeCode/CLAUDE.md
   • Linux ו-WSL: /etc/claude-code/CLAUDE.md
   • Windows: C:\Program Files\ClaudeCode\CLAUDE.md

2. פרסו אותו באמצעות מערכת ניהול התצורה שלכם: השתמשו ב-MDM, ב-Group Policy, ב-Ansible או בכלים דומים כדי להפיץ את הקובץ בין מחשבי המפתחים. ראו הגדרות מנוהלות (managed settings) עבור אפשרויות תצורה כלל-ארגוניות נוספות.

המפתח claudeMd מאפשר לכם להציב תוכן של CLAUDE.md מנוהל ישירות בתוך managed-settings.json במקום לפרוס קובץ נפרד.

היקף (Scope): כל הפעלת Claude Code במחשב, בכל מאגר. להנחיות ספציפיות למאגר, בצעו commit לקובץ CLAUDE.md של הפרויקט במקום זאת.

עדיפות (Precedence): זהה לקובץ CLAUDE.md מנוהל. נטען לפני CLAUDE.md של המשתמש ושל הפרויקט.

היכן זה מכובד: בהגדרות מנוהלות והגדרות מדיניות (managed and policy settings) בלבד. להגדרת claudeMd בהגדרות משתמש, פרויקט או הגדרות מקומיות אין כל השפעה.

הדוגמה שלהלן מוסיפה הנחיות התנהגותיות ישירות בקובץ הגדרות מנוהל:

{
  "claudeMd": "Always run `make lint` before committing.\nNever push directly to main."
}

קובץ CLAUDE.md מנוהל וכן הגדרות מנוהלות משמשים למטרות שונות. השתמשו בהגדרות לצורך אכיפה טכנית וב-CLAUDE.md להנחיה התנהגותית:

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

#החרגת קובצי CLAUDE.md ספציפיים

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

דוגמה זו מחריגה קובץ CLAUDE.md ברמה העליונה ותיקיית כללים מתיקיית אב. הוסיפו אותה לקובץ .claude/settings.local.json כדי שההחרגה תישאר מקומית במחשב שלכם:

{
  "claudeMdExcludes": [
    "**/monorepo/CLAUDE.md",
    "/home/user/monorepo/other-team/.claude/rules/**"
  ]
}

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

כדי להחריג קובץ כללים שאליו אתם מגיעים דרך קישור סימבולי (symlink), בין אם הקובץ עצמו ובין אם התיקייה שלו היא הקישור, כתבו את התבנית ביחס לאחד מהנתיבים: נתיב הקובץ תחת .claude/rules/ או יעד הקישור שלו. תבנית התואמת לאחד הנתיבים מחריגה את הקובץ. לפני גרסה v2.1.239, רק תבנית שהתאימה ליעד הקישור החריגה את הקובץ.

לא ניתן להחריג קובצי CLAUDE.md של מדיניות מנוהלת. הדבר מבטיח שהנחיות כלל-ארגוניות יחולו תמיד, ללא תלות בהגדרות אישיות.

#AGENTS.md

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

כדי לשנות את ברירת המחדל, למשל כדי לגרום לקלוד לקרוא תמיד את שני הקבצים, לקרוא רק את CLAUDE.md, או לקרוא רק את ההנחיות המנוהלות של הארגון שלכם, שנו את ההגדרה Project instructions.

הערה: קריאת AGENTS.md ישירות דורשת את Claude Code בגרסה v2.1.277 ומעלה. בהפעלות מסוימות, כגון אלה הפועלות על גבי Amazon Bedrock או כאשר טלמטריה מושבתת, קלוד אינו יכול לקרוא את AGENTS.md, לכן יש לייבא אותו מתוך CLAUDE.md במקרים אלה.

#מתי Claude Code קורא את AGENTS.md

כברירת מחדל, קלוד קורא את AGENTS.md רק כאשר אין לכם CLAUDE.md בתיקיית העבודה שלכם או מעליה. להלן הקבצים שנחשבים לצורך בדיקה זו:

• נחשבים, כך שקלוד קורא אותם במקום את AGENTS.md: קובצי CLAUDE.md, .claude/CLAUDE.md או CLAUDE.local.md בתיקיית העבודה שלכם או בכל תיקייה מעליה.
• אינם נחשבים, וממשיכים להיטען לצד AGENTS.md: קובץ ~/.claude/CLAUDE.md שלכם, קובץ ה-CLAUDE.md המנוהל של הארגון שלכם, וקובצי .claude/rules/.

כאשר אף אחד מהם אינו קיים, הנה מה שקלוד קורא וכיצד תוכלו לדעת זאת:

• בתחילת ההפעלה: כל AGENTS.md ו-.claude/AGENTS.md בתיקיית העבודה שלכם ובתיקיות שמעליה. בהפעלה אינטראקטיבית תראו שורה כגון no CLAUDE.md found; AGENTS.md loaded: /home/you/repo/AGENTS.md בשיחה.
• כאשר קלוד עובד בתת-תיקיות: קובץ AGENTS.md של תת-תיקייה, כאשר קלוד פותח שם קובץ באמצעות הכלי Read ולאותה תת-תיקייה אין אף אחד משלושת קובצי ה-CLAUDE.md משלה.
• בתוך כל AGENTS.md: פעולות ייבוא @path נפרסות, תבניות claudeMdExcludes חלות, וסוכני משנה שמדלגים על הנחיות פרויקט מדלגים גם על קבצים אלה.
• לא נקראים: AGENTS.local.md, AGENTS.override.md, או כל דבר תחת תיקיית .agents/.

הערה: מכיוון ש-CLAUDE.local.md נחשב בספירה, הוספת קובץ כזה כדי לשמור על הנחיות אישיות משלכם שלא נכנסות ל-commit בפרויקט שמסתמך על AGENTS.md תגרום לקלוד להפסיק לקרוא את AGENTS.md. כדי לשמור על CLAUDE.local.md ועדיין לגרום לקלוד לקרוא את AGENTS.md, הגדירו את Project instructions לערך claude-md-and-agents-md.

#בחירת קובצי ההנחיות שייטענו

כדי לשנות אילו קבצים קלוד קורא, הקלידו /config בהפעלת Claude Code כדי לפתוח את לוח ההגדרות, ולאחר מכן הגדירו את Project instructions לאחד מהערכים הבאים:

באפשרותכם לקבוע את הערך גם בקובץ הגדרות במקום דרך /config. הוסיפו אותו תחת המזהה של התוסף המובנה agents-md בתוך pluginConfigs, ב-~/.claude/settings.json, בקובץ --settings, או ב-הגדרות מנוהלות. Claude Code מתעלם מכך בקובצי הגדרות של פרויקט ובקובצי הגדרות מקומיים. דוגמה זו מגדירה לקלוד לקרוא את שני הקבצים:

{
  "pluginConfigs": {
    "agents-md@builtin": {
      "options": { "instructionFiles": "claude-md-and-agents-md" }
    }
  }
}

השינוי שלכם יחול החל מההודעה הבאה שתשלחו ובכל הפעלה חדשה.

#מתי התמיכה ב-AGENTS.md אינה זמינה

בהפעלות אלה קלוד קורא קובצי CLAUDE.md בלבד, והאפשרות Project instructions אינה מופיעה בלוח ההגדרות של /config:

• אתם משתמשים בגרסה של Claude Code הקודמת ל-v2.1.277
• ההפעלה שלכם אינה מושכת דגלי תכונות (feature flags) מ-Anthropic, למשל משום שאתם משתמשים ב-Amazon Bedrock או בספק צד שלישי אחר, או שהשבתתם טלמטריה. הסעיף המקושר כולל את הרשימה המלאה
• זוהי ההפעלה הראשונה שלכם לאחר התקנה או שדרוג לגרסה הכוללת תמיכה ב-AGENTS.md. קלוד יקרא את AGENTS.md החל מההפעלה הבאה שלכם
• אתם או הארגון שלכם הגדרתם את disableAllHooks או את allowManagedHooksOnly, או שהשבתתם את התוסף המובנה agents-md בתוך /plugin

כדי לספק לקלוד את ה-AGENTS.md שלכם בהפעלות אלה, ייבאו אותו מתוך CLAUDE.md.

#במה AGENTS.md שונה מ-CLAUDE.md

קובץ AGENTS.md שקלוד קורא דרך ההגדרה Project instructions נבדל מ-CLAUDE.md בנקודות הבאות:

#הסרת מעקף קודם עבור AGENTS.md

אם הגדרתם את Claude Code לקרוא את AGENTS.md לפני שהוא עשה זאת בעצמו, הנה מה שעליכם לעשות בכל אחד מהמבנים הנפוצים:

• קובץ CLAUDE.md המכיל @AGENTS.md: אתם יכולים להשאיר אותו. השארת הייבוא לעולם אינה גורמת לקלוד לקרוא את AGENTS.md פעמיים, בכל ערך שתבחרו עבור Project instructions. מחקו את CLAUDE.md אם אינו מכיל שום דבר אחר, או השאירו אותו אם חלק מההפעלות שלכם אינן יכולות לטעון את AGENTS.md ישירות.
• קובץ CLAUDE.md שאומר לקלוד במילים לקרוא את AGENTS.md: קלוד רואה את AGENTS.md רק אם הוא מחליט לפתוח את הקובץ. מחקו את CLAUDE.md כדי שקלוד יקרא את AGENTS.md ישירות, או החליפו את המשפט בייבוא מסוג @AGENTS.md.
• קובץ CLAUDE.md שמקושר ב-symlink אל AGENTS.md: אל תעשו דבר, או מחקו את ה-symlink. בכל מקרה קלוד קורא את התוכן פעם אחת.
• הוק מסוג SessionStart שמדפיס את AGENTS.md: הסירו אותו. מרגע שקלוד קורא את AGENTS.md ישירות, ההוק יוסיף עותק שני אל ההקשר.

#שיתוף קובץ יחיד עם כלי קידוד אחרים

כאשר קלוד אינו קורא את ה-AGENTS.md שלכם ישירות, עדיין תוכלו לשמור עליו כקובץ היחיד שכל הכלים משתפים, על ידי הצבת ייבוא @AGENTS.md בתוך קובץ CLAUDE.md לצידו. עשו זאת כאשר בפרויקט שלכם יש גם CLAUDE.md, כאשר הגדרתם את Project instructions לערך claude-md, או בהפעלות שאינן יכולות לטעון את AGENTS.md. הוסיפו כל הנחיה ספציפית לקלוד מתחת לייבוא, וקלוד יקרא תחילה את הקובץ המיובא ולאחר מכן את השאר:

@AGENTS.md

## Claude Code

Use plan mode for changes under `src/billing/`.

אם אינכם זקוקים לתוכן ספציפי לקלוד, גם קישור סימבולי (symlink) יעבוד:

ln -s AGENTS.md CLAUDE.md

הפקודה אינה מציגה פלט בהצלחה. לפני שתבחרו ב-symlink במקום בייבוא, בדקו את המגבלות הבאות:

• עריכה: קלוד קורא את CLAUDE.md דרך הקישור, אך הכלים Edit ו-Write מסרבים לכתוב דרך קישור סימבולי, והסירוב מנחה את קלוד לערוך את יעד הקישור, AGENTS.md, במקום זאת.
• Windows: אם אתם או מישהו שמשכפל (clones) את המאגר עובדים על Windows, השתמשו בייבוא @AGENTS.md במקום זאת. יצירת קישור סימבולי ב-Windows דורשת הרשאות מנהל מערכת (Administrator) או מצב מפתח (Developer Mode), ו-Git מושך קישור סימבולי שנשמר ב-commit כקובץ טקסט רגיל אלא אם כן core.symlinks מופעל, מה שמשאיר את אותו עותק עם CLAUDE.md של שורה אחת במקום ההנחיות שלכם.

בכל אחת מהגישות, הריצו /context בהפעלה הבאה שלכם וודאו ש-CLAUDE.md מופיע תחת Memory files.

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

הרצת /init קוראת קובצי הנחיות של כלים אחרים ומשלבת את החלקים הרלוונטיים בתוך קובץ ה-CLAUDE.md שנוצר:

• כללי Cursor בתוך .cursor/rules/ או .cursorrules
• כללי Copilot בתוך .github/copilot-instructions.md
• כאשר CLAUDE_CODE_NEW_INIT=1 מוגדר: AGENTS.md, .devin/rules/, .windsurf/rules/ או .windsurfrules, וכן .clinerules

באפשרותכם גם להריץ את /import כדי לייבא תצורה של סוכן קידוד נתמך אל תוך Claude Code, מה שמוסיף עותק חד פעמי של קובצי הנחיות כגון AGENTS.md אל קובץ ה-CLAUDE.md התואם, ומעביר שרתי MCP, פקודות, סוכני משנה ומיומנויות (skills). דורש את Claude Code בגרסה v2.1.213 ומעלה.

#זיכרון אוטומטי (Auto memory)

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

• user: התפקיד שלכם, המומחיות והעדפות העבודה שלכם
• feedback: תיקונים שאתם נותנים לקלוד וגישות שאתם מאשרים
• project: עבודה מתמשכת, מועדי יעד (deadlines) והחלטות שקלוד אינו יכול להסיק מהקוד או מהיסטוריית ה-git
• reference: היכן למצוא מידע מחוץ לפרויקט, כגון מערכת מעקב משימות (issue tracker) או לוח בקרה (dashboard)

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

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

#הפעלה או השבתה של זיכרון אוטומטי

זיכרון אוטומטי מופעל כברירת מחדל. כדי לשנות את מצבו, פתחו את /memory במהלך ההפעלה והשתמשו במתג הזיכרון האוטומטי, מה ששומר את autoMemoryEnabled בהגדרות המשתמש שלכם ב-~/.claude/settings.json. כדי לכבות אותו עבור פרויקט בודד, הגדירו את autoMemoryEnabled בהגדרות של אותו פרויקט:

{
  "autoMemoryEnabled": false
}

כדי להשבית את הזיכרון האוטומטי באמצעות משתנה סביבה, הגדירו CLAUDE_CODE_DISABLE_AUTO_MEMORY=1.

#מיקום האחסון

כל פרויקט מקבל תיקיית זיכרון משלו בנתיב ~/.claude/projects/<project>/memory/. הנתיב <project> נגזר ממאגר ה-git, כך שכל עצי העבודה (worktrees) ותת-התיקיות באותו מאגר חולקים תיקיית זיכרון אוטומטי אחת. מחוץ למאגר git, תיקיית השורש של הפרויקט משמשת במקום זאת.

אם אתם מגדירים את CLAUDE_CODE_PROJECT_DIR_NAME לצד CLAUDE_CONFIG_DIR, המערכת של Claude Code משתמשת בשם זה בתור תיקיית <project> תחת <config dir>/projects/, ללא תלות במאגר שבו הפעלתם אותה, כך שפרויקטים המופעלים עם אותה תיקיית תצורה חולקים תיקיית זיכרון אוטומטי אחת. דורש את Claude Code בגרסה v2.1.234 ומעלה.

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

{
  "autoMemoryDirectory": "~/my-custom-memory-dir"
}

הערך חייב להיות נתיב מוחלט או להתחיל ב-~/.

כאשר אתם מגדירים זאת בקובץ .claude/settings.json או .claude/settings.local.json של פרויקט, Claude Code מכבד זאת תחת אותו כלל אמון סביבת עבודה (workspace trust) כמו הוקים בקובצי הגדרות. כאשר permissions.blockReadsOutsideWorkingDirectories מופעל, Claude Code אינו טוען שום זיכרון אוטומטי מתיקייה שנבחרה על ידי קובץ הגדרות שסופק על ידי המאגר ואינו שומר אליה דבר, בכל מקום שבו תיקייה זו ממוקמת.

התיקייה מכילה אינדקס בשם MEMORY.md וקובץ נושא אחד לכל זיכרון:

~/.claude/projects/<project>/memory/
├── MEMORY.md           
# Index, one line per memory, loaded into every session
├── user_role.md        
# One memory
├── feedback_testing.md 
# One memory
└── ...                 
# Any other topic files Claude creates

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

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

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

#כיצד זה עובד

200 השורות הראשונות של MEMORY.md, או 25KB הראשונים, המוקדם מביניהם, נטענים בתחילת כל שיחה. תוכן מעבר לסף זה אינו נטען בעת תחילת ההפעלה. קלוד שומר על MEMORY.md תמציתי על ידי העברת הערות מפורטות לקובצי נושא נפרדים.

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

מגבלה זו חלה רק על MEMORY.md. Claude Code טוען קובץ CLAUDE.md במלואו עד לגודל של 4 MiB, ומדלג על קובץ גדול מכך. קבצים קצרים יותר מניבים רמת הקפדה והיענות טובה יותר.

Claude Code אינו טוען קובצי נושא כגון user_role.md או feedback_testing.md בעת ההפעלה. קלוד קורא אותם לפי דרישה בעזרת כלי הקבצים הרגילים שלו כאשר הוא זקוק למידע.

הזיכרון האוטומטי של השיחה הראשית אינו נטען אל סוכני משנה (subagents); היוצא מן הכלל הוא פיצול (fork), אשר יורש את שיחת האב ואת הנחיית המערכת (system prompt). זיכרון אוטומטי של סוכן משנה עצמו, המופעל באמצעות שדה memory של סוכן המשנה, הוא תיקייה נפרדת.

קלוד קורא וכותב קובצי זיכרון במהלך ההפעלה שלכם. כאשר אתם רואים הודעות כמו "Saved 2 memories" או "Recalled 2 memories" בממשק של Claude Code, קלוד מעדכן או קורא באופן פעיל מתוך ~/.claude/projects/<project>/memory/.

כאשר קלוד כותב קובץ זיכרון שמתחיל ב-YAML frontmatter, המערכת של Claude Code רושמת את זמן הכתיבה בשדה frontmatter בשם modified כחותמת זמן בתקן ISO 8601. חותמת הזמן מראה עד כמה העובדה עדכנית, הן עבורכם והן עבור קלוד כאשר הוא קורא בחזרה את הזיכרון. כל קובץ שיש לו frontmatter מקבל שדה זה בפעם הבאה שקלוד כותב אליו, כולל קבצים שנוצרו בגרסאות קודמות; Claude Code לעולם אינו מוסיף frontmatter לקובץ שאין לו כזה מלכתחילה. השדה modified דורש את Claude Code בגרסה v2.1.214 ומעלה.

#בדיקה ועריכה של הזיכרון שלכם

קובצי זיכרון אוטומטי הם קובצי markdown רגילים שתוכלו לערוך או למחוק בכל עת. הריצו את הפקודה /memory כדי לעיין בקובצי זיכרון ולפתוח אותם מתוך הפעלה פעילה.

#צפייה ועריכה באמצעות /memory

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

עורכי ממשק משתמש גרפי (GUI) כגון VS Code פותחים את הקובץ בחלון נפרד, ותוכלו להמשיך להשתמש בהפעלה כשהוא פתוח. לפני גרסה v2.1.216, הפקודה /memory המתינה שתסגרו את הקובץ לפני שהגיבה. עורכי מסוף כגון Vim משתלטים על המסוף עד שאתם יוצאים מהם.

כאשר אתם מבקשים מקלוד לזכור משהו, כמו "השתמש תמיד ב-pnpm ולא ב-npm" או "זכור שבדיקות ה-API דורשות מופע מקומי של Redis", קלוד שומר זאת בזיכרון האוטומטי. כדי להוסיף הנחיות ל-CLAUDE.md במקום זאת, בקשו מקלוד ישירות, כגון "הוסף זאת ל-CLAUDE.md", או ערכו את הקובץ בעצמכם דרך /memory.

#פתרון בעיות בזיכרון

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

#קלוד אינו פועל לפי ה-CLAUDE.md שלי

תוכן CLAUDE.md מועבר כהודעת משתמש לאחר הנחיית המערכת (system prompt), ולא כחלק מהנחיית המערכת עצמה. קלוד קורא אותו ומנסה לפעול לפיו, אך אין ערובה להיענות מוחלטת, בייחוד עבור הנחיות מעורפלות או סותרות.

לניפוי שגיאות:

• הריצו /context ובדקו את הרשימה תחת Memory files כדי לוודא שקובצי ה-CLAUDE.md ו-CLAUDE.local.md שלכם נטענו. אם קובץ CLAUDE.md חסר שם, קלוד אינו יכול לראות אותו. קובץ AGENTS.md מופיע שם רק כאשר קובץ CLAUDE.md מייבא אותו, ולא כאשר קלוד קורא אותו ישירות. השתמשו ב-/memory כדי לפתוח ולערוך את הקבצים.
• ודאו שה-CLAUDE.md הרלוונטי נמצא במיקום שנטען עבור ההפעלה שלכם (ראו בחירת המיקום לקובצי CLAUDE.md).
• הפכו את ההנחיות לספציפיות יותר. "השתמש בהזחה של 2 רווחים" עובד טוב יותר מאשר "עצב את הקוד יפה".
• חפשו הנחיות סותרות בין קובצי CLAUDE.md שונים. אם שני קבצים מספקים הנחיות שונות לאותה התנהגות, קלוד עלול לבחור באחת מהן באופן שרירותי.

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

עבור הנחיות שאתם מעוניינים להעביר ברמת הנחיית המערכת (system prompt), השתמשו בדגל --append-system-prompt. אתם מעבירים אותו בעת ההפעלה, ולכן הוא מתאים יותר לסקריפטים ולאוטומציה מאשר לשימוש אינטראקטיבי. לגבי התנהגותו בעת חידוש שיחה, ראו דגלי הנחיית מערכת בשיחות מחודשות.

טיפ: השתמשו ב-הוק מסוג InstructionsLoaded כדי לתעד ביומן (log) אילו קובצי CLAUDE.md וקובצי כללים נטענו, מתי הם נטענו ומדוע. הדבר שימושי במיוחד לניפוי שגיאות של כללים מוגבלי נתיב או קבצים הנטענים לפי דרישה (lazy-loaded) בתת-תיקיות.

#ה-AGENTS.md שלי אינו נטען

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

1. חפשו קובץ CLAUDE.md, .claude/CLAUDE.md או CLAUDE.local.md בתיקיית העבודה שלכם או בכל תיקייה מעליה, למעט ~/.claude/CLAUDE.md שלכם. אם מצאתם כזה, קלוד קורא אותו במקום את AGENTS.md, אלא אם כן תגדירו את Project instructions לערך claude-md-and-agents-md.
2. הריצו claude --version וודאו שגרסת התוכנה היא v2.1.277 ומעלה.
3. בדקו האם ההפעלה שלכם היא כזו שאינה יכולה לטעון את AGENTS.md, כגון הפעלה דרך ספק צד שלישי או כאשר טלמטריה מושבתת.
4. הקלידו /config בהפעלה שלכם כדי לפתוח את לוח ההגדרות, וודאו ש-Project instructions אינו מוגדר ל-claude-md או ל-managed-only. אם אינכם רואים את ההגדרה כלל, ההפעלה שלכם היא כזו שאינה יכולה לטעון את AGENTS.md.

הקובץ AGENTS.md אינו מופיע ב-/memory או ב-/context כאשר קלוד קורא אותו ישירות, לכן חפשו במקום זאת את השורה AGENTS.md loaded או שאלו את קלוד מה כתוב בהנחיות הפרויקט שלו.

אם אתם מעוניינים להשאיר את ה-CLAUDE.md שמצאתם, או שההפעלה שלכם אינה יכולה לטעון את AGENTS.md, הוסיפו קובץ CLAUDE.md לצד ה-AGENTS.md שלכם אשר מייבא אותו.

#איני יודע מה הזיכרון האוטומטי שמר

הריצו /memory ובחרו בתיקיית הזיכרון האוטומטי כדי לעיין במה שקלוד שמר. הכל כתוב ב-markdown פשוט שתוכלו לקרוא, לערוך או למחוק.

#ה-CLAUDE.md שלי גדול מדי

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

בדיקת התקינות /doctor מציעה קיצוצים עבור קובץ CLAUDE.md שנמצא במאגר: היא מסירה תוכן שקלוד יכול להסיק מבסיס הקוד, כגון מבנה תיקיות, רשימות תלויות וסקירות ארכיטקטורה, ומשאירה מוקשים אפשריים, נימוקים ומוסכמות השונות מברירות המחדל של הכלים. בדיקת הקיצוץ דורשת את Claude Code בגרסה v2.1.206 ומעלה.

#נראה שהנחיות הולכות לאיבוד לאחר /compact

קובץ CLAUDE.md בשורש הפרויקט שורד תהליך דחיסה (compaction): לאחר /compact, קלוד קורא אותו מחדש מהדיסק ומזריק אותו שוב להפעלה. קובצי CLAUDE.md מקוננים בתת-תיקיות וכללים עם שדה paths: ב-frontmatter נטענים מחדש כאשר קלוד קורא קבצים שעליהם הם חלים.

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

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

#משאבים קשורים

• ניפוי שגיאות בתצורה שלכם: אבחנו מדוע CLAUDE.md או הגדרות אינם נכנסים לתוקף
• מיומנויות (Skills): אריזת תהליכי עבודה שניתן לחזור עליהם הנטענים לפי דרישה
• הגדרות (Settings): הגדרת התנהגות Claude Code באמצעות קובצי הגדרות
• זיכרון סוכני משנה (Subagent memory): אפשרו לסוכני משנה לתחזק זיכרון אוטומטי משלהם