📘 תיעוד 8

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

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

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

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

הדף הזה מכסה איך:

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

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

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

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

גם סוכני משנה יכולים לנהל זיכרון אוטומטי משלהם. ראה הגדרת סוכן משנה לפרטים.

#קבצי CLAUDE.md

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

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

התייחס ל-CLAUDE.md כמקום שבו אתה רושם את מה שהיית מסביר מחדש. הוסף אליו כש:

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

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

#בחר איפה לשים קבצי CLAUDE.md

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

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

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

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

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

כדי לאשר שהקובץ נטען, הרץ /context all בסשן ובדוק את הרשימה תחת Memory files. ב-מצב מסך מלא, /context לבד מכווץ את הרשימה הזאת.

טיפ

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

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

#כתוב הוראות יעילות

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

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

שמור על הקבצים קצרים, מאורגנים, ועקביים:

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

#בקר את קבצי ההוראות שלך

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

כברירת מחדל, הביקורת מכסה את קבצי CLAUDE.md, CLAUDE.local.md, ו-AGENTS.md שלך, וגם את הכללים, ה-skills, הפקודות, סוכני המשנה, וסגנונות הפלט תחת .claude/ ו-~/.claude/. כדי לבקר קובץ או תיקייה אחת, העבר את הנתיב, לדוגמה /doctor prompt-audit .claude/skills/deploy.

הביקורת רצה דרך ה-skill המצורף /claude-api. היא לא זמינה בזמן שה-skill הזה כבוי ב-skillOverrides או עם disableBundledSkills. /doctor prompt-audit דורש Claude Code v2.1.283 או חדש יותר.

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

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

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

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

- API conventions @Design\ Docs/api-conventions.md

