תיעוד 12

שיטות מומלצות עבור Claude Code

טיפים ודפוסים להפקת המרב מ-Claude Code, מהגדרת הסביבה שלך ועד להרחבת העבודה במקביל עם מספר הפעלות (sessions).

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

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

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

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

רוב השיטות המומלצות מבוססות על מגבלה אחת: חלון ההקשר (context window) של Claude מתמלא מהר, והביצועים יורדים ככל שהוא מתמלא.

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

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

#תן ל-Claude דרך לאמת את עבודתו

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

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

הבדיקה יכולה להיות כל דבר שמחזיר אות ש-Claude יכול לקרוא בשיחה: מערך בדיקות, קוד יציאה (exit code) של תהליך בנייה, כלי linter, סקריפט שמשווה הבדלים בפלט מול קובץ ייחוס (fixture), או צילום מסך של דפדפן בהשוואה לעיצוב. הרץ את /verify בעצמך לאחר שהבדיקה של Claude עוברת כדי לאשר את השינוי מול היישום הפועל.

אסטרטגיה	לפני	אחרי
ספק קריטריונים לאימות	"implement a function that validates email addresses"	"write a validateEmail function. example test cases: [email protected] is true, invalid is false, [email protected] is false. run the tests after implementing"
אמת שינויי ממשק משתמש (UI) באופן חזותי	"make the dashboard look better"	"[paste screenshot] implement this design. take a screenshot of the result and compare it to the original. list differences and fix them"
טפל בגורמי שורש ולא בסימפטומים	"the build is failing"	"the build fails with this error: [paste error]. fix it and verify the build succeeds. address the root cause, don't suppress the error"

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

בהנחיה (prompt) אחת: בקש מ-Claude להריץ את הבדיקה ולבצע סבבים חוזרים באותה ההודעה, כמו בטבלה שלמעלה.
לאורך הפעלה שלמה: הגדר את הבדיקה כתנאי של /goal. מעריך נפרד בודק אותה מחדש לאחר כל תור ו-Claude ממשיך לעבוד עד שהיעד מושג. אם Claude נתקע, Claude Code עוצר בסופו של דבר את הריצה כאשר היעד עדיין מוגדר, ראה כיצד פועלת הערכת goal/.
כשער חוסם דטרמיניסטי: רכיב Stop hook מריץ את הבדיקה שלך כסקריפט וחוסם את סיום התור עד שהיא עוברת. Claude Code עוקף את ה-hook ומסיים את התור לאחר 8 חסימות רצופות.
באמצעות חוות דעת שנייה: רכיב verification subagent או זרימת עבודה דינמית שבודקת את הממצאים של עצמה מפעילה מודל רענן שמנסה להפריך את התוצאה, כך שהסוכן שמבצע את העבודה אינו זה שמעריך אותה.

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

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

#חקור תחילה, אחר כך תכנן, ואז כתוב קוד

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

מתן אפשרות ל-Claude לקפוץ ישירות לכתיבת קוד עלול להוביל לקוד שפותר את הבעיה הלא נכונה. השתמש ב-מצב תכנון (plan mode) כדי להפריד בין חקירה לבין ביצוע.

תהליך העבודה המומלץ כולל ארבעה שלבים:

חקור (Explore): היכנס למצב תכנון על ידי לחיצה על Shift+Tab עד ששורת המצב מציגה ⏸ plan mode on, או התחל את ההפעלה באמצעות claude --permission-mode plan. Claude קורא קבצים ועונה על שאלות מבלי לבצע שינויים.

read /src/auth and understand how we handle sessions and login.
also look at how we manage environment variables for secrets.

תכנן (Plan): בקש מ-Claude ליצור תוכנית יישום מפורטת.

I want to add Google OAuth. What files need to change?
What's the session flow? Create a plan.

לחץ על Ctrl+G כדי לפתוח את התוכנית בעורך הטקסט שלך לצורך עריכה ישירה לפני ש-Claude ממשיך.

יישם (Implement): צא ממצב תכנון על ידי אישור התוכנית או לחיצה על Shift+Tab, ואז אפשר ל-Claude לכתוב את הקוד, תוך אימות מול התוכנית שלו.

implement the OAuth flow from your plan. write tests for the
callback handler, run the test suite and fix any failures.

בצע Commit (Commit): בקש מ-Claude לבצע commit עם הודעה תיאורית ולפתוח PR.

commit with a descriptive message and open a PR

שים לב: מצב תכנון (plan mode) הוא שימושי, אך הוא גם מוסיף תקורה.

עבור משימות שבהן ההיקף ברור והתיקון קטן (כמו תיקון שגיאת כתיב, הוספת שורת log או שינוי שם של משתנה), בקש מ-Claude לבצע זאת ישירות.

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

#ספק הקשר ספציפי בהנחיות (prompts) שלך

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

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

אסטרטגיה	לפני	אחרי
הגדר את היקף המשימה. ציין איזה קובץ, איזה תרחיש והעדפות בדיקה.	"add tests for foo.py"	"write a test for foo.py covering the edge case where the user is logged out. avoid mocks."
הפנה למקורות. כוון את Claude למקור שיכול לענות על השאלה.	"why does ExecutionFactory have such a weird api?"	"look through ExecutionFactory's git history and summarize how its api came to be"
התייחס לדפוסים קיימים. הפנה את Claude לדפוסים בבסיס הקוד שלך.	"add a calendar widget"	"look at how existing widgets are implemented on the home page to understand the patterns. HotDogWidget.php is a good example. follow the pattern to implement a new calendar widget that lets the user select a month and paginate forwards/backwards to pick a year. build from scratch without libraries other than the ones already used in the codebase."
תאר את הסימפטום. ספק את הסימפטום, המיקום המשוער ואיך נראה מצב "מתוקן".	"fix the login bug"	"users report that login fails after session timeout. check the auth flow in src/auth/, especially token refresh. write a failing test that reproduces the issue, then fix it"

הנחיות מעורפלות יכולות להיות שימושיות כאשר אתה חוקר ויכול להרשות לעצמך לתקן כיוון תוך כדי תנועה. הנחיה כמו "what would you improve in this file?" יכולה להעלות דברים שלא היית חושב לשאול עליהם.

#ספק תוכן עשיר

טיפ: השתמש ב-@ כדי להפנות לקבצים, הדבק צילומי מסך או תמונות, או הזרם נתונים ישירות דרך צינור (pipe).

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

התייחס לקבצים באמצעות @ במקום לתאר היכן הקוד נמצא. Claude קורא את הקובץ לפני שהוא מגיב.
הדבק תמונות ישירות. העתק והדבק או גרור ושחרר תמונות אל שורת ההנחיה.
ספק כתובות URL עבור תיעוד והפניות API. השתמש ב-/permissions כדי להוסיף לרשימת ההיתרים דומיינים שנמצאים בשימוש תדיר.
הזרם נתונים (pipe) על ידי הרצת cat error.log | claude כדי לשלוח את תוכן הקובץ ישירות.
אפשר ל-Claude להביא את מה שהוא צריך. הנחה את Claude למשוך הקשר בעצמו באמצעות פקודות Bash, כלי MCP, או על ידי קריאת קבצים.

#הגדר את הסביבה שלך

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

#כתוב קובץ CLAUDE.md יעיל

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

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

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

# Code style
- Use ES modules (import/export) syntax, not CommonJS (require)
- Destructure imports when possible (eg. import { foo } from 'bar')

# Workflow
- Be sure to typecheck when you're done making a series of code changes
- Prefer running single tests, and not the whole test suite, for performance

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

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

✅ כלול	❌ אל תכלול
פקודות Bash ש-Claude אינו יכול לנחש	כל דבר ש-Claude יכול להבין מקריאת הקוד
כללי סגנון קוד השונים מברירות המחדל	מוסכמות שפה סטנדרטיות ש-Claude כבר מכיר
הוראות בדיקה וכלי הרצת בדיקות מועדפים	תיעוד API מפורט (קשר לתיעוד במקום זאת)
כללי התנהגות במאגר (מתן שמות לענפים, מוסכמות PR)	מידע שמשתנה לעיתים תכופות
החלטות ארכיטקטוניות הספציפיות לפרויקט שלך	הסברים ארוכים או מדריכים
מאפיינים ייחודיים של סביבת הפיתוח (משתני סביבה נדרשים)	תיאור מפורט של בסיס הקוד קובץ אחר קובץ
מוקשים נפוצים או התנהגויות לא מובנות מאליהן	שיטות מובנות מאליהן כמו "כתוב קוד נקי"

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

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

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

#הגדר הרשאות

טיפ: כדי לקבל פחות בקשות אישור מבלי לוותר על שליטה, אשר מראש את הכלים שאתה סומך עליהם באמצעות /permissions ואפשר לפקודות שרצות בתוך ארגז חול (sandbox) לרוץ מבלי לשאול באמצעות /sandbox. עבור למצב ידני (Manual mode) כאשר אתה מעוניין לאשר עריכות ופקודות בעצמך.

בתוכניות Pro, Max ו-Team, מצב אוטומטי (auto mode) הוא מצב ברירת המחדל ההתחלתי להרשאות עבור הפעלות אינטראקטיביות במסוף וב-VS Code: מודל מסווג (classifier) נפרד בודק את רוב הפעולות במקומך וחוסם רק מה שנראה מסוכן, כגון הסלמת הרשאות (scope escalation), תשתית לא מוכרת או פעולות המונעות מתוכן עוין.

במצב ידני (Manual mode), שהוא מצב ברירת המחדל ההתחלתי בתוכניות אחרות, Claude Code מבקש אישור לפני פעולות שעלולות לשנות את המערכת שלך: כתיבת קבצים, פקודות Bash וכלי MCP. זה בטוח אך מייגע. לאחר האישור העשירי אתה פשוט לוחץ על אישור במקום לבדוק באמת. שני כלים מפחיתים את ההפרעות הללו במצב ידני ותקפים גם במצב אוטומטי:

רשימות היתרים (allowlists) של הרשאות: מתן אישור מראש לכלים ספציפיים שאתה יודע שהם בטוחים, כגון npm run lint או git commit.
ארגז חול (Sandboxing): הפעלת בידוד ברמת מערכת ההפעלה המגביל גישה למערכת הקבצים ולרשת, ומאפשר ל-Claude לעבוד בחופשיות רבה יותר בתוך גבולות מוגדרים.

קרא עוד על מצבי הרשאות, כללי הרשאות ו-ארגז חול (sandboxing).

#השתמש בכלי CLI

טיפ: הנחה את Claude Code להשתמש בכלי CLI כגון gh, aws, gcloud ו-sentry-cli בעת אינטראקציה עם שירותים חיצוניים.

כלי CLI הם הדרך היעילה ביותר מבחינת הקשר לאינטראקציה עם שירותים חיצוניים. אם אתה משתמש ב-GitHub, התקן את כלי ה-CLI של gh. Claude יודע כיצד להשתמש בו ליצירת issues, פתיחת pull requests וקריאת תגובות. ללא gh, Claude עדיין יכול להשתמש ב-API של GitHub, אך בקשות לא מאומתות נתקלות לעיתים קרובות במגבלות קצב (rate limits).

Claude יעיל גם בלמידת כלי CLI שהוא אינו מכיר עדיין. נסה הנחיות כגון Use 'foo-cli-tool --help' to learn about foo tool, then use it to solve A, B, C.

#חבר שרתי MCP

טיפ: הרץ את claude mcp add עם שם שרת וכתובת URL או פקודה כדי לחבר כלים חיצוניים כמו Notion, Figma, או מסד הנתונים שלך. לדוגמה: claude mcp add --transport http notion https://mcp.notion.com/mcp.

באמצעות שרתי MCP, אתה יכול לבקש מ-Claude ליישם תכונות מתוך מערכות מעקב אחר משימות, לתשאל מסדי נתונים, לנתח נתוני ניטור, לשלב עיצובים מ-Figma ולבצע אוטומציה של תהליכי עבודה.

#הגדר hooks

טיפ: השתמש ב-hooks עבור פעולות שחייבות להתבצע בכל פעם ללא יוצא מן הכלל.

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

Claude יכול לכתוב hooks עבורך. נסה הנחיות כגון "Write a hook that runs eslint after every file edit" או "Write a hook that blocks writes to the migrations folder." ערוך את .claude/settings.json ישירות כדי להגדיר hooks באופן ידני, והרץ את /hooks כדי לעיין במה שמוגדר.

#צור skills

טיפ: צור קובצי SKILL.md בתוך .claude/skills/ כדי להעניק ל-Claude ידע ספציפי לתחום ותהליכי עבודה לשימוש חוזר.

רכיבי Skills מרחיבים את הידע של Claude עם מידע הספציפי לפרויקט, לצוות או לתחום שלך. Claude מיישם אותם באופן אוטומטי כאשר הם רלוונטיים, או שאתה יכול להפעיל אותם ישירות באמצעות skill-name/.

צור skill על ידי הוספת תיקייה עם קובץ SKILL.md תחת .claude/skills/:

---
name: api-conventions
description: REST API design conventions for our services
---
# API Conventions
- Use kebab-case for URL paths
- Use camelCase for JSON properties
- Always include pagination for list endpoints
- Version APIs in the URL path (/v1/, /v2/)

רכיבי Skills יכולים גם להגדיר תהליכי עבודה שניתן לחזור עליהם ולהפעילם ישירות:

---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---
Analyze and fix the GitHub issue: $ARGUMENTS.

1. Use `gh issue view` to get the issue details
2. Understand the problem described in the issue
3. Search the codebase for relevant files
4. Implement the necessary changes to fix the issue
5. Write and run tests to verify the fix
6. Ensure code passes linting and type checking
7. Create a descriptive commit message
8. Push and create a PR

הרץ את /fix-issue 1234 כדי להפעיל אותו. השתמש ב-disable-model-invocation: true עבור תהליכי עבודה עם תופעות לוואי שברצונך להפעיל באופן ידני בלבד.

#צור subagents מותאמים אישית

טיפ: הגדר עוזרים ייעודיים בתוך .claude/agents/ ש-Claude יכול להאציל אליהם משימות מבודדות.

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

---
name: security-reviewer
description: Reviews code for security vulnerabilities
tools: Read, Grep, Glob, Bash
model: opus
---
You are a senior security engineer. Review code for:
- Injection vulnerabilities (SQL, XSS, command injection)
- Authentication and authorization flaws
- Secrets or credentials in code
- Insecure data handling

Provide specific line references and suggested fixes.

הנחה את Claude להשתמש ב-subagents במפורש: "Use a subagent to review this code for security issues."

#התקן תוספים (plugins)

טיפ: הרץ את /plugin כדי לעיין בחנות התוספים (marketplace). תוספים מוסיפים skills, כלים ואינטגרציות ללא צורך בהגדרה ידנית.

תוספים (Plugins) מאגדים skills, hooks, subagents ושרתי MCP ליחידה אחת הניתנת להתקנה מהקהילה ומ-Anthropic. אם אתה עובד עם שפה בעלת טיפוסים (typed language), התקן תוסף בינה לקוד (code intelligence plugin) כדי לתת ל-Claude ניווט מדויק בסמלים וזיהוי שגיאות אוטומטי לאחר עריכות.

להנחיות לגבי הבחירה בין skills, subagents, hooks ו-MCP, ראה הרחבת Claude Code.

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

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

#שאל שאלות על בסיס הקוד (codebase)

טיפ: שאל את Claude שאלות שהיית שואל מהנדס בכיר.

בעת כניסה לבסיס קוד חדש (onboarding), השתמש ב-Claude Code ללמידה ולחקירה. תוכל לשאול את Claude את אותן סוגי שאלות שהיית שואל מהנדס אחר:

כיצד עובד מנגנון הרישום ביומן (logging)?
כיצד אני יוצר נקודת קצה חדשה ב-API?
מה עושה async move { ... } בשורה 134 של foo.rs?
באילו מקרי קצה מטפל CustomerOnboardingFlowImpl?
מדוע הקוד קורא ל-foo() במקום ל-bar() בשורה 333?

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

#תן ל-Claude לראיין אותך

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

Claude שואל על דברים שאולי עדיין לא לקחת בחשבון, כולל יישום טכני, UI/UX, מקרי קצה ופשרות (tradeoffs). החלף את [brief description] בתיאור התכונה שלך לפני שליחת ההנחיה.

I want to build [brief description]. Interview me in detail using the AskUserQuestion tool.

Ask about technical implementation, UI/UX, edge cases, concerns, and tradeoffs. Don't ask obvious questions, dig into the hard parts I might not have considered.

Keep interviewing until we've covered everything, then write a complete spec to SPEC.md.

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

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

#נהל את ההפעלה (session) שלך

שיחות הן מתמשכות וניתנות להחזרה לאחור. נצל זאת לטובתך!

#תקן מסלול מוקדם ולעיתים קרובות

טיפ: תקן את Claude ברגע שאתה מבחין שהוא סוטה מהמסלול.

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

Esc: עצור את Claude באמצע פעולה באמצעות מקש ה-Esc. ההקשר נשמר, כך שתוכל לכוון אותו מחדש.
Esc + Esc או /rewind: לחץ על Esc פעמיים או הרץ את /rewind כדי לפתוח את תפריט ההחזרה לאחור ולשחזר מצב שיחה וקוד קודמים, או לסכם החל מהודעה שנבחרה.
"Undo that": בקש מ-Claude לבטל את השינויים שביצע.
/clear: אפס את ההקשר בין משימות שאינן קשורות. הפעלות ארוכות עם הקשר לא רלוונטי עלולות לפגוע בביצועים.

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

#נהל הקשר באופן אגרסיבי

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

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

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

השתמש ב-/clear לעיתים קרובות בין משימות כדי לאפס את חלון ההקשר לחלוטין.
כאשר דחיסה אוטומטית מופעלת, Claude מסכם את מה שהכי חשוב, כולל דפוסי קוד, מצבי קבצים והחלטות מפתח.
לשליטה רבה יותר, הרץ את <פקודות> compact/, כמו למשל /compact Focus on the API changes.
כדי לדחוס רק חלק מהשיחה, השתמש ב-Esc + Esc או ב-/rewind, בחר נקודת ביקורת (checkpoint) של הודעה, ובחר Summarize from here או Summarize up to here. האפשרות הראשונה מתמצתת הודעות מנקודה זו ואילך תוך שמירה על הקשר מוקדם יותר ללא שינוי, והאפשרות השנייה מתמצתת הודעות מוקדמות תוך שמירה על ההודעות האחרונות במלואן. ראה אפשרויות הסיכום בתפריט ה-rewind.
התאם אישית את התנהגות הדחיסה ב-CLAUDE.md עם הנחיות כגון "When compacting, always preserve the full list of modified files and any test commands" כדי להבטיח שהקשר קריטי ישרוד את הסיכום.
עבור שאלות שאינן צריכות להישאר בהקשר, השתמש ב-/btw. התשובה אינה נכנסת לעולם להיסטוריית השיחה, כך שתוכל לבדוק פרט מסוים מבלי להגדיל את ההקשר.

#השתמש ב-subagents לחקירה

טיפ: האצל משימות מחקר באמצעות "use subagents to investigate X". הם חוקרים בחלון הקשר נפרד, ושומרים על השיחה הראשית שלך נקייה לצורך היישום.

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

Use subagents to investigate how our authentication system handles token
refresh, and whether we have any existing OAuth utilities I should reuse.

תוכל גם להשתמש ב-subagents לצורך אימות לאחר ש-Claude מיישם משהו. ראה הוסף שלב סקירה ביקורתית.

#החזר לאחור בעזרת נקודות ביקורת (checkpoints)

טיפ: כל הנחיה שאתה שולח ופותחת תור יוצרת נקודת ביקורת (checkpoint). אתה יכול לשחזר את השיחה, את הקוד, או את שניהם לכל נקודת ביקורת קודמת.

Claude שומר באופן אוטומטי תמונת מצב (snapshot) של קבצים לפני כל שינוי, כך שנקודת ביקורת יכולה לשחזר אותם. הקש פעמיים על Escape או הרץ את /rewind כדי לפתוח את תפריט ההחזרה לאחור. תוכל לשחזר שיחה בלבד, לשחזר קוד בלבד, לשחזר את שניהם, או לסכם החל מהודעה שנבחרה. ראה נקודות ביקורת (Checkpointing) לפרטים נוספים.

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

אזהרה: נקודות ביקורת עוקבות רק אחר שינויים שנעשו באמצעות כלי עריכת הקבצים של Claude. שינויים שנעשו באמצעות פקודות Bash או תהליכים חיצוניים אינם נלכדים. זה אינו תחליף ל-git.

#המשך שיחות (resume)

טיפ: תן שמות להפעלות באמצעות /rename והתייחס אליהן כמו לענפים (branches): כל זרם עבודה מקבל הקשר קבוע משלו.

Claude Code שומר שיחות באופן מקומי, כך שכאשר משימה נפרסת על פני מספר ישיבות אינך צריך להסביר מחדש את ההקשר. הרץ את claude --continue כדי להמשיך מהמקום שבו עצרת, או את claude --resume כדי לבחור מתוך רשימה. תן להפעלות שמות תיאוריים כמו oauth-migration כדי שתוכל למצוא אותן מאוחר יותר. ראה ניהול הפעלות עבור מערך הבקרות המלא של חידוש, פיצול לענפים ומתן שמות.

#בצע אוטומציה והתרחב (scale)

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

#הרץ במצב לא-אינטראקטיבי

טיפ: השתמש ב-claude -p "prompt" ב-CI, ב-pre-commit hooks, או בסקריפטים. הוסף --output-format stream-json --verbose עבור פלט JSON מוזרם.

באמצעות claude -p "your prompt", תוכל להריץ את Claude באופן לא-אינטראקטיבי, ללא הנחיה אינטראקטיבית. הריצה עדיין יוצרת הפעלה שניתן לחדש, אלא אם כן תעביר את הדגל --no-session-persistence. מצב לא-אינטראקטיבי הוא הדרך שבה אתה משלב את Claude בצינורות CI, ב-pre-commit hooks, או בכל תהליך עבודה אוטומטי. פורמטי הפלט מאפשרים לך לפענח תוצאות באופן תכנותי: טקסט רגיל, JSON או JSON מוזרם.

# One-off queries
claude -p "Explain what this project does"

# Structured output for scripts
claude -p "List all API endpoints" --output-format json

# Streaming for real-time processing
claude -p "Analyze this log file" --output-format stream-json --verbose

הפקודה הראשונה מדפיסה טקסט רגיל. פורמט ה-json מחזיר אובייקט JSON יחיד עם שדה result. פורמט ה-stream-json מדפיס אובייקט JSON אחד לכל שורה, החל מאירוע אתחול (init event).

#הרץ מספר הפעלות של Claude

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

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

Worktrees: הרץ הפעלות CLI נפרדות בעותקי git נפרדים ומבודדים כדי שהעריכות לא יתנגשו.
העברת הודעות בין הפעלות (Cross-session messaging): אפשר להפעלות שאתה מריץ בעצמך להעביר ממצאים זו לזו.
יישום שולחן עבודה (Desktop app): נהל מספר הפעלות מקומיות באופן חזותי, כאשר כל אחת מהן יכולה לפעול ב-worktree משלה.
שימוש ב-Claude Code בענן: הרץ הפעלות על תשתית מנוהלת של Anthropic כברירת מחדל.
מבט סוכנים (Agent view): תצוגה מקדימה למחקר (research preview). הרץ את claude agents כדי לשגר הפעלות שממשיכות לרוץ ברקע וצפה בהן ממסך אחד.
צוותי סוכנים (Agent teams): ניסיוני ומנוטרל כברירת מחדל. תיאום אוטומטי של מספר הפעלות עם משימות משותפות, העברת הודעות ומוביל צוות (team lead).

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

לדוגמה, השתמש בדפוס כותב/סוקר (Writer/Reviewer):

הפעלה א (כותב)	הפעלה ב (סוקר)
`Implement a rate limiter for our API endpoints`
	`Review the rate limiter implementation in @src/middleware/rateLimiter.ts. Look for edge cases, race conditions, and consistency with our existing middleware patterns.`
`Here's the review feedback: [Session B output]. Address these issues.`

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

#פצל משימות על פני קבצים רבים (fan out)

טיפ: רוץ בלולאה על פני משימות וקרא ל-claude -p עבור כל אחת מהן. השתמש ב---allowedTools כדי להגדיר את היקף ההרשאות לפעולות באצווה (batch).

עבור מיגרציות גדולות או ניתוחים נרחבים, תוכל לחלק את העבודה בין הפעלות רבות ומקבילות של Claude. בתוך מאגר git, הרץ את <הוראה> batch/ כדי לגרום ל-Claude לפצל את השינוי על פני 5 עד 30 סוכני משנה (subagents). כל סוכן משנה עובד ב-worktree משלו ופותח pull request. כדי לנהל את הפיצול מתוך סקריפט משלך במקום זאת, הרץ לולאה סביב claude -p:

צור רשימת משימות (Generate a task list): בקש מ-Claude לכתוב את רשימת הקבצים שדורשים מיגרציה לתוך קובץ, כך שהלולאה בשלב הבא תוכל לקרוא אותה, באמצעות הנחיה כמו list all 2,000 Python files that need migrating and save the list to files.txt
כתוב סקריפט כדי לרוץ בלולאה על הרשימה (Write a script to loop through the list):

for file in $(cat files.txt); do
  claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \
    --allowedTools "Edit,Bash(git commit *)"
done

בדוק על קבצים בודדים, ואז הרץ על כולם (Test on a few files, then run on all of them): דייק את ההנחיה שלך על סמך מה שמשתבש ב-2 עד 3 הקבצים הראשונים, ואז הרץ על מערך הקבצים המלא. הדגל --allowedTools מגביל את מה ש-Claude יכול לעשות, דבר שחשוב כאשר מריצים ללא השגחה.

תוכל גם לשלב את Claude בצינורות עיבוד נתונים קיימים:

claude -p "<your prompt>" --output-format json | your_command

#הרץ בצורה אוטונומית עם מצב אוטומטי (auto mode)

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

claude --permission-mode auto -p "fix all lint errors"

כאשר המסווג חוסם שוב ושוב פעולות בריצה לא-אינטראקטיבית עם הדגל -p, Claude Code אינו עוצר את הריצה. ראה מתי מצב אוטומטי נסוג (falls back) עבור מה שקורה במקום זאת ועבור ספי החסימה.

#הוסף שלב סקירה ביקורתית (adversarial review)

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

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

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

Use a subagent to review the rate limiter diff against PLAN.md. Check that
every requirement is implemented, the listed edge cases have tests, and
nothing outside the task's scope changed. Report gaps, not style preferences.

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

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

#הימנע מדפוסי כשל נפוצים

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

הפעלת "כל הבא ליד" (The kitchen sink session): אתה מתחיל במשימה אחת, לאחר מכן שואל את Claude משהו לא קשור, ואז חוזר למשימה הראשונה. ההקשר מלא במידע לא רלוונטי.

תיקון: הרץ את /clear בין משימות שאינן קשורות.
תיקון שוב ושוב (Correcting over and over): Claude עושה משהו שגוי, אתה מתקן אותו, זה עדיין שגוי, ואתה מתקן שוב. ההקשר מזוהם בגישות שנכשלו.

תיקון: לאחר שני תיקונים שנכשלו, הרץ את /clear וכתוב הנחיה ראשונית טובה יותר המשלבת את מה שלמדת.
קובץ CLAUDE.md מפורט יתר על המידה (The over-specified CLAUDE.md): אם קובץ ה-CLAUDE.md שלך ארוך מדי, Claude מתעלם ממחציתו כי כללים חשובים הולכים לאיבוד ברעש.

תיקון: גזום ללא רחמים. אם Claude כבר עושה משהו נכון ללא ההנחיה, מחק אותה או המר אותה ל-hook.
פער ה"בטח ואז אמת" (The trust-then-verify gap): Claude מייצר יישום שנראה סביר אך אינו מטפל במקרי קצה.

תיקון: ספק תמיד אימות (בדיקות, סקריפטים, צילומי מסך). אם אינך יכול לאמת את זה, אל תוציא את זה לפרודקשן (don't ship it).
החקירה האינסופית (The infinite exploration): אתה מבקש מ-Claude "לחקור" משהו מבלי להגדיר לו היקף. Claude קורא מאות קבצים וממלא את ההקשר.

תיקון: הגדר היקף צר לחקירות או השתמש ב-subagents כדי שהחקירה לא תכלה את ההקשר הראשי שלך.

#פתח את האינטואיציה שלך

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

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

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

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

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

כיצד Claude Code עובד: הלולאה מבוססת הסוכן, כלים וניהול הקשר
הרחבת Claude Code: skills, hooks, MCP, subagents ותוספים (plugins)
תהליכי עבודה נפוצים: מתכונים צעד אחר צעד לניפוי שגיאות, בדיקות, PRs ועוד
קובץ CLAUDE.md: אחסון מוסכמות פרויקט והקשר מתמשך