CLAUDE.md וזיכרון אוטומטי: איך Claude Code זוכר את הפרויקט שלכם

Q: איפה כדאי לשים את הקובץ בפרויקט עם כמה תיקיות משנה?

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

Q: איך אני יודע שהקובץ שלי באמת נטען לתוך השיחה?

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

מאת צוות מדיה דיל · 08.08.2026 · AI · 8 דק׳

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

כל סשן חדש של Claude Code מתחיל מ־context window ריק לגמרי. אין לו זיכרון מהשיחה של אתמול, אין לו מושג שכבר הסברתם לו פעמיים שאתם עובדים עם pnpm ולא npm, ואין לו שום רמז שקבצי ה־API handlers חיים דווקא ב־src/api/handlers/ ולא במקום אחר. זה נשמע כמו בעיה - אבל Claude Code פתר אותה בשני מנגנונים משלימים: קובץ CLAUDE.md שאתם כותבים, וזיכרון אוטומטי (auto memory) ש-Claude בונה לבד תוך כדי עבודה. שני המנגנונים נטענים בתחילת כל שיחה, ומי שמבין איך להשתמש בהם נכון חוסך לעצמו הרבה חזרות מיותרות.

מה זה CLAUDE.md ולמה זה משנה

CLAUDE.md הוא קובץ markdown רגיל שכותבים בעצמכם, ו-Claude Code קורא אותו בתחילת כל סשן עבודה. זה לא הגדרה טכנית אכיפה כמו permission - זה context. Claude מתייחס לתוכן כאל הנחיות שהוא משתדל לעקוב אחריהן, לא כללים שנאכפים באופן מוחלט. אם צריך לחסום פעולה בוודאות, השימוש הנכון הוא ב-hook מסוג PreToolUse ולא בהנחיה בקובץ. אבל לרוב מה שרוצים זה בדיוק את זה: לתת ל-Claude הקשר - מה הארכיטקטורה, אילו ספריות מועדפות, אילו בדיקות חובה להריץ לפני commit, ואיך עושים code review בפרויקט הזה.

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

איפה שמים את הקובץ - היררכיה וסדר טעינה

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

Managed policy - קובץ שמנוהל ברמת הארגון על ידי IT, למשל ב-/etc/claude-code/CLAUDE.md בלינוקס. חל על כל המשתמשים בארגון ולא ניתן להחריג אותו בהגדרות אישיות. משמש למדיניות אבטחה וסטנדרטים ארגוניים.
User instructions - הקובץ האישי ב-~/.claude/CLAUDE.md. חל על כל הפרויקטים שלכם, ומתאים להעדפות אישיות כמו סגנון קוד או קיצורי דרך בכלים.
Project instructions - ./CLAUDE.md או ./.claude/CLAUDE.md בשורש הפרויקט. זה הקובץ שהצוות משתף דרך גיט - ארכיטקטורה, קונבנציות קוד, workflow משותף.
Local instructions - ./CLAUDE.local.md, מיועד להעדפות אישיות בתוך פרויקט ספציפי, כמו כתובות סביבת sandbox או נתוני בדיקה. את הקובץ הזה מוסיפים ל-gitignore כדי שלא יעלה לריפו המשותף.

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

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

מה הופך CLAUDE.md לטוב - עם דוגמה קונקרטית

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

שלושה עקרונות שעושים את ההבדל: מבנה ברור עם כותרות ותבליטים, כי Claude סורק מבנה בדיוק כמו קורא אנושי; ספציפיות שאפשר לאמת - "השתמשו בהזחה של 2 רווחים" עדיף על "פרמטו את הקוד יפה", ו"הריצו npm test לפני commit" עדיף על "בדקו את השינויים"; ועקביות - אם שתי הנחיות סותרות זו את זו, Claude עלול לבחור אחת מהן באופן שרירותי, אז כדאי לעבור מדי פעם על הקבצים ולנקות סתירות ותוכן מיושן.