ניתוח הייבוא מדלג על מקטעי קוד של Markdown ועל בלוקי קוד מגודרים. כדי להזכיר נתיב ב-CLAUDE.md בלי לייבא אותו, עטוף אותו בגרשיים הפוכים: כתיבת `@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 כדי שהוא לא יועבר ל-commit. כש-CLAUDE_CODE_NEW_INIT=1 מוגדר, הרצת /init ובחירת האפשרות האישית עושה זאת בשבילך.

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

# 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/ או קובץ כלל שהוא symlink שמצביע מחוץ לתיקיית העבודה.

#איך קבצי 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 נקראות אחרונות. בתוך כל תיקייה, CLAUDE.local.md מצורף אחרי CLAUDE.md, כך שההערות האישיות שלך הן הדבר האחרון ש-Claude קורא ברמה הזאת.

Claude גם מגלה קבצי CLAUDE.md ו-CLAUDE.local.md בתת תיקיות מתחת לתיקיית העבודה הנוכחית. במקום לטעון אותם בהפעלה, Claude Code טוען כל אחד פעם אחת כש-Claude קורא, כותב, או עורך קובץ אחר בתת התיקייה הזאת. קריאה כוללת צפייה בקובץ עם פקודת Bash שנחשבת לקריאה, כמו cat או head על קובץ יחיד. לקבצים בתוך worktree תחת .claude/worktrees/, ראה בידוד סוכני משנה עם worktrees.

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

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

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

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

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

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

הצורה בתוך השורה מגדירה את המשתנה להפעלה האחת הזאת ב-Bash או ב-Zsh. כדי להשאיר אותו פעיל לכל סשן, הוסף אותו לבלוק env ב-~/.claude/settings.json כפי שמוצג ב-הגדרת משתני סביבה.

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

#ארגון כללים עם .claude/rules/

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

[!NOTE]

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

#הגדרת כללים

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

your-project/
├── .claude/
│   ├── CLAUDE.md           # הוראות הפרויקט הראשיות
│   └── rules/
│       ├── code-style.md   # הנחיות סגנון קוד
│       ├── testing.md      # מוסכמות בדיקות
│       └── security.md     # דרישות אבטחה

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

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

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

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

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

# כללי פיתוח API

- כל נקודות הקצה של ה API חייבות לכלול אימות קלט
- השתמשו בפורמט תגובת השגיאה הסטנדרטי
- כללו הערות תיעוד OpenAPI

כלל שתחום לנתיב נטען כש Claude משתמש בכלי Read, Write או Edit על קובץ תואם. הוא נטען גם כש Claude צופה בקובץ תואם באמצעות פקודת Bash שנחשבת לקריאה, כמו cat או head על קובץ יחיד. ההתאמה עובדת גם כש Claude מגיע לקובץ דרך נתיב symlink לספריית הפרויקט, למשל ב checkout שהוא symlink.

כל תבנית יחסית לספריית הבסיס של הכלל:

• כללי פרויקט: הספרייה שמכילה את תיקיית .claude של הכלל
• כללים ברמת המשתמש: ספריית העבודה הראשית של הסשן

כדי שכללים שתחומים לנתיב ייטענו עבור קבצים ב git worktree אח, הפעילו את Claude Code ב worktree הזה או העבירו את הסשן לשם עם /cd.

השתמשו בתבניות 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 משתמש בכל תבנית שהייתה חורגת מהתקציב בלי הרחבה, והסוגריים המסולסלים המילוליים שלה לא מתאימים לאף קובץ.

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

#שדות frontmatter של כלל

מגדירים כלל עם YAML frontmatter בין סמני --- בראש הקובץ. paths הוא השדה היחיד ש Claude Code קורא מכלל. כל שדה אחר מתעלמים ממנו בלי שגיאה. Claude Code מסיר את ה frontmatter לפני טעינת הכלל להקשר.

אם ה YAML בין הסמנים לא מתפרס, Claude Code מתעלם מה frontmatter וטוען את הכלל כאילו אין לו paths. הריצו claude --debug כדי לראות את שגיאת הפירוס.

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

הספרייה .claude/rules/ תומכת ב symlinks, כך שאפשר לתחזק קבוצת כללים משותפת ולקשר אותם לכמה פרויקטים. 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

אם מפנים symlink של .claude/rules/ או CLAUDE.md לנתיב רשת כמו שיתוף UNC \\server\share או נתיב תחת /net או /Network, ההוראות המקושרות לא נטענות. Claude Code לא עוקב אחרי הקישור, כי חיפוש נתיב כזה יכול ליצור קשר עם המארח שהוא מציין. נתיבי \\wsl$ לא נחשבים לנתיבי רשת.

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

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

~/.claude/rules/
├── preferences.md    # ההעדפות האישיות שלכם לכתיבת קוד
└── workflows.md      # תהליכי העבודה המועדפים עליכם

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

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

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

#פריסת CLAUDE.md לכל הארגון

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

1. צרו את הקובץ במיקום המדיניות המנוהלת

• 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, או כלים דומים כדי להפיץ את הקובץ למכונות המפתחים. ראו הגדרות מנוהלות לאפשרויות תצורה נוספות לכל הארגון.

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

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

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

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

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

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

CLAUDE.md מנוהל והגדרות מנוהלות משמשים למטרות שונות. השתמשו בהגדרות לאכיפה טכנית וב CLAUDE.md להנחיה התנהגותית:

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

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

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

הדוגמה הזו מחריגה 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, רק תבנית שהתאימה ליעד הקישור החריגה את הקובץ.

#AGENTS.md

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

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

[!NOTE]

קריאה ישירה של AGENTS.md דורשת Claude Code v2.1.277 או חדש יותר. בחלק מההפעלות Claude לא יכול לקרוא את AGENTS.md, אז ייבא אותו מתוך CLAUDE.md שם במקום.

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

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

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

כשאף אחד לא נכלל, זה מה ש-Claude קורא ואיך אפשר לדעת:

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

[!NOTE]

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

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

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

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

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

לפני v2.1.285, המזהה של התוסף היה agents-md@builtin, ו-Claude Code התעלם מרשומה תחת cc-plugin-agents-md@builtin. אם גם גרסאות קודמות קוראות את קובץ ההגדרות שלך, השתמש שם ב-agents-md@builtin. Claude Code v2.1.285 ומעלה קורא רשומה תחת כל אחד משני המזהים.

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

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

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

• אתה בגרסת Claude Code שלפני v2.1.277
• השתמשת ב-/plugin כדי להשבית את התוסף המובנה שקורא את AGENTS.md
• במקרים מסוימים, זו ההפעלה הראשונה אחרי שדרוג מ-v2.1.276 או מוקדם יותר. Claude קורא את AGENTS.md מההפעלה הבאה ואילך

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

#איפה AGENTS.md שונה מ-CLAUDE.md

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

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

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

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

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

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

@AGENTS.md

## Claude Code

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

אם אין צורך בתוכן ייחודי ל-Claude, גם קישור סימבולי עובד:

ln -s AGENTS.md CLAUDE.md

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

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

בכל אחת מהגישות, הרץ /context all בהפעלה הבאה שלך ואשר ש-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, פקודות, סוכני משנה ומיומנויות.

#זיכרון אוטומטי

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

• user: התפקיד שלך, המומחיות שלך, והעדפות העבודה שלך
• feedback: תיקונים שאתה נותן ל-Claude וגישות שאתה מאשר
• project: עבודה מתמשכת, מועדים, והחלטות ש-Claude לא יכול לגזור מהקוד או מהיסטוריית git
• reference: איפה למצוא מידע מחוץ לפרויקט, כמו מעקב תקלות או לוח בקרה

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

Claude לא שומר משהו בכל הפעלה. הוא מחליט מה שווה לזכור לפי השאלה אם המידע יהיה שימושי בשיחה עתידית.

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

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

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

המתג מכבה את הזיכרון האוטומטי אבל לא מפעיל אותו בחזרה בהפעלות האלה:

• הפעלת רקע
• הפעלה שאותה התחילה הפעלת Claude Code אחרת, למשל כש-Claude מריץ claude דרך כלי Bash שלו

בזמן שהזיכרון האוטומטי כבוי שם, המתג קורא off · can't be turned on here; use a session started outside Claude Code. כדי להפעיל את הזיכרון האוטומטי בחזרה, הרץ claude ישירות בטרמינל שלך והשתמש במתג /memory בהפעלה הזו.

כדי לכבות אותו לפרויקט יחיד, הגדר 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 מכבד אותו תחת אותו כלל אמון בסביבת עבודה כמו הוקים בקבצי הגדרות. בזמן ש-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 משמש כאינדקס של תיקיית הזיכרון. Claude קורא וכותב קבצים בתיקייה הזו לאורך ההפעלה שלך, ומשתמש ב-MEMORY.md כדי לעקוב אחרי מה שמאוחסן ואיפה.

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

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

#איך זה עובד

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

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

[!NOTE]

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

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

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

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

כש-Claude כותב קובץ זיכרון שמתחיל ב-frontmatter של YAML, Claude Code רושם את זמן הכתיבה בשדה frontmatter בשם modified כחותמת זמן ISO 8601. חותמת הזמן מראה כמה העובדה עדכנית, גם לך וגם ל-Claude כשהוא קורא את הזיכרון בחזרה.

#ביקורת ועריכה של הזיכרון שלך

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

#צפייה ועריכה עם /memory

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

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

כשמבקשים מ-Claude לזכור משהו, למשל "always use pnpm, not npm" או "remember that the API tests require a local Redis instance", Claude שומר את זה בזיכרון האוטומטי. כדי להוסיף הוראות ל-CLAUDE.md במקום זה, בקשו מ-Claude ישירות, למשל "add this to CLAUDE.md", או ערכו את הקובץ בעצמכם דרך /memory.

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

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

#Claude לא פועל לפי ה-CLAUDE.md שלי

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

כדי לאבחן:

• הריצו /context all ובדקו את הרשימה תחת Memory files כדי לוודא את קבצי CLAUDE.md ו-CLAUDE.local.md שאמורים להיטען בהפעלה. אם אחד חסר שם, Claude לא יכול לראות אותו. השתמשו ב-/memory כדי לפתוח ולערוך את הקבצים.
• אם מופיעה הודעת Instruction file not loaded, ראו מה זה אומר ומה לעשות.
• CLAUDE.md בתת-ספרייה של ספריית העבודה לא מופיע תחת Memory files, כי הוא נטען לפי דרישה ולא בהפעלה. כשהוא נטען, מופיעה במסוף שורת Loaded עם הנתיב שלו. כדי לבדוק קובץ חדש, צרו אותו מהמעטפת ולא על ידי בקשה מ-Claude לכתוב אותו, ואז בקשו מ-Claude לקרוא קובץ בתת-ספרייה הזאת.
• בדקו שה-CLAUDE.md הרלוונטי נמצא במיקום שנטען עבור הסשן (ראו בחירה איפה למקם קבצי CLAUDE.md).
• הפכו את ההוראות לספציפיות יותר. "Use 2-space indentation" עובד טוב יותר מ-"format code nicely."
• חפשו הוראות סותרות בין קבצי CLAUDE.md. אם שני קבצים נותנים הנחיה שונה לאותה התנהגות, Claude עשוי לבחור אחת באופן שרירותי.
• בדקו אם ההוראה שלכם מתחרה בהנחיה ש-Claude Code מוסיף בעצמו. אם CLAUDE.md שלכם קובע כללי commit או pull request, כבו את הכללים המובנים עם includeGitInstructions וקבעו את טקסט הייחוס עם attribution.

אם ההוראה היא משהו שחייב לרוץ בנקודה מסוימת, למשל לפני כל commit או אחרי כל עריכת קובץ, כתבו אותה כ-hook. Hooks רצים כפקודות מעטפת באירועי מחזור חיים קבועים, והם חלים בלי קשר למה ש-Claude מחליט לעשות.

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

[!TIP]

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

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

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

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

כדי לבדוק אם Claude קרא את AGENTS.md, הריצו /memory וחפשו את הנתיב שלו ברשימה.

לפני v2.1.280, /memory ו-/context לא הציגו AGENTS.md ש-Claude קרא ישירות. בגרסאות האלה, בקשו מ-Claude לומר מה אומרות הוראות הפרויקט שלו.

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

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

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

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

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

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

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

[!NOTE]

שמרו כל קובץ כללים לפי נתיב בתוך מגבלת הגודל שלו לכל קובץ, כי Claude מקבל רק את תחילת הקובץ שחורג ממנה.

#Claude מתעלם מסוף ה-CLAUDE.md שבתת-ספרייה

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

בדקו אם הקובץ חורג מהמגבלה, וצמצמו אותו אם כן:

1. ודאו שהמגבלה חלה על הקובץ. המגבלה חלה על הקבצים האלה, שנטענים לפי דרישה:
   • CLAUDE.md ו-CLAUDE.local.md בתת-ספרייה של הספרייה שבה הפעלתם את Claude Code, והקבצים שהם מייבאים עם @path
   • קבצי כללים ב-.claude/rules/ של תת-ספרייה
   • כללים לפי נתיב ב-.claude/rules/ של הפרויקט או ב-~/.claude/rules/
2. מצאו את המגבלה לחלון ההקשר של הסשן:
   • 200K context window: 40,000 תווים
   • 1M context window: 200,000 תווים ב-Claude Opus 4.6 וב-Claude Sonnet 4.6, ו-150,000 תווים במודלים מאוחרים יותר
3. ב-Bash או ב-Zsh, הריצו wc -m path/to/CLAUDE.md כדי להדפיס את מספר התווים בקובץ.
4. השוו את המספר למגבלה:
   • Over the limit: קצרו את הקובץ, או העבירו חלק ממנו לקובץ כללים אחד או יותר, שכל אחד מהם נספר מול המגבלה בפני עצמו
   • Under the limit: חפשו סיבה אחרת תחת Claude לא פועל לפי ה-CLAUDE.md שלי

לפני v2.1.309, Claude Code לא החיל את המגבלה הזאת על קבצים שנטענים לפי דרישה.

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

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

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

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

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

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