שיטות עבודה מומלצות עם Claude Code

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

מה זה עושה / למה זה שימושי

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

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

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

איך משתמשים

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

תן ל-Claude בדיקה שהוא יכול להריץ: tests, build, או screenshot להשוואה. זה ההבדל בין session שאתה צופה בו לבין כזה שאתה הולך ממנו.

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

הבדיקה היא כל דבר שמחזיר אות ש-Claude יכול לקרוא בשיחה: test suite, exit code של build, linter, סקריפט שמשווה פלט מול fixture, או screenshot מהדפדפן מול עיצוב.

דרגות לאכיפת העצירה

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

bprompt אחד — בקש מ-Claude להריץ את הבדיקה ולבצע iteration באותה הודעה, כמו בטבלה למעלה. גרסת ה-prompt עובדת על כל משימה כבר היום.

לאורך session — הגדר את הבדיקה כתנאי /goal. evaluator נפרד בודק מחדש לאחר כל תור, ו-Claude ממשיך לעבוד עד שהתנאי מתקיים.

כשער דטרמיניסטי — Stop hook מריץ את הבדיקה שלך כסקריפט וחוסם את סיום התור עד שהיא עוברת. Claude Code עוקף את ה-hook ומסיים את התור לאחר 8 חסימות רצופות.

בדעה שנייה — verification subagent או workflow דינמי שבודק את ממצאיו: מודל חדש מנסה להפריך את התוצאה, כך שהסוכן שעושה את העבודה אינו זה שמעריך אותה.

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

חקור קודם, אז תכנן, אז קדד

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

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

בשלב החקירה אתה נכנס ל-plan mode, ו-Claude קורא קבצים ועונה על שאלות ללא ביצוע שינויים.

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

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

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

בשלב היישום אתה יוצא מ-plan mode ונותן ל-Claude לקדד, תוך אימות מול התוכנית שלו.

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

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

commit with a descriptive message and open a PR

plan mode שימושי אך גם מוסיף תקורה. למשימות שהיקפן ברור והתיקון קטן (תיקון typo, הוספת שורת log, שינוי שם משתנה) — בקש מ-Claude לבצע ישירות. תכנון שימושי במיוחד כשאתה לא בטוח לגבי הגישה, כשהשינוי נוגע במספר קבצים, או כשאינך מכיר את הקוד שמשתנה. אם אפשר לתאר את ה-diff במשפט אחד, דלג על התכנון.

ספק הקשר ספציפי ב-prompts

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

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

ספק תוכן עשיר

יש מספר דרכים לספק נתונים עשירים ל-Claude. הפנה לקבצים עם @ במקום לתאר היכן הקוד נמצא — Claude קורא את הקובץ לפני שהוא עונה. הדבק תמונות ישירות באמצעות copy/paste או drag and drop. ספק URLs לתיעוד ולהפניות API, והשתמש ב-/permissions כדי להוסיף דומיינים נפוצים ל-allowlist. הזרם נתונים פנימה עם פקודה כמו cat error.log | claude. או פשוט תן ל-Claude למשוך את ההקשר בעצמו דרך פקודות Bash, כלי MCP, או קריאת קבצים.

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

כתוב CLAUDE.md יעיל

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

CLAUDE.md הוא קובץ מיוחד ש-Claude קורא בתחילת כל שיחה. כלול בו פקודות Bash, סגנון קוד וכללי workflow. זה מעניק ל-Claude הקשר קבוע שאינו יכול להסיק מהקוד לבדו. פקודת /init מנתחת את ה-codebase כדי לזהות מערכות build, frameworks של testing ודפוסי קוד.

אין פורמט נדרש ל-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

CLAUDE.md נטען בכל session, לכן כלול רק דברים שחלים באופן רחב. לידע תחום או workflows שרלוונטיים רק לעיתים, השתמש ב-skills במקום — Claude טוען אותם לפי דרישה בלי לנפח כל שיחה.

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

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

אפשר לכוונן הנחיות על ידי הוספת דגש (כמו "IMPORTANT" או "YOU MUST") כדי לשפר היענות. הכנס את CLAUDE.md ל-git כדי שהצוות שלך יוכל לתרום. הערך של הקובץ הולך ומצטבר עם הזמן.

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

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

# Additional Instructions
- Git workflow: @docs/git-instructions.md
- Personal overrides: @~/.claude/my-project-instructions.md

מיקומי CLAUDE.md

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

הגדר הרשאות

כברירת מחדל, Claude Code מבקש הרשאה לפעולות שעלולות לשנות את המערכת שלך: כתיבת קבצים, פקודות Bash, כלי MCP ועוד. זה בטוח אך מייגע. יש שלוש דרכים להפחית את ההפרעות. auto mode — מודל classifier נפרד סוקר פקודות וחוסם רק את מה שנראה מסוכן: הסלמת היקף, תשתית לא מוכרת, או פעולות מונעות-תוכן עוין. permission allowlists — מתיר כלים ספציפיים שאתה יודע שהם בטוחים, כמו npm run lint או git commit. Sandboxing — מאפשר בידוד ברמת מערכת ההפעלה המגביל גישה ל-filesystem ולרשת.

השתמש בכלי CLI

הורה ל-Claude Code להשתמש בכלי CLI כמו gh, aws, gcloud ו-sentry-cli בעת אינטראקציה עם שירותים חיצוניים. כלי CLI הם הדרך היעילה ביותר מבחינת הקשר לאינטראקציה עם שירותים חיצוניים. אם אתה משתמש ב-GitHub, התקן את gh CLI — בלעדיו Claude עדיין יכול להשתמש ב-GitHub API, אך בקשות לא מאומתות פוגעות לעיתים קרובות ב-rate limits. Claude גם יעיל בלמידת כלי CLI שהוא לא מכיר: נסה prompt כמו Use 'foo-cli-tool --help' to learn about foo tool, then use it to solve A, B, C.

חבר שרתי MCP

הרץ claude mcp add כדי לחבר כלים חיצוניים כמו Notion, Figma, או מסד הנתונים שלך. עם שרתי MCP אפשר לבקש מ-Claude ליישם פיצ'רים ממערכות ניהול issues, לתשאל מסדי נתונים, לנתח נתוני ניטור, לשלב עיצובים מ-Figma, ולאוטמט workflows.

הגדר hooks

השתמש ב-hooks לפעולות שחייבות לקרות בכל פעם ללא חריגים. hooks מריצים סקריפטים אוטומטית בנקודות מסוימות ב-workflow של Claude. בניגוד להנחיות CLAUDE.md שהן מייעצות, hooks הם דטרמיניסטיים ומבטיחים שהפעולה תקרה. Claude יכול לכתוב hooks בשבילך: נסה prompt כמו "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 ידע תחום ו-workflows לשימוש חוזר. skills מרחיבים את הידע של Claude במידע ספציפי לפרויקט, לצוות או לתחום שלך. Claude מיישם אותם אוטומטית כשהם רלוונטיים, או שאפשר להפעיל אותם ישירות עם /skill-name.

---
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 יכולים גם להגדיר workflows חוזרים שאתה מפעיל ישירות. השתמש ב-disable-model-invocation: true עבור workflows עם תופעות לוואי שאתה רוצה להפעיל ידנית, והרץ אותם כמו /fix-issue 1234.

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

צור subagents מותאמים

הגדר עוזרים מתמחים ב-.claude/agents/ ש-Claude יכול להאציל אליהם משימות מבודדות. subagents רצים ב-context משלהם עם סט כלים מורשים משלהם. הם שימושיים למשימות שקוראות הרבה קבצים או דורשות מיקוד מתמחה בלי לבלגן את השיחה הראשית.

---
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

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

התקן plugins

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

תקשר ביעילות

שאל שאלות על ה-codebase

שאל את Claude שאלות שהיית שואל מהנדס בכיר. בעת onboarding ל-codebase חדש, השתמש ב-Claude Code ללמידה וחקירה. אפשר לשאול את אותו סוג שאלות שהיית שואל מהנדס אחר: איך עובד logging, איך יוצרים API endpoint חדש, מה עושה async move { ... } בשורה 134 של foo.rs, אילו edge cases מטפל CustomerOnboardingFlowImpl, מדוע הקוד קורא ל-foo() במקום bar() בשורה 333. אין צורך ב-prompting מיוחד — שאל ישירות.

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

עבור פיצ'רים גדולים, תן ל-Claude לראיין אותך קודם. התחל עם prompt מינימלי ובקש מ-Claude לראיין אותך באמצעות הכלי AskUserQuestion. Claude שואל על דברים שאולי לא חשבת עליהם עדיין, כולל יישום טכני, UI/UX, edge cases ו-tradeoffs.

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.

לאחר שה-spec שלם, התחל session חדש כדי לבצע אותו. ל-session החדש יש context נקי שממוקד כולו ביישום, ויש לך spec כתוב להפניה. ה-specs השימושיים ביותר הם עצמאיים: הם נוקבים בשמות הקבצים והממשקים המעורבים, מציינים מה מחוץ להיקף, ומסתיימים בשלב אימות end-to-end שמוכיח שהפיצ'ר עובד.

נהל את ה-session שלך

שיחות הן קבועות והפיכות. נצל זאת לטובתך.

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

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

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

נהל context באגרסיביות

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

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

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

האצל מחקר עם "use subagents to investigate X". הם חוקרים ב-context נפרד, ושומרים על השיחה הראשית שלך נקייה ליישום. כש-Claude חוקר codebase הוא קורא הרבה קבצים, שכולם צורכים את ה-context שלך. subagents רצים בחלונות context נפרדים ומדווחים בחזרה סיכומים.

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

אפשר גם להשתמש ב-subagents לאימות לאחר ש-Claude מיישם משהו: use a subagent to review this code for edge cases.

חזור אחורה עם checkpoints

כל prompt שאתה שולח יוצר checkpoint. אפשר לשחזר שיחה, קוד, או שניהם לכל checkpoint קודם. Claude מצלם אוטומטית את הקבצים לפני כל שינוי כך ש-checkpoint יכול לשחזר אותם. הקש Escape פעמיים או הרץ /rewind כדי לפתוח את תפריט ה-rewind. במקום לתכנן בקפידה כל מהלך, אפשר להורות ל-Claude לנסות משהו מסוכן — אם זה לא עובד, חזור אחורה ונסה גישה אחרת. checkpoints נשמרים בין sessions. שים לב: checkpoints עוקבים רק אחר שינויים שבוצעו על ידי Claude, לא תהליכים חיצוניים, ואינם תחליף ל-git.

חדש שיחות

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

אוטמט והרחב בקנה מידה

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

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

השתמש ב-claude -p "prompt" ב-CI, ב-pre-commit hooks, או בסקריפטים. הוסף --output-format stream-json --verbose לפלט JSON זורם. מצב לא-אינטראקטיבי הוא הדרך לשלב את Claude ב-pipelines של CI, ב-pre-commit hooks, או בכל workflow אוטומטי. פורמטי הפלט מאפשרים לפרסר תוצאות באופן תכנותי: טקסט רגיל, 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

הרץ מספר sessions של Claude

הרץ מספר sessions של Claude במקביל כדי להאיץ פיתוח, להריץ ניסויים מבודדים, או להתחיל workflows מורכבים. בחר את הגישה המקבילה שמתאימה לכמות התיאום שאתה רוצה לעשות בעצמך: Worktrees (sessions נפרדים ב-checkouts מבודדים של git), אפליקציית Desktop (ניהול ויזואלי של מספר sessions מקומיים), Claude Code on the web (sessions על תשתית ענן מנוהלת ב-VMs מבודדים), ו-Agent teams (תיאום אוטומטי של מספר sessions עם משימות, הודעות ו-team lead משותפים).

מעבר למקביליות, מספר sessions מאפשרים workflows ממוקדי איכות. context חדש משפר code review מכיוון ש-Claude לא יהיה מוטה לטובת קוד שהוא בדיוק כתב. לדוגמה, דפוס Writer/Reviewer: session אחד מיישם פיצ'ר (כמו rate limiter), session שני סוקר אותו ומחפש edge cases, race conditions ועקביות, וה-session הראשון מטפל בממצאי הסקירה. אפשר לעשות דבר דומה עם tests: Claude אחד כותב tests, ואחר כותב קוד שיעבור אותם.

פרוס (fan out) על פני קבצים

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

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

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

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

הרץ אוטונומית עם auto mode

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

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

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

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

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

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.

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

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

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

The kitchen sink session — מתחילים עם משימה אחת, שואלים את Claude משהו לא קשור, וחוזרים למשימה הראשונה. ה-context מלא במידע לא רלוונטי. התיקון: /clear בין משימות לא קשורות.

Correcting over and over — Claude עושה משהו שגוי, אתה מתקן, זה עדיין שגוי, אתה מתקן שוב. ה-context מזוהם בגישות שנכשלו. התיקון: לאחר שני תיקונים כושלים, /clear וכתוב prompt התחלתי טוב יותר.

The over-specified CLAUDE.md — אם ה-CLAUDE.md ארוך מדי, Claude מתעלם מחציו כי כללים חשובים הולכים לאיבוד ברעש. התיקון: גזום בחוסר רחמים. אם Claude כבר עושה משהו נכון בלי ההנחיה, מחק אותה או המר אותה ל-hook.

The trust-then-verify gap — Claude מייצר יישום שנראה סביר אך לא מטפל ב-edge cases. התיקון: תמיד ספק אימות (tests, סקריפטים, screenshots). אם אינך יכול לאמת זאת, אל תשלח לפרודקשן.

The infinite exploration — אתה מבקש מ-Claude "לחקור" משהו בלי להגדיר היקף. Claude קורא מאות קבצים וממלא את ה-context. התיקון: הגדר חקירות בצמצום או השתמש ב-subagents.

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

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

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