איך נראה CLAUDE.md טוב בפועל? לדוגמה, קובץ פרויקט Next.js קטן יכול לכלול סעיפים כאלה:

פקודות build ובדיקה - למשל npm run dev להרצה מקומית, npm run test לפני כל commit, ו-npm run lint כחלק מה-CI.
ארכיטקטורה - היכן חיים ה-API routes, איך מנוהל ה-state הגלובלי, ואיפה ה-schema של מסד הנתונים.
קונבנציות - הזחה, שמות קבצים, מוסכמות import, ומתי להשתמש ב-TypeScript strict mode.
ספריות מועדפות - למשל Tailwind ולא CSS מותאם אישית, או Zod לוולידציה במקום פתרון תפור בבית.
checklist לביקורת קוד - נקודות שחוזרות שוב ושוב בסקירות, כמו טיפול בשגיאות רשת או בדיקת הרשאות לפני כתיבה ל-DB.

כל שורה כזו היא מידע ש-Claude לא היה יכול לנחש מקריאת הקוד בלבד, או שהוא כן יכול לנחש אבל עדיף לחסוך לו את הניחוש. אגב, בדיוק בגלל זה יש ל-/doctor בדיקת "trim" שמציעה לגזום מ-CLAUDE.md תוכן ש-Claude יכול לגזור בעצמו מהקוד - כמו מבנה תיקיות או רשימת תלויות - ולשמור רק על מה שבאמת שונה מברירת המחדל של הכלים או דורש הקשר והנמקה.

אם רוצים לשמור על קובץ קצר בלי לאבד מידע, אפשר לייבא קבצים נוספים בתחביר @path/to/file - למשל @README לסקירת הפרויקט או @docs/git-instructions.md לתהליך גיט. חשוב לדעת שהקבצים המיובאים נטענים במלואם בהפעלה בדיוק כמו הקובץ הראשי, כך שהייבוא עוזר לארגון אבל לא מקטין את צריכת ה-context. ולמי שכבר משתמש ב-AGENTS.md לכלי AI אחרים - Claude Code לא קורא את AGENTS.md ישירות, אלא רק CLAUDE.md, אז הפתרון הנקי הוא ליצור CLAUDE.md שמייבא את @AGENTS.md ומוסיף מתחתיו הנחיות ספציפיות ל-Claude.

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

זיכרון אוטומטי - מה זה ואיך זה שונה מ-CLAUDE.md

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

הזיכרון האוטומטי דלוק כברירת מחדל. ניתן להפעיל או לכבות אותו דרך פקודת /memory בתוך סשן, שמשנה את השדה autoMemoryEnabled בהגדרות המשתמש. אפשר גם לכבות אותו רק בפרויקט ספציפי על ידי הגדרת autoMemoryEnabled: false בקובץ ההגדרות של אותו פרויקט, או דרך משתנה סביבה CLAUDE_CODE_DISABLE_AUTO_MEMORY=1.

מבחינת אחסון, לכל פרויקט יש תיקיית זיכרון משלו תחת ~/.claude/projects/<project>/memory/, כאשר הנתיב נגזר מריפו הגיט - כך שכל ה-worktrees ותתי-התיקיות של אותו ריפו חולקים תיקיית זיכרון אחת. בתוך התיקייה יש קובץ מרכזי בשם MEMORY.md שמשמש כאינדקס תמציתי, ולצדו קבצי נושא נוספים כמו debugging.md או api-conventions.md ש-Claude יוצר לפי הצורך. רק 200 השורות הראשונות של MEMORY.md, או עד 25KB - הקטן מביניהם - נטענים בתחילת כל שיחה; קבצי הנושא לא נטענים אוטומטית, אלא Claude פותח אותם לפי הצורך בכלי הקריאה הרגילים שלו במהלך השיחה.

נקודה חשובה נוספת: הזיכרון האוטומטי הוא local למכונה. הוא לא משותף בין מכונות שונות או סביבות ענן שונות, גם אם מדובר באותו ריפו. זה שונה במובהק מ-CLAUDE.md בפרויקט, שמשותף לכל הצוות דרך בקרת גרסאות. כשרואים בממשק הודעות כמו "Saved 2 memories" או "Recalled 2 memories", זה בדיוק הרגע שבו Claude קורא או כותב לקבצים האלה. וכדי לדעת בדיוק מה נשמר, אפשר בכל רגע להריץ /memory ולפתוח את תיקיית הזיכרון האוטומטי - כל הקבצים הם markdown רגיל שאפשר לקרוא, לערוך או למחוק בעצמכם.

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

תרחיש עבודה אמיתי בצוות

נניח צוות פיתוח בן חמישה אנשים שעובד על מוצר SaaS עם backend ב-Node ו-frontend ב-React. בתחילת הפרויקט מישהו מריץ /init, ו-Claude סורק את הקוד ובונה CLAUDE.md ראשוני עם מבנה התיקיות, פקודות ההרצה והבדיקה, וסגנון הקוד שהוא מזהה. הקובץ הזה נכנס ל-commit ונשמר בגיט, כך שכל מי שמצטרף לצוות מקבל אותו הקשר בסיסי כבר מהיום הראשון.

במהלך השבועות הבאים, כל פעם שמפתח מתקן את Claude על משהו - "אנחנו לא משתמשים ב-any ב-TypeScript", "תמיד תריץ migration לפני שאתה בודק endpoint חדש" - הוא בעצם מספק שני סוגי מידע. תיקון שהוא כלל כללי ורלוונטי לכל הצוות שווה להוסיף ידנית ל-CLAUDE.md, פשוט בבקשה כמו "תוסיף את זה ל-CLAUDE.md". לעומת זאת, תובנה נקודתית כמו "הבדיקות של ה-API דורשות מופע Redis מקומי" יכולה פשוט להיאמר בשיחה כ"תזכור ש..." - וClaude ישמור אותה בעצמו לזיכרון האוטומטי, בלי לגעת בקובץ המשותף בכלל.

ההפרדה הזו חשובה כי היא שומרת על CLAUDE.md נקי ומתומצת עבור כל הצוות - רק כללי אצבע ורציונל שבאמת חוזרים - בעוד שהזיכרון האוטומטי אוגר את כל הבלגן היומיומי של פרטים טכניים שאף אחד לא רוצה לכתוב ידנית בקובץ המשותף, אבל שעדיין שימושי שClaude יזכור בפעם הבאה על אותה מכונה. בפרויקטים גדולים יותר, כשה-CLAUDE.md מתחיל להתנפח, מפצלים חלק מההנחיות לכללים ממוקדי-נתיב תחת .claude/rules/ - למשל כלל שחל רק על קבצים תחת src/api/**/*.ts ונטען לתוך ה-context רק כשClaude עובד בפועל עם קבצי API.

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

שאלות נפוצות

מה בדיוק ההבדל בין CLAUDE.md לזיכרון אוטומטי?

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

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

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

איך אני יודע שהקובץ שלי באמת נטען לתוך השיחה?

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

אפשר לכבות את הזיכרון האוטומטי אם לא רוצים בו?

כן. הוא דלוק כברירת מחדל, וניתן לכבות אותו גלובלית דרך המתג ב-/memory, שמעדכן את autoMemoryEnabled בהגדרות המשתמש, או רק לפרויקט מסוים על ידי הוספת אותו שדה עם ערך false בהגדרות הפרויקט. יש גם אפשרות לכבות דרך משתנה הסביבה CLAUDE_CODE_DISABLE_AUTO_MEMORY=1.

מה קורה אם ה-CLAUDE.md שלי גדל מדי?

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

הזיכרון האוטומטי משותף בין חברי הצוות או בין מחשבים?

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

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

תגיות: Claude Code · CLAUDE.md · זיכרון אוטומטי · auto memory · AI Agent · כלי פיתוח AI · ניהול פרויקטים בקוד

← חזרה לבלוג · צור קשר