📘 תיעוד 15

תנו לקלוד לתאם עבודה מתמשכת באמצעות Projects

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

הערה: פרויקטים (Projects) נמצאים בבטא ציבורית בתוכניות Pro ו-Max ונפרסים בהדרגה, החל מחשבונות שהשתמשו ב-הפעלות ענן ושאין להם פרויקטים קיימים בצ'אט של claude.ai או ב-Cowork. הם עדיין אינם זמינים בתוכניות Team או Enterprise. אם Projects אינו מופיע בסרגל הצד ב-claude.ai/code או בלשונית Code של אפליקציית שולחן העבודה, הפריסה טרם הגיעה לחשבון שלכם, ותוכלו להצטרף לרשימת ההמתנה. הדף הפעלת סוכנים במקביל מפרט במה תוכלו להשתמש בינתיים.

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

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

• שליחת עבודה למקום אחד: הדביקו דוח באג, עקבת מחסנית (stack trace) או רשימת משימות לתוך השיחה בכל פעם שמשהו עולה. קלוד מתחיל שרשור עבור כל משימה או מעביר אותה לשרשור שכבר עובד באותו תחום, ועונה על שאלות מהירות במקום.
• הגדרת הקשר פעם אחת: כל שרשור חדש מתחיל עם המאגרים, ההוראות והזיכרון של הפרויקט, כך שכלל שתציינו פעם אחת, כגון לאיזה ענף לכוון, מגיע לכולם.
• עזיבה וחזרה לעבודה גמורה: כשאתם חוזרים שעה לאחר מכן או למחרת בבוקר, חלונית ה-Overview מראה אילו שרשורים הסתיימו, אילו בקשות משיכה (pull requests) מוכנות לבדיקה, ואיזה שרשור ממתין לתשובה שלכם.

אם אתם כבר יודעים איזו עבודה אתם רוצים שפרויקט יריץ, עברו ישירות אל יצירת פרויקט.

#מתי להשתמש בפרויקט

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

• יעד אחד על פני מאגרים רבים: "התאם כל שירות לתצורת ה-lint החדשה." קלוד יכול להריץ שרשור לכל מאגר, כל אחד עם בקשת משיכה משלו, וחלונית ה-Overview מראה אילו מהם מוכנים לבדיקה.
• תחום שאתם ממשיכים להזין: הבאגים, עקבות המחסנית ובקשות הבדיקה עבור שירות אחד, מודבקים לתוך השיחה כשהם מגיעים אליכם. מכשול שאתם אומרים לקלוד לזכור לאחר תיקון אחד נשמר ב-זיכרון הפרויקט עבור התיקון הבא.
• בנייה או הגירה שגדולות מהפעלה אחת: "בנה את מה ש-docs/spec.md מתאר" או "העבר את האפליקציה מה-ORM המיושן." העבודה מתפצלת לשרשורים שכל אחד מהם לוקח חלק, החלטות שביקשתם מקלוד לזכור בשלב מוקדם מגיעות לשרשורים המאוחרים יותר, ושינויי המפרט ובאגים שאתם מוצאים במהלך הבנייה נכנסים לאותה שיחה.
• עבודה שאינה קוד: תיקייה של חוזים או ייצוא פניות תמיכה שאתם חוזרים אליהם שוב ושוב עם שאלות חדשות, כגון "מצא את עשר טעויות האינטגרציה הנפוצות ביותר בפניות אלה." העלו את המסמכים במקום להוסיף מאגר, והשרשורים יספקו כל סיכום כקובץ בלשונית Library של הפרויקט.

בכל אחד מהמקרים האלה תוכלו לשלוח מקבץ משימות, לומר לקלוד להתחיל מבלי לבקש מכם לאשר, להתרחק, ולמצוא את השרשורים שזקוקים לכם תחת Waiting on you כשתחזרו, או לבקש מקלוד להגדיר חלק מהעבודה לפי לוח זמנים כ-רוטינה (routine). אם אחד המצבים האלה מתאר את המצב שלכם, צרו פרויקט.

#מתי משהו אחר מתאים יותר

שרשורים עובדים על מאגרי GitHub ועל הקבצים, התיקיות ותיקיות Google Drive שאתם מעלים לפרויקט, ולא על קבצים או כלים שקיימים רק במחשב שלכם. משהו אחר מתאים יותר במקרים אלה:

• משימה אחת שמתאימה להפעלה בודדת: "תקן את מבחן ההתחברות הלא יציב." הפעילו הפעלת ענן בעצמכם.
• עבודה הדורשת כלים או שירותים שרק המחשב שלכם יכול להגיע אליהם: מסד נתונים מקומי, אמולטור מכשירים, API מאחורי ה-VPN שלכם. השתמשו בהפעלה מקומית, או ב-תצוגת סוכנים (agent view) כדי להריץ כמה בבת אחת. אם העבודה דורשת רק קבצים מקומיים, העלו אותם לפרויקט במקום זאת.
• משימה אחת שחוזרת על עצמה לפי לוח זמנים ללא שיחה סביבה: "פרסם דוח תלויות בכל יום שני." צרו רוטינה בפני עצמה.
• מספר אנשים שנותנים לקלוד עבודה ומכוונים אותו יחד בערוץ Slack: עיינו ב-Claude Tag.

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

#כיצד פרויקט מאורגן

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

• שיחת הפרויקט: הפעלה אחת ארוכת טווח שבה קלוד פועל כמתאם. הוא מקבל את מה שאתם שולחים, מחליט מה יהפוך לשרשור, ועוקב אחר כל שרשור שהתחיל. הוא רואה מה השרשורים מדווחים בחזרה, ולא כל צעד שהם עושים.
• שרשורים (Threads): העובדים. כל אחד מהם הוא הפעלת ענן נפרדת עם חלון הקשר משלו שמבצעת חלק אחד של עבודה בענף משלה, פותחת בקשת משיכה (pull request) כאשר העבודה דורשת זאת, ומדווחת בחזרה לשיחה כשהיא מסתיימת.
• מה שכל שרשור מתחיל איתו:
  • המאגרים והקבצים של הפרויקט, בנוסף ל-הוראות ולזיכרון שלו
  • קובץ ה-CLAUDE.md, המיומנויות (skills) והתוספים (plugins) ב-כל אחד ממאגרי הפרויקט, ובפרויקט עם מאגר יחיד, גם כללי ההרשאות וה-hooks של אותו מאגר
  • ה-מחברים (connectors) בחשבון ה-claude.ai שלכם
  • סביבת ענן שקובעת את הגישה שלו לרשת, משתני סביבה, אישורי API וכלים מותקנים
• חלונית ה-Overview: המקום שבו אתם רואים את כל השרשורים בבת אחת ומי מהם זקוק לכם. הלשוניות הנוספות שלה הן Library עבור הקבצים שהוספתם והקבצים שהשרשורים הפיקו, Pull requests עבור אלו שהשרשורים פתחו, ו-Routines עבור עבודה מתוזמנת בפרויקט.

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

כך החלקים האלה מתחברים, מכם דרך השיחה אל השרשורים שמבצעים את העבודה, כאשר חלונית Overview עוקבת אחר מצבם:

#יצירת פרויקט

אתם יוצרים פרויקטים ומשתמשים בהם ב-claude.ai/code, בלשונית Code של אפליקציית שולחן העבודה, או באפליקציית Claude לנייד עבור iOS ועבור Android. בדפדפן ובאפליקציית שולחן העבודה יש שתי דרכים להתחיל פרויקט:

• מאפס, כשאתם יודעים את רצף העבודה שאתם רוצים שקלוד יריץ: פתחו את תיבת הדו-שיח New project ותנו לו שם. הסעיף התחלת פרויקט חדש מאפס מלווה את שלבי תיבת הדו-שיח.
• מהפעלת ענן שכבר מבצעת את העבודה: בחרו Continue as a project מתפריט אותה הפעלה, וקלוד יציע את הגדרת הפרויקט מתוך מה שההפעלה עשתה. עיינו בסעיף התחלה מהפעלת ענן קיימת.

בכל אחת מהדרכים, בדקו תחילה את דרישות הקדם.

#בדיקת דרישות הקדם

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

• תוכנית: אתם בתוכנית Pro או Max ו-Projects מופיע בסרגל הצד שלכם.
• GitHub, אם הפרויקט יעבוד על קוד: הקוד שלכם נמצא ב-github.com ולא ב-GitHub Enterprise Server, GitLab או Bitbucket, לחשבון GitHub המחובר שלכם יש הרשאת push אליו, ואפליקציית Claude GitHub App מותקנת בו. אם חיברתם את GitHub באמצעות /web-setup, אסימון זה מאפשר להפעלות הענן האחרות שלכם לגשת למאגר אך אינו מספיק עבור שרשורי פרויקט, הזקוקים לאפליקציית Claude GitHub App. הסעיף הגדרת גישה ל-GitHub מכיל את השלבים.
• רשת, אישורים וכלים: אלה מגיעים מ-סביבת הענן של הפרויקט. סביבת ברירת המחדל כבר ניגשת אל מאגרי חבילות נפוצים, לכן בדקו זאת רק אם העבודה זקוקה לדומיינים אחרים, לסוד (secret) או לכלי שאינו מותקן מראש. אם העבודה דורשת שרת MCP, ודאו שהוא מופיע כמחובר ב-מחברי claude.ai שלכם.

#התחלת פרויקט חדש מאפס

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

1. פתחו את Projects: ב-claude.ai/code או בלשונית Code של אפליקציית שולחן העבודה, בחרו Projects בסרגל הצד השמאלי, ולאחר מכן בחרו New project. בדפדפן תוכלו גם לעבור ישירות אל claude.ai/code/projects/browse.

2. מלאו את תיבת הדו-שיח New project: הגדירו את היקף הפרויקט לרצף עבודה אחד שתמשיכו להוסיף לו, כגון כל מה שנדרש כדי לשמור על API אחד מתחת ליעד זמן ההמתנה שלו. בסעיף מתי להשתמש בפרויקט יש דוגמאות נוספות. לאחר מכן מלאו את שדות תיבת הדו-שיח:

   • Name: כיצד הפרויקט מופיע ברשימת Projects.
   • Goal (אופציונלי): שורה אחת המתארת מה אתם מנסים להשיג, כגון "Hold p95 API latency under 200 ms". קלוד בשיחה פועל לקראת יעד זה. ללא יעד, קלוד עובד מתוך המשימות שאתם שולחים, ותוכלו להוסיף יעד מאוחר יותר ב-Project settings > General.
   • Context (אופציונלי): מאגרי GitHub שעליהם פרויקט זה עובד, בתוספת קבצים, תיקיות או תיקיות Google Drive שעל השרשורים לקרוא. לחצו על Add עבור כל אחד מהם. הוסיפו את המאגרים שרוב המשימות זקוקות להם ולא כל מאגר שהעבודה עשויה לגעת בו: הסעיף החלטה אילו מאגרים להוסיף מכסה את הבחירה, ותוכלו להוסיף עוד מאוחר יותר ב-Project settings > Environment.

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

3. צרו את הפרויקט: לחצו על Create project. שיחת הפרויקט נפתחת עם תיבת הודעות בתחתית, שבה אתם מתארים עבודה עבור קלוד.

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

• להתחיל שרשור אחד שחוקר את המאגר מבלי לשנות דבר ומציע צעדים הבאים, אם לפרויקט יש מאגר שהוא יכול לקרוא.
• לפרסם Setup recommendations שנלקחו מהפעלות הענן האחרונות שלכם: מאגרים להוספה, רוטינות ליצירה ושרשורים שהוא יכול להתחיל. כל מאגר ורוטינה מומלצים מוגדרים כמופעלים כברירת מחדל. כבו את אלה שאינכם רוצים, ואז לחצו על Update setup כדי להוסיף את השאר, או התעלמו מההמלצות ותארו את העבודה בעצמכם.

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

#התחלה מהפעלת ענן קיימת

אם כבר יש לכם הפעלת ענן שמבצעת עבודה השייכת לפרויקט, פתחו את תפריט ההפעלה בסרגל הצד ובחרו Continue as a project או Move to project:

• Continue as a project: יוצר פרויקט חדש שנקרא על שם ההפעלה ופותח אותו. קלוד קורא את ההפעלה ומפרסם Setup recommendations בשיחה כדי שתאשרו אותן. ההפעלה המקורית נשארת ברשימת ההפעלות שלכם, ואם היא הייתה באמצע תור היא ממשיכה לרוץ, לכן עצרו אותה בעצמכם אם אינכם רוצים ששתיהן יעבדו בו-זמנית. אם תשתמשו במקום זאת בבאנר Set up project שעשוי להופיע מעל תיבת ההודעות של הפעלת ענן, התוצאה זהה, פרט לכך שהתור הפעיל של ההפעלה נעצר ברגע שהפרויקט נפתח.
• Move to project: מביא את עבודת ההפעלה לתוך פרויקט קיים. הוא מפרסם הודעה בשיחת אותו פרויקט ומבקש מקלוד לקרוא את ההפעלה ולהמשיך מהמקום שבו היא הפסיקה, ועבודה חדשה ממשיכה בשרשורים של הפרויקט עצמו. ההפעלה המקורית נשארת ברשימת ההפעלות שלכם, ללא שינוי.

#הגדרת גישה ל-GitHub

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

1. חיבור חשבון GitHub שלכם: אם לא השתמשתם ב-claude.ai/code בעבר, הביקור הראשון שלכם מלווה אתכם בחיבור GitHub: עיינו בסעיף חיבור GitHub. אחרת, השתמשו באחת מ-אפשרויות האימות של GitHub.

2. התקנת Claude GitHub App על מאגרי הפרויקט: התקינו את Claude GitHub App והעניקו לה גישה למאגרים שבהם הפרויקט ישתמש. במאגר שבבעלות ארגון GitHub, רק בעלים של הארגון יכול להשלים את ההתקנה: אם אינכם בעלים, GitHub שולח לבעלים בקשת התקנה והפרויקט אינו יכול להשתמש במאגר עד שהם יאשרו אותה.

3. אישור SSO עבור ארגונים שאוכפים זאת: אם ארגון GitHub אוכף SAML SSO, חברו מחדש את GitHub ואשרו את אפליקציית Claude עבור אותו ארגון. עד שתעשו זאת, מאגרים פרטיים של אותו ארגון לא יופיעו בתיבת הדו-שיח New project או ב-Project settings > Environment.

כאשר אחד מהשלבים האלה אינו מושלם, תיבת הדו-שיח New project ודף הפרויקט מציינים את השלב החסר ומקשרים למקום שבו אתם משלימים אותו. השלימו את השלב שם, ולאחר מכן לחצו על Check again אם תיבת הדו-שיח מציעה זאת. אם מאגר עדיין חסר מהרשימה לאחר מכן, פתחו את התקנת Claude GitHub App ב-GitHub, בכתובת github.com/settings/installations עבור חשבון אישי, וודאו שהמאגר רשום תחת Repository access. עבור הודעות השגיאה ששרשור או הפרויקט מדווחים כאשר הגישה עדיין שגויה, עיינו בסעיף שגיאות גישה למאגר.

#עבודה בפרויקט

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

#המקבץ הראשון שלכם

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

1. כתבו הוראות פרויקט: התקציר שממנו מתחיל כל שרשור, כגון לאיזה ענף לכוון, כיצד שרשור בודק את עבודתו ומה דורש את אישורכם מראש.
2. שלחו חלק קטן אחד מהעבודה האמיתית, או התחילו את אחד השרשורים שקלוד הציע אם הוא הציע כאלה, ופתחו את השרשור כשהוא מסתיים כדי לראות כיצד הוא מדווח בחזרה ומה הוא עשה בענף שלו. אם הוא הניח משהו לא נכון או שלא הצליח להגיע למה שהיה צריך, הסעיף שרשורים ניחשו או נתקעו במקום לשאול מכסה היכן לתקן זאת.
3. בדקו את Thread model ואת Thread effort ב-Project settings > General. פרויקט חדש מריץ כל שרשור על Opus במאמץ גבוה, מה שצורך מהתוכנית שלכם הכי מהר: הסעיף בחירת מודלים ואפשור לקלוד לנהל הקשר מכסה את החלופות.
4. בקשו מקלוד להציע שרשורים לפני הפעלתם ולהריץ כמה בודדים בכל פעם, והסירו את המגבלות האלה ברגע שכמה שרשורים חוזרים כפי שאתם רוצים.

#שליחת עבודה וקריאת תוצאות

קלוד מחליט לאן מגיעה כל הודעה שאתם שולחים בשיחה:

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

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

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

לפעמים קלוד מציע שרשורים במקום להתחיל אותם, ברשימת Suggested threads. לחצו על החץ בהצעה כדי להתחיל את אותו שרשור. כאשר מוצעים כמה ברשימה, כפתור מתחת לרשימה מתחיל את כולם.

#בדיקת בקשת המשיכה של שרשור

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

• ענף: עובד על ענף חדש, שהתחיל מענף ברירת המחדל של המאגר.
• בקשת משיכה (Pull request): פותח אחת כשאתם מבקשים, ויכול לפתוח אחת בעצמו עבור תיקון באג או שינוי קונקרטי אחר.
• לאחר שהיא נפתחת: עוקב אחר בקשת המשיכה כאשר תיקון אוטומטי (auto-fix) מופעל, בין אם תיקון אוטומטי מופעל עבור הפעלות הענן האחרות שלכם ובין אם לא. הוא דוחף תיקונים כאשר CI נכשל, מתייחס להערות סקירה, ומשיב בשרשור כאשר הבדיקות עוברות ובקשת המשיכה מוכנה עבורכם.

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

• Resolve conflicts, Fix CI, Address comments ו-Merge it שולחים הוראה זו לשרשור כהודעה מכם, כך שתוכלו להנחות את השרשור בעצמכם במקום לחכות שהוא יגיב לבקשת המשיכה.
• Review PR פותח את בקשת המשיכה ב-GitHub.
• Create PR מופיע כאשר שרשור במצב המתנה (idle) דחף ענף אך לא פתח בקשת משיכה. לחיצה עליו יוצרת את בקשת המשיכה ישירות מאותו ענף במקום לשלוח לשרשור הוראה לפתוח אחת.

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

#מעקב אחר מה שזקוק לכם ב-Overview

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

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

לשונית ה-Threads בחלונית מקבצת שרשורים לפי מצב:

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

#פתיחת שרשור כשאתם זקוקים לשליטה

לחצו על כרטיס של שרשור בשיחה או על השורה שלו ב-Overview כדי לפתוח את התמליל שלו בחלונית ה-Overview. משם תוכלו:

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

#בחירת מודלים ואפשור לקלוד לנהל הקשר

הגדירו מודלים ורמת מאמץ ב-Project settings > General. פרויקט חדש מריץ את Opus בכל מקום, עם רמת מאמץ (effort) גבוהה עבור שרשורים ומאמץ נמוך עבור השיחה:

• Thread model ו-Thread effort חלים על שרשורים. כדי להשתמש במודל שונה עבור משימה אחת, בקשו זאת במשימה: עבור שרשור שכבר רץ, השתמשו בבורר המודלים של אותו שרשור.
• Coordinator model ו-Coordinator effort חלים על קלוד בשיחת הפרויקט.

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

#כוונון האופן שבו קלוד מנהל פרויקט

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

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

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

#שחרור חסימה של שרשור הממתין לאישור

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

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

#מתן הקשר קבוע לפרויקט

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

התפריט Project settings > Memory מפרט קבצים אלה תחת Auto memory, מכיוון שקלוד כותב אותם בעצמו כשהוא עובד בפרויקט. הם נפרדים מ-הזיכרון האוטומטי ש-Claude Code שומר במחשב שלכם, למרות ששניהם משתמשים באינדקס MEMORY.md. זיכרון הפרויקט נפרד גם מקובצי ה-CLAUDE.md שבמאגרי הפרויקט. כל שרשור עדיין קורא את קובצי ה-CLAUDE.md האלה מהשכפול שלו כשהוא מתחיל, לכן שימו הוראות לגבי מאגר ב-CLAUDE.md שלו והערות לגבי הפרויקט בזיכרון הפרויקט.

#כתיבת הוראות פרויקט

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

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

לדוגמה:

This project holds p95 latency for the payments API under 200 ms: profiling, query and caching fixes, and the dependency upgrades that come with them, in the payments-api repository.

- Branch from main and open one draft pull request per thread.
- Before you call work done, run `make test` and `make lint` and paste the summary lines in your final message.
- If you can't reach something you need, such as a repository, a secret, an API, or a connector, say exactly what's missing in your first message and stop. Don't substitute, mock, or guess.
- Don't merge, force-push, or change CI configuration without asking me in the thread.

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

#החלטה אילו מאגרים להוסיף

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

• הוספה לפרויקט: בתיבת הדו-שיח New project, ב-Project settings > Environment, או על ידי בקשה מקלוד בשיחה להוסיף אותו לפרויקט. כל שרשור מאותו רגע משכפל אותו ומתחיל כשקובץ ה-CLAUDE.md והמיומנויות שלו טעונים, בין אם המשימה נוגעת בו ובין אם לא. מעבר ממאגר אחד למספר מאגרים משנה גם את מה ששרשורים לוקחים מקובץ ה-.claude/settings.json של כל מאגר: עיינו בסעיף מה שרשורים לוקחים מהמאגרים שלכם.
• השארתו בחוץ ואפשור לשרשורים להוסיף אותו בעת הצורך: שרשור שהמשימה שלו זקוקה למאגר שאין לפרויקט יכול להוסיף אותו לעצמו, והערה בשרשור מציינת שהוא נוסף לשרשור זה בלבד. השכפול מתבצע במהלך המשימה, כך שקובץ ה-CLAUDE.md והמיומנויות של אותו מאגר לא היו שם כשהשרשור התחיל. השרשור הבא מתחיל שוב בלעדיו. מאגר ששרשור מוסיף זקוק לאותן דרישות קדם כמו מאגר פרויקט: אפליקציית Claude GitHub App מותקנת בו והרשאת push מחשבון ה-GitHub שלכם.

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

ברגע שיש לפרויקט מאגרים, קלוד יכול להוסיף מאגרים רק מבעל חשבון GitHub שהפרויקט כבר משתמש בו, בין אם הוא מוסיף מאגר לפרויקט ובין אם שרשור מוסיף מאגר לעצמו. כדי להביא מאגר מבעלים אחר, הוסיפו אותו לפרויקט בעצמכם ב-Project settings > Environment.

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

#מה שרשורים לוקחים מהמאגרים שלכם

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

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

#בחירת סביבה עבור שרשורים

כל שרשור חדש מתחיל ב-סביבת הענן של הפרויקט. הסביבה קובעת לאילו דומיינים שרשורים יכולים לגשת, אילו משתני סביבה יש להם, אילו אישורי API מתווספים לבקשות שלהם ומה מתקין סקריפט ההגדרה לפני שקלוד מתחיל. שרשורים משתמשים בסביבת ברירת מחדל המתארחת אצל Anthropic עד שתבחרו סביבה ב-Project settings > Environment.

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

#העברת מיומנויות, תוספים, מחברים וכלים לתוך שרשורים

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

• מיומנויות, תת-סוכנים ופקודות: בצעו להם commit למאגר שהוספתם לפרויקט, לדוגמה מיומנות ב-.claude/skills/<skill-name>/SKILL.md. כל שרשור משכפל כל מאגר בפרויקט וטוען את .claude/skills/, את .claude/agents/ ואת .claude/commands/ מכל אחד מהם, כך שמיומנות שבוצע לה commit במאגר אחד זמינה בכל שרשור חדש. שרשורים טוענים גם את המיומנויות שאתם מפעילים עבור חשבון ה-claude.ai שלכם.
• תוספים: הוסיפו אותם ב-Project settings > Plugins: הם נטענים לכל שרשור חדש. תוספים שמאגר מצהיר עליהם ב-.claude/settings.json שלו נטענים גם כן: עיינו בסעיף מה עובר מההגדרות שלכם.
• שרתי MCP: שרשורים מקבלים את כלי ה-MCP שלהם מהמחברים (connectors) בחשבון ה-claude.ai שלכם, שהם שרתי MCP שאתם מחברים פעם אחת ב-claude.ai/customize/connectors או דרך הקישור Manage connectors ב-Project settings > Environment. כל שרשור יכול להשתמש בכולם ללא הגדרה לכל פרויקט. לשיחת הפרויקט עצמה אין מחברים, לכן שלחו עבודה הזקוקה למחבר כמשימה עבור שרשור. בפרויקט עם מאגר יחיד, שרשורים טוענים שרתי MCP גם מקובץ ה-.mcp.json של אותו מאגר. הדף כיצד מחברים מגיעים אל Claude Code מפרט את הכללים עבור הפעלות ענן ואת ההגדרות שמכבות מחברים.
• כלי שורת פקודה וחבילות: התקינו אותם ב-סקריפט ההגדרה של הסביבה.

כדי לראות אילו מחברים יש לשרשור פעיל ב-claude.ai/code, פתחו את השרשור ובחרו ב-Connectors מתפריט ה-+ לצד תיבת ההודעות שלו. כיבוי מחבר שם מסיר אותו מאותו שרשור ושומר זאת כברירת מחדל של החשבון שלכם, כך ששרשורים חדשים ושיחות claude.ai יתחילו בלעדיו עד שתפעילו אותו מחדש. שרשור קולט מחבר שהוספתם או חיברתם מחדש לאחר ההודעה הבאה שתשלחו אליו.

#מדריך הגדרות הפרויקט

אתם משנים את הגדרות הפרויקט ב-claude.ai/code או באפליקציית שולחן העבודה, לא בקובץ settings.json. פתחו את Project settings מתוך Settings בתפריט סרגל הצד של הפרויקט או מסמל גלגל השיניים בכותרת הפרויקט.

ההגדרות נשמרות תוך כדי שינוין: שדה טקסט שאתם עורכים, כגון היעד או ההוראות, מציג את Save changes ואת Discard עד שאתם יוצאים ממנו. שינויים בהוראות, במאגרים, בתוספים ובסביבה ב-Project settings מגיעים לשרשורים חדשים, ולא לשרשורים שכבר רצים.

#השהיה, העברה לארכיון או מחיקה של פרויקט

שלושת הפקדים נמצאים בתחתית Project settings > General:

• Pause: עוצר הכל בבת אחת. כל שרשור שרץ והשיחה נקטעים, שרשורים חדשים אינם מתחילים, רוטינות אינן רצות, והפרויקט אינו מקבל הודעות עד שתחדשו אותו. לחצו על Resume באותו מקום או בבאנר שמעל תיבת ההודעות של הפרויקט: שרשור מושהה ממשיך כשאתם שולחים לו הודעה לאחר מכן.
• Archive: מסתיר את הפרויקט מסרגל הצד ומעביר את השרשורים שלו לארכיון, מה שעוצר כל שרשור שרץ או עקב אחר בקשת משיכה. רוטינות בפרויקט אינן רצות בזמן שהוא בארכיון. כדי להחזיר את הפרויקט, פתחו אותו מדף הפרויקטים ולחצו על Unarchive. השרשורים שלו נשארים בארכיון עד שתבטלו את העברתם לארכיון בנפרד מרשימת ההפעלות.
• Delete: מסיר לצמיתות את הפרויקט יחד עם השרשורים שלו, הזיכרון שלו והקבצים שלו, ומכבה את הרוטינות של הפרויקט. לא ניתן לבטל פעולה זו. ענפים ובקשות משיכה שהשרשורים דחפו ל-GitHub אינם מושפעים.

#שימוש ועלות

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

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

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

#מה צורך מהתוכנית שלכם

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

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

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

#צפייה בשימוש של פרויקט והפחתתו

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

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

#כיצד פרויקטים קשורים לתכונות Claude Code אחרות

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

• Claude Tag: ‏Claude Tag הוא קלוד בערוצי ה-Slack של הצוות שלכם, בתוכניות Team ו-Enterprise. כל אחד בערוץ יכול לתת לו עבודה, כולם בערוץ רואים ומכוונים אותה, והוא משתמש בחיבורים שמנהל מערכת הגדיר עבור אותו ערוץ. פרויקט שייך לכם בלבד: אתם היחידים ששולחים לו עבודה או רואים את השרשורים שלו, הוא משתמש בגישת ה-GitHub ובמחברים שלכם, והוא זמין ב-Pro וב-Max. הדף כיצד Claude Tag שונה מ-Cowork ומ-Claude Code מציג השוואה זה לצד זה.
• הפעלות ענן (Cloud sessions): כל שרשור הוא הפעלת ענן, שקלוד מתחיל ועוקב אחריה במקומכם. הפעלת ענן שהפעלתם בעצמכם יכולה להפוך לפרויקט או להזין פרויקט באמצעות Continue as a project או Move to project.
• רוטינות (Routines): כשאתם מבקשים עבודה מתוזמנת בפרויקט, קלוד יוצר רוטינה שרצה כשרשורים באותו פרויקט ומופיעה בלשונית Routines שלו. רוטינות שאתם יוצרים מחוץ לפרויקט ממשיכות לפעול בפני עצמן.
• הפעלות מקומיות ותצוגת סוכנים (Agent view): הפעלות בטרמינל שלכם, ב-IDE או בסביבה המקומית של אפליקציית שולחן העבודה רצות במחשב שלכם ואינן יכולות להיות חלק מפרויקט. תצוגת סוכנים (Agent view) היא מסך למעקב אחר מספר הפעלות מקומיות כאלו: אין בה מתאם.
• Worktrees: כלי worktree מעניק לכל הפעלה מקומית עותק עבודה משלה של מאגר, כך שהפעלות מקבילות במחשב שלכם אינן דורסות זו את זו. שרשורים אינם זקוקים להם: כל שרשור משכפל את המאגרים שלו לתוך סביבת ענן מבודדת (sandbox) משלו ועובד על ענף משלו.
• צוותי סוכנים (Agent teams): צוות סוכנים הוא הפעלה אחת שמפעילה הפעלות של עמיתים לצוות עבור משימה בודדת, במחשב שלכם או בתוך הפעלת ענן, ומסתיים עם אותה משימה.
• פרויקטים בצ'אט של claude.ai וב-Cowork: חוויית הפרויקטים המוקדמת יותר, המקבצת שיחות וקובצי ייחוס ללא שרשורים או מתאם. פרויקטים אלה ממשיכים לפעול כפי שהם פועלים כיום עד שהחוויה המחודשת תגיע אליהם.

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

#מגבלות

• פרויקטים זמינים ב-claude.ai/code, באפליקציית שולחן העבודה ובאפליקציית Claude לנייד, ולא ב-CLI של הטרמינל או דרך Amazon Bedrock, Google Cloud's Agent Platform או Microsoft Foundry. פקודת ה-CLI בשם claude project, המנהלת את מצב Claude Code המקומי עבור ספרייה, אינה קשורה לכך.
• שרשורי פרויקט הם הפעלות ענן עם Anthropic כספק המודל. הדפים אבטחה ו-שימוש בנתונים מכסים כיצד הפעלות ענן מבודדות ומה נשמר.
• הפעלה מקומית אינה יכולה להיות חלק מפרויקט.
• סביבת הבדיקה המבודדת (sandbox) של שרשור מושהית בין תורות ומתחדשת כאשר השרשור ממשיך. אם לא ניתן לחדש את הסביבה, השרשור ממשיך משכפול רענן, כך ששינויים שלא בוצע להם commit עלולים ללכת לאיבוד. במשימות ארוכות, בקשו מקלוד לבצע commit ולדחוף עבודה בתהליך.
• פרויקט שייך למשתמש אחד. אינכם יכולים לשתף פרויקט או את השרשורים שלו עם משתמש אחר, ולתמלילי שרשור אין את אפשרות השיתוף שיש להפעלות ענן אחרות. אין בקרות ברמת הארגון עבור פרויקטים במהלך הבטא.
• שרשור שייך לפרויקט האחד שהפעיל אותו. אינכם יכולים להעביר או להעתיק שרשור לפרויקט אחר, או להוציא אותו כדי שיעמוד בפני עצמו. האפשרות Move to project פועלת רק בכיוון ההפוך: היא מביאה עבודה של הפעלת ענן לתוך פרויקט.

#פתרון בעיות

עבור הנחיות הגדרת GitHub בתיבת הדו-שיח New project, עיינו בסעיף הגדרת גישה ל-GitHub.

#שרשור נראה תקוע

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

#שרשורים ניחשו או נתקעו במקום לשאול

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

1. בקשו מקלוד בשיחה: "For every open thread, list what you asked it to do, what it assumed or couldn't reach, and what it's waiting on." (עבור כל שרשור פתוח, פרט מה ביקשת ממנו לעשות, מה הוא הניח או לא הצליח להגיע אליו, ולמה הוא ממתין). קלוד קורא כל שרשור ועונה בשיחה.
2. עבור שרשורים שהתחילו מהנחה שגויה, פתחו את השרשור מתוך Overview וסמנו אותו כהושלם (resolved) מהתפריט שלו, או אמרו לו מה לעשות במקום זאת בתיבת ההודעות שלו. הענף שלו וכל בקשת משיכה נשארים ב-GitHub עד שתמחקו אותם.
3. תקנו את הפער פעם אחת, ב-הוראות הפרויקט או ב-סביבה, ולאחר מכן שלחו שרשור אחד לפני שליחת שאר העבודה שוב כשרשורים חדשים.

#קלוד לא הגיב

שיחת הפרויקט מציגה באנר "Claude hasn't responded" כאשר קלוד רץ אך התשובות שלו אינן מגיעות לפרויקט. לחצו על Restart Claude בבאנר, או עברו אל Project settings > General ולחצו על Restart בשורה של Restart Claude. קלוד מתחבר מחדש לשיחה: כל תשובה שהוא היה באמצע כתיבתה אובדת, והשרשורים אינם מושפעים.

#שגיאות גישה למאגר

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

• "Couldn't start the session: Claude doesn't have GitHub access to this project's repository", מדווחת לפני שהשרשור מתחיל, כאשר Claude GitHub App אינה מותקנת באותו מאגר, מושעית, או אינה מקושרת לחשבון GitHub שחיברתם.
• "Unable to access your repository", מדווחת על ידי שרשור כאשר השכפול שלו נכשל: GitHub דחה את השכפול, המאגר לא נמצא תחת השם שיש לפרויקט, או שהענף שהשרשור התבקש להתחיל ממנו אינו קיים.
• "Claude can't access" a repository, מוצגת כאשר אתם שומרים מאגרים בתיבת הדו-שיח New project או ב-Project settings. ההודעה ממשיכה עם קישור התקנה וקישור חיבור מחדש. השתמשו בקישור ההתקנה אם Claude GitHub App אינה מותקנת באותו מאגר, ובקישור החיבור מחדש אם היא מותקנת, מכיוון שאפליקציית GitHub App יכולה להיות מותקנת ב-GitHub מבלי להיות מקושרת לחשבון שחיברתם לקלוד. אם ההודעה מציינת שה-GitHub App מושעית או אינה כוללת מאגר זה, עקבו אחר הקישור שלה ל-GitHub כדי לתקן זאת.

כדי לתקן כל אחת מהן, לחצו על הכפתור שההודעה מציעה, כגון Install GitHub App או Select repositories on GitHub, ולאחר מכן על Check again. כאשר החסימה היא בצד של ארגון ה-GitHub, כגון בעלים שלא אישר את האפליקציה או רשימת היתרים של כתובות IP שאינה כוללת את קלוד, ההודעה מציגה במקום זאת קישור See how to fix. אם אין כפתור, פעלו לפי הגדרת גישה ל-GitHub, ולאחר מכן שלחו הודעה נוספת כדי לנסות שוב.

#שרשור הגיע למגבלת השימוש

כאשר שרשור או שיחת הפרויקט מגיעים למגבלת חמש השעות או למגבלה השבועית של התוכנית שלכם, הוא ממשיך לנסות שוב בעצמו וממשיך כאשר המגבלה מתאפסת. בזמן שהוא ממתין, השרשור מציג Service is busy עם "Claude is still retrying and will continue automatically." אינכם צריכים לעשות דבר כדי שהעבודה תימשך. אם אתם מעדיפים שהוא לא ישתמש בחלון השימוש הבא שלכם, לחצו על Stop בשרשור, או השהו את הפרויקט כדי לעצור כל שרשור. שרשור שרוטינה התחילה אינו ממתין: התור שלו נעצר עם שגיאת מגבלה, ואתם שולחים לו הודעה לאחר שהמגבלה מתאפסת.

הדף שגיאות מגבלת שימוש מסביר את המגבלות ומתי הן מתאפסות.

#נדרשים קרדיטים נוספים לשימוש

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

#הודעות אחרות

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

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

• שימוש ב-Claude Code בענן: כיצד פועלות הפעלות הענן שמאחורי כל שרשור, כולל אפשרויות גישה ל-GitHub ותיקון אוטומטי בבקשות משיכה
• הגדרת סביבות ענן: שינוי מה ששרשורים יכולים להגיע אליו ברשת, מתן משתני סביבה ואישורי API, והתקנת כלים באמצעות סקריפט הגדרה
• אוטומציה של עבודה באמצעות רוטינות: לוחות זמנים, טריגרים וניהול עבור רוטינות, כולל אלו שקלוד יוצר מתוך פרויקט
• ניהול מספר סוכנים באמצעות תצוגת סוכנים (agent view): הרצה ומעקב אחר מספר הפעלות במחשב שלכם כאשר העבודה זקוקה לכלים או לשירותים שרק המחשב שלכם יכול להגיע אליהם
• פרויקטים בעיצוב מחדש: מתיקייה לשיחה: הודעת ההשקה, עם החשיבה מאחורי הפיכת פרויקט לשיחה עם קלוד