איך להוציא את המקסימום
מ-Claude Code

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

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

במה זה שונה מ-IDE autocomplete?

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

השוואה לכלים אחרים

אם השתמשת בכלי AI אחרים לקוד, הנה איפה Claude Code שונה:

אם אתה משתמש ב-Cursor — Claude Code לא מחליף אותו, הוא משלים. תוסף Claude Code עובד בתוך Cursor, ונותן לך גם את ה-chat וה-completions של Cursor וגם את הסוכנות של Claude Code. הרבה משתמשים מריצים את שניהם.

היכן Claude Code זמין

כל הממשקים מתחברים לאותו מנוע — קבצי CLAUDE.md, settings, ו-MCP servers שלך עובדים בכולם.

ההתקנה לוקחת כדקה. כל ההתקנות הנייטיביות מתעדכנות אוטומטית ברקע — לא צריך לתחזק.

macOS, Linux, WSL

curl -fsSL https://claude.ai/install.sh | bash

Windows PowerShell

irm https://claude.ai/install.ps1 | iex

Windows CMD

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

חלופות התקנה

# macOS Homebrew
brew install --cask claude-code

# Windows WinGet
winget install Anthropic.ClaudeCode

# Linux: apt, dnf, apk זמינים גם הם

התחלה ראשונה

cd /path/to/your/project
claude

בפעם הראשונה תתבקש להתחבר. אפשר להיכנס עם מנוי Claude (Pro / Max / Team / Enterprise), עם חשבון Anthropic Console (API עם קרדיטים מוקדמים), או דרך Bedrock / Vertex AI / Foundry לחברות.

השאלות הראשונות שכדאי לשאול

what does this project do?
what technologies does this project use?
where is the main entry point?
explain the folder structure

Claude קורא את הקבצים לפי הצורך — אין צורך להוסיף קונטקסט ידנית. אחרי שהבנת את הקוד, אפשר לעבור לעבודה ממשית: "add a hello world function to the main file" או "there's a bug where users can submit empty forms — fix it".

VS Code הוא הסביבה הויזואלית המומלצת ל-Claude Code אם אתה לא חי בטרמינל. התוסף הרשמי נותן לך diffs מצוירים בתוך העורך, ‎@-mentions‎ עם השלמה אוטומטית, היסטוריית שיחות, ויכולת לפתוח כמה sessions במקביל בתוך טאבים נפרדים. אותו תוסף בדיוק עובד גם ב-Cursor, Windsurf, ו-Kiro.

שלב 1 · התקנת התוסף

שלוש דרכים, מהמהירה לאיטית:

• קישור ישיר: vscode:extension/anthropic.claude-code (או cursor:extension/anthropic.claude-code)
• ‎Extensions view: ‎Ctrl+Shift+X‎ (Windows/Linux) או ‎Cmd+Shift+X‎ (Mac), חפש "Claude Code", לחץ Install
• Command Palette: ‎Ctrl+Shift+P‎ → ‎"Extensions: Install Extensions" → חפש Claude Code

אם אתה ב-Windsurf או Kiro — אותו דבר, או דרך Open VSX registry.

אם התוסף לא מופיע אחרי התקנה: Developer: Reload Window מה-Command Palette.

שלב 2 · פתיחת Claude

אחרי ההתקנה, יש 4 דרכים לפתוח את הפאנל. שים לב לאייקון Spark (✱) — זה המזהה הויזואלי של Claude Code בכל מקום:

• ‎Editor Toolbar — אייקון Spark בפינה הימנית-עליונה של העורך. מופיע רק כשיש קובץ פתוח.
• ‎Activity Bar — אייקון Spark בסרגל הצדדי השמאלי. תמיד גלוי. לחיצה פותחת רשימת sessions.
• ‎Status Bar — "✱ Claude Code" בפינה הימנית-תחתונה. עובד גם בלי קובץ פתוח.
• ‎Command Palette — ‎Ctrl+Shift+P‎ → "Claude Code: Open in New Tab"

שלב 3 · התחברות

בפעם הראשונה תופיע מסך sign-in. לחץ Sign in וסיים את האישור בדפדפן. אם אתה רואה "Not logged in · Please run /login" — התוסף יפתח את מסך ההתחברות אוטומטית. אם לא — Developer: Reload Window.

שלב 4 · הפרומפט הראשון

סמן טקסט בעורך — Claude רואה אותו אוטומטית. לחץ ‎Alt+K‎ (Windows/Linux) או ‎Option+K‎ (Mac) כדי להוסיף ל-prompt הפניית ‎@-mention‎ עם שורות (לדוגמה @app.ts#5-10).

שלב 5 · ביקורת שינויים

כש-Claude רוצה לערוך קובץ — תופיע השוואה מצד-לצד של המקור מול ההצעה. אתה יכול:

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

פיצ'רים שכדאי להכיר ב-VS Code

‎@-mentions עם fuzzy matching

טייפ @ ושם חלקי — VS Code מציע התאמות. @auth ימצא auth.js או AuthService.ts. עבור תיקיות, הוסף סלאש: @src/components/.

‎@terminal:name — הפניה לפלט טרמינל

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

@terminal:bash explain this error
@terminal:dev-server why is the server crashing

‎/usage — בדיקת קונטקסט ועלויות

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

‎Extended Thinking

טוגל ב-/ מאפשר ל-Claude לחשוב יותר עמוק על בעיות מורכבות. ההיגיון מופיע בשיחה כבלוקים מקופלים. Ctrl+O פותח/סוגר את כל ה-thinking blocks בסשן.

‎Multi-line input

‎Shift+Enter‎ מוסיף שורה חדשה בלי לשלוח. שימושי לפרומפטים ארוכים.

‎Plan Mode כ-markdown editable

ב-VS Code, plan mode פותח את התוכנית כמסמך markdown מלא — אתה יכול להוסיף הערות inline לפני ש-Claude מתחיל. זה הרבה יותר טוב מ-CLI.

איפה Claude יושב — גרור איפה שנוח לך

גרור את הפאנל לאן שמתאים לך:

• ‎Secondary Sidebar (ימין) — שומר על Claude נראה תמיד תוך כדי קוד. מומלץ לרוב.
• ‎Primary Sidebar (שמאל) — ליד Explorer, Search
• ‎Editor Area — Claude כטאב לצד הקבצים. שימושי ל-side tasks

VS Code זוכר את ההעדפה שלך.

‎Multiple conversations במקביל

"Open in New Tab" או "Open in New Window" מה-Command Palette פותח שיחה נוספת עם היסטוריה וקונטקסט עצמאיים. נקודה צבעונית קטנה על אייקון Spark של הטאב מציינת:

• כחול — בקשת הרשאה ממתינה
• כתום — Claude סיים בזמן שהטאב היה מוסתר

‎Session History

כפתור Session history בראש פאנל Claude נותן גישה להיסטוריה. חיפוש לפי keyword או דפדוף לפי זמן (היום, אתמול, 7 ימים אחרונים...). שיחות חדשות מקבלות שם אוטומטי לפי ההודעה הראשונה שלך. רחף מעל סשן כדי לערוך שם או למחוק.

אם אתה משתמש גם ב-Claude Code on the Web, טאב Remote מציג סשנים מ-claude.ai — לחיצה מורידה אותם להמשך מקומי.

הגדרות התוסף שכדאי לדעת

פתח עם ‎Ctrl+,‎ → Extensions → Claude Code:

הוסף "$schema": "https://json.schemastore.org/claude-code-settings.json" ל-settings.json כדי לקבל autocomplete ו-validation מובנים ב-VS Code.

‎Plugins דרך VS Code

טייפ /plugins ב-prompt box כדי לפתוח ממשק גרפי לניהול plugins. שני טאבים:

• Plugins — מותקנים ופעילים בראש, עם toggle. זמינים מ-marketplaces — מתחת.
• Marketplaces — הוספה/הסרה של מקורות. תוכל להוסיף GitHub repo, URL, או נתיב מקומי.

בעת התקנה — בחר scope:

• Install for you — זמין בכל הפרויקטים שלך
• Install for this project — משותף עם משתפי הפרויקט (commit ל-git)
• Install locally — רק אתה, רק ה-repo הזה

‎@browser — אוטומציית Chrome מתוך VS Code

אחרי שתתקין את תוסף Claude in Chrome (1.0.36+), תוכל לכתוב @browser בפרומפט:

@browser go to localhost:3000 and check the console for errors
@browser fill out the registration form and submit
@browser take a screenshot of the dashboard and tell me what's broken

זהו הפיצ'ר הקריטי לפיתוח web — נפרט עליו בפרק 9.

‎/ide — חיבור CLI ל-VS Code

אם אתה אוהב את ה-CLI אבל רוצה תצוגת diffs ב-VS Code, פתח את הטרמינל המובנה (‎Ctrl+`‎) והרץ claude. ה-CLI מתחבר אוטומטית ל-IDE לתצוגת diff ושיתוף diagnostics. אם אתה משתמש בטרמינל חיצוני, הרץ /ide בתוך Claude כדי לחבר.

‎CLI מול תוסף — מה ההבדל?

היתרון הגדול: ההיסטוריה משותפת. אם התחלת שיחה בתוסף, claude --resume בטרמינל ימשיך אותה — ולהפך.

קיצורים שכדאי לדעת

פתרון תקלות נפוצות

אייקון Spark לא נראה

1. פתח קובץ — האייקון בעורך מופיע רק כשיש קובץ פתוח
2. בדוק גרסה — VS Code 1.98.0 ומעלה (Help → About)
3. ‎Developer: Reload Window
4. השבת תוספים מתחרים זמנית (Cline, Continue וכו')
5. בדוק workspace trust — התוסף לא עובד ב-Restricted Mode

‎Cmd+Esc לא עושה כלום ב-macOS

ב-macOS Tahoe ומעלה, ה-Game Overlay חוטף את הקיצור הזה. פתרון: System Settings → Keyboard → Keyboard Shortcuts → Game Controllers → ביטול ה-Game Overlay. או הקצה קיצור אחר ב-VS Code Keyboard Shortcuts.

Claude לא מגיב

1. בדוק חיבור אינטרנט
2. התחל שיחה חדשה
3. הרץ claude מהטרמינל המובנה — אולי תקבל הודעת שגיאה מפורטת

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

‎Agentic loop — המודל המנטלי

‎LLM רגיל מקבל טקסט ומחזיר טקסט. סוכן (agent) הוא LLM שיש לו כלים ויכולת לקרוא לכלים, לקרוא את התוצאה, ולחשוב שוב. זה הכל. השאר זה לולאה:

┌─────────────────────────────────────────┐
│  1. אתה שולח prompt                       │
│              ↓                          │
│  2. Claude חושב                          │
│              ↓                          │
│  3. Claude מחליט: לענות או לקרוא לכלי?     │
│              ↓                          │
│  4. אם כלי → קריאה (Read/Edit/Bash/...)   │
│              ↓                          │
│  5. תוצאת הכלי חוזרת לClaude              │
│              ↓                          │
│  6. חוזרים ל-2 — Claude חושב שוב          │
│              ↓                          │
│  ... עד שClaude מחליט שסיים               │
│              ↓                          │
│  7. תשובה אליך                            │
└─────────────────────────────────────────┘

כל איטרציה של 2-6 נקראת turn. משימה אחת שלך עשויה לדרוש 5-50 turns. במצב headless אפשר להגביל מספר turns דרך --max-turns 10 (בעיקר ל-CI ולמשימות אוטונומיות).

דוגמה קונקרטית: "תקן את שגיאת ה-TypeScript ב-auth.ts"

איך זה נראה turn-by-turn:

זה ‎~1,430 tokens לתיקון פשוט. למשימה מורכבת — הכפל ב-10. למשימה ענקית — ב-50. מכאן החשיבות העצומה של ניהול קונטקסט (פרק 5).

כלי ה-built-in

במה זה שונה מ-RAG ומ-chat רגיל

היתרון של agentic: Claude יכול להריץ את הקוד ולראות מה קורה — לבדוק tests, להריץ build, לבדוק UI. זה מה שהופך את התוצאה מ-"קוד שנראה סביר" ל-"קוד שעובד".

‎Checkpoints — בטיחות מובנית

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

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

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

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

כמה זה הקונטקסט בכלל?

‎Claude Sonnet 4.6 ו-Opus 4.6 — חלון של 200,000 tokens. נשמע הרבה, נכון? בוא נראה לאן זה הולך:

סשן ארוך עם הרבה קריאות קבצים יכול להגיע ל-150K במהירות. סביב 70-80% התחלה לראות ירידה בביצועים — Claude שוכח הוראות, חוזר לטעויות שכבר תיקנת, או מתחיל לעשות דברים שלא ביקשת.

מעקב אחר הצריכה

‎/usage

הפקודה הכי שימושית לבדיקת מצב. מציגה:

• כמה context אתה משתמש בסשן הנוכחי
• מודל פעיל
• השימוש שלך החודש (אם רלוונטי לתוכנית שלך)
• זמן עד reset של ה-rate limit

‎Status line

‎ב-VS Code, הפרומפט-בוקס מציג ויזואלית כמה context אתה צורך. ב-CLI אפשר להגדיר custom status line שיציג זאת תמיד. אם אתה רואה את האחוז עולה בצורה דרמטית — זה הזמן להתערב.

אסטרטגיות לניהול קונטקסט

‎/clear‎ בין משימות לא קשורות

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

‎/compact‎ עם הוראות

כשהקונטקסט מתקרב למגבלה, Claude מבצע compaction אוטומטית. מה זה עושה בפועל: Claude מסכם את כל מה שעבדתם עליו עד עכשיו לפסקה צפופה (קוד שעבר edit, החלטות שהתקבלו, קבצים מרכזיים), ואז מוחק את ההיסטוריה המפורטת. זה משחרר 60-80% מהקונטקסט. עלות: פרטים קטנים אובדים.

אפשר לשלוט: /compact Focus on the API changes — Claude יכלול את כל מה שקשור ל-API ויוותר על השאר. שימושי כשאתה יודע מה החשוב.

גם בלי /compact ידני, Claude מבצע auto-compaction סביב 95%. פרויקט root CLAUDE.md שורד את ה-compaction ונטען מחדש; CLAUDE.md מקונן בתת-תיקיות לא, עד שClaude קורא קובץ באותה תיקייה שוב.

Subagents לחקירה

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

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

ה-subagent חוקר ב-context window נפרד ומחזיר רק את הסיכום (אולי 500 tokens) — בלי לזהם את הקונטקסט הראשי שלך עם 20 קריאות קבצים.

‎/btw‎ לשאלות צד

שאלת תקציב מהירה שלא צריכה להיכנס להיסטוריה? /btw מציג תשובה ב-overlay נפרד שלא נכנס לשיחה. שימושי כשאתה עובד על משימה גדולה ופתאום צריך לבדוק "what's the syntax for X?".

‎Rewind ו-Checkpoints

כל פעולה של Claude יוצרת checkpoint. Esc Esc או /rewind פותחים תפריט שחזור — אפשר לשחזר רק שיחה, רק קוד, או שניהם. זה אומר שאתה יכול לבקש מ-Claude לנסות משהו מסוכן ואם זה לא עובד — לחזור אחורה.

סדר העדיפויות לחיסכון

1. ‎/clear — חיסכון מיידי של 100% מהקונטקסט הזמין
2. Subagents לחקירות — חוסך עשרות אלפי tokens של קריאת קבצים
3. ‎/compact עם focus — שומר על הקשר תוך חיסכון משמעותי
4. ‎CLAUDE.md תמציתי — חיסכון קבוע של 5-10K לכל סשן
5. השתמש ב-Edit במקום Write כשאפשר — Claude יודע, אבל לפעמים בקש במפורש

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

איך מתחילים?

הרץ /init בפרויקט — Claude ינתח את הקוד ויצור CLAUDE.md מותאם עם פקודות build, מסגרות בדיקה, ו-conventions שזיהה. זה המסד; ממנו תזקק במשך הזמן.

מבנה לדוגמה

# 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 לטעות?" אם לא — מחק. קבצי CLAUDE.md מנופחים גורמים ל-Claude להתעלם מההוראות שלך — חוקים חשובים נאבדים בתוך הרעש.

אם Claude ממשיך לעשות משהו שלא רצית למרות שיש כלל נגד זה — ה-CLAUDE.md כנראה ארוך מדי. תקצר.

היכן למקם את הקובץ

‎Imports עם ‎@

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

Auto Memory — Claude כותב לעצמו

Claude Code v2.1.59 ומעלה כולל מערכת זיכרון אוטומטית. Claude כותב לעצמו הערות תוך כדי עבודה: פקודות build, תובנות debugging, החלטות ארכיטקטורה — בלי שאתה תכתוב כלום.

הקבצים נשמרים ב-~/.claude/projects/<project>/memory/. ה-200 שורות הראשונות (או 25KB) של MEMORY.md נטענות בכל שיחה. את השאר Claude קורא לפי דרישה.

לבדוק / לערוך — /memory בתוך סשן.

‎.claude/rules/‎ — חוקים מודולריים

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

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

# API Development Rules
- All API endpoints must include input validation
- Use the standard error response format
- Include OpenAPI documentation comments

‎AGENTS.md — אם אתה כבר עובד עם כלי AI אחר

הרבה פרויקטים כבר מגדירים AGENTS.md ל-Cursor, Aider, או כלים אחרים. Claude Code לא קורא AGENTS.md ישירות — אבל קל לחבר:

@AGENTS.md

## Claude-specific
Use plan mode for changes under `src/billing/`.
Prefer pnpm test:unit over the full suite for performance.

זה טוען את ה-AGENTS.md שלך ומוסיף הנחיות ספציפיות ל-Claude. אם אין לך תוספות — אפשר symlink:

ln -s AGENTS.md CLAUDE.md

(ב-Windows symlinks דורשים הרשאות admin או Developer Mode — עדיף להשתמש ב-@AGENTS.md.)

טיפ נוסף: /init בפרויקט שכבר יש בו AGENTS.md (או .cursorrules, .windsurfrules) קורא אותו אוטומטית ומשלב את החלקים הרלוונטיים ב-CLAUDE.md החדש.

‎Managed CLAUDE.md — לארגונים

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

• ‎macOS: /Library/Application Support/ClaudeCode/CLAUDE.md
• ‎Linux/WSL: /etc/claude-code/CLAUDE.md
• ‎Windows: C:\Program Files\ClaudeCode\CLAUDE.md

שימושי ל-coding standards של החברה, חוקי security, או הוראות compliance שחייבות לחול. נפרס דרך MDM, Group Policy, או Ansible.

הסימנים שכדאי להוסיף ל-CLAUDE.md

בלי ה-feedback loop הזה, ה-CLAUDE.md שלך יישאר חלש. אלה הטריגרים שאומרים "תוסף":

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

‎CLAUDE.md הוא מקום ל-"דברים שClaude לא יכול להסיק מקריאת הקוד". אם הוא יכול — מחק את השורה.

ברירת המחדל היא ש-Claude מבקש רשות לכל פעולה שמשנה את המערכת — כתיבת קובץ, פקודת Bash, קריאה ל-MCP. זה בטוח אבל מתיש. Shift+Tab מחליף בין מצבים.

Plan Mode — לחשוב לפני שעורכים

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

claude --permission-mode plan

או באמצע סשן: Shift+Tab כדי להיכנס. Ctrl+G פותח את התוכנית בעורך הטקסט שלך לעריכה ישירה.

Auto Mode — ללא הפרעות, עם הגנה

זמין ל-Team / Enterprise / API plans, דורש Sonnet 4.6 או Opus 4.6. במקום להפסיק אותך עם prompts, מודל classifier נפרד בודק כל פעולה לפני ביצוע — חוסם הסלמת היקף, תשתית לא-מוכרת, ופעולות שנראות מונעות מ-prompt injection.

חוסם כברירת מחדל: הורדת והרצת קוד (curl | bash), שליחת מידע רגיש לשרתים חיצוניים, deploys ל-production, מחיקה המונית, force push, push ישיר ל-main.

מאפשר כברירת מחדל: פעולות מקומיות בתיקיית העבודה, התקנת dependencies שכבר ב-lock file, בקשות HTTP read-only, push לבראנץ' שאתה התחלת.

Sandboxing — בידוד OS-level

בידוד ברמת מערכת ההפעלה — מגביל גישה ל-filesystem ולרשת ומאפשר ל-Claude לעבוד יותר בחופשיות בתוך גבולות מוגדרים. כך אפשר להפעיל Claude עם auto mode בלי דאגה שיגיע למקומות לא רצויים. זמין דרך /sandbox.

‎/permissions — allowlist מותאם אישית

השיטה היומיומית לצמצם interruptions: ‎הוסף פקודות בטוחות שאתה מכיר ל-allowlist. ‎/permissions בתוך session פותח ממשק אינטראקטיבי, או שאתה עורך ידנית את .claude/settings.json.

שלוש רמות של חוקים

• allow — מבוצע ללא שאלה
• ask — שואל למרות שיש allow אחר (ל-override במקרים רגישים)
• deny — חוסם מוחלט. עוקף allow.

דוגמה מעשית: settings.json לפרויקט Next.js טיפוסי

{
  "permissions": {
    "allow": [
      "Bash(pnpm install)",
      "Bash(pnpm dev)",
      "Bash(pnpm build)",
      "Bash(pnpm test:*)",
      "Bash(pnpm lint)",
      "Bash(pnpm typecheck)",
      "Bash(git status)",
      "Bash(git diff:*)",
      "Bash(git log:*)",
      "Bash(git add:*)",
      "Bash(git commit:*)",
      "Bash(git push)",
      "Bash(npx drizzle-kit:*)",
      "WebFetch(domain:localhost)",
      "WebFetch(domain:docs.claude.com)"
    ],
    "ask": [
      "Bash(rm:*)",
      "Bash(git push --force:*)"
    ],
    "deny": [
      "Bash(rm -rf /)",
      "Read(./.env.production)",
      "Read(./.env.local)",
      "Write(./db/migrations/*)"
    ]
  }
}

‎Pattern matching

הסינטקס מאפשר רמות שונות של גמישות:

סדר העדיפויות

‎deny תמיד עוקף allow. זה אומר שאתה יכול להגדיר Bash(git:*) ב-allow ועדיין לחסום Bash(git push --force:*) ב-deny — וזה יעבוד.

טיפ לסולו-מפתח: התחל קטן, הוסף לפי הצורך

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

שילוב של mode + permissions

הזרימה האידיאלית לרוב המשתמשים:

1. מצב ברירת מחדל: acceptEdits (אתה סומך על Claude לערוך, אבל סוקר commands)
2. ‎allowlist רחב יחסית של פקודות בטוחות (lint, test, typecheck, git status/diff/add)
3. ‎deny rules על קבצים רגישים (.env*, migrations)
4. ‎plan mode למשימות multi-file גדולות
5. ‎auto mode למשימות boring שאתה לא רוצה לפקח עליהן (fix all lint, batch migration)

זרימת עבודה מומלצת: Explore → Plan → Code → Commit

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

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

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

commit with a descriptive message and open a PR

הבנת קוד-בייס חדש

give me an overview of this codebase
explain the main architecture patterns used here
what are the key data models?
how is authentication handled?
trace the login process from front-end to database

תיקון באג ביעילות

I'm seeing an error when I run npm test
[paste full error and stack trace]

Find the root cause, write a failing test that reproduces it, then fix it.

הוספת בדיקות

find functions in NotificationsService.ts that are not covered by tests
add tests for the notification service following our existing patterns
add test cases for edge conditions
run the new tests and fix any failures

Refactoring — מודרניזציה הדרגתית

‎Refactoring טוב הוא איטרטיבי, לא mass change. הזרימה:

# שלב 1: מצא מטרות
find deprecated API usage in our codebase. group by category.

# שלב 2: למד את הגישה
look at how we handle errors in the newer routes (@src/api/v2/).
why is that pattern better than the old try/catch in @src/api/v1/?

# שלב 3: refactor incrementally — קובץ אחד, עם tests
refactor @src/api/v1/users.ts to use the v2 error pattern.
keep the public API identical (no behavioral changes).
run the existing tests after — they must all still pass.

# שלב 4: אם הצליח, חזור על אותו דפוס
now do the same for @src/api/v1/products.ts.
follow the exact same approach.

זרימה זו מונעת את "הfix-everything-at-once" שהוא דרך ודאית לשבור את הקוד.

תיעוד

# מצא חוסרים
find functions without proper JSDoc comments in @src/api/handlers/

# צור תיעוד שמתאים לסטנדרט שלך
add JSDoc comments to the undocumented functions.
match the style of the existing documented functions in this folder.
include @param, @returns, @throws, and a one-line summary.

# שפר את התיעוד עם דוגמאות
for the public API functions, add a short @example block
showing typical usage.

# ודא שהתיעוד עוקב אחר הסטנדרט שלכם
check that all docs include the security considerations section
where it applies (authentication, input validation).

יצירת Pull Request

summarize the changes I've made to the authentication module
create a pr
enhance the PR description with more context about the security improvements

אחרי gh pr create, ה-session מקושר אוטומטית ל-PR. כדי לחזור: claude --from-pr 1234 או הדבק את כתובת ה-PR ב-/resume.

עבודה עם תמונות

גרור תמונה לחלון, או הדבק עם Ctrl+V (לא Cmd+V!). שימושי במיוחד עבור:

• ‎Screenshots‎ של שגיאות — "מה גורם לזה?"
• ‎Mockups‎ של עיצוב — "הפק CSS שמתאים"
• ‎Diagrams‎ של ארכיטקטורה — "איך לשנות את הסכמה?"

‎@ — ‎references‎ לקבצים ו-resources

explain the logic in @src/utils/auth.js
what's the structure of @src/components?
show me the data from @github:repos/owner/repo/issues

Resume של שיחות

# המשך השיחה האחרונה בתיקייה
claude --continue
claude -c

# בחר שיחה מרשימה
claude --resume
claude -r

# ‎name session‎ לזיהוי קל יותר
/rename oauth-migration

פיתוח web עם Claude Code שונה מפיתוח backend בכך שיש לך לולאת משוב ויזואלית — מה שאתה רואה בדפדפן הוא האמת. הפרק הזה מראה איך לנצל את זה: מבניית רכיב לפי mockup, דרך debugging חי בדפדפן, ועד אוטומציה מלאה של בדיקות UI.

שלוש דרכים לתת ל-Claude עיניים

‎Claude Code לא רואה את הדפדפן שלך כברירת מחדל. יש שלוש דרכים לחבר אותו:

‎Chrome extension — הפיצ'ר הקריטי לפיתוח web

זה הכלי שהופך את Claude מ-"כותב קוד עיוור" ל-"מפתח שבודק את עצמו". הוא:

• קורא ‎console errors — תקלות JS, warnings, network errors
• קורא DOM state — איזה אלמנט קיים, מה הקלאסים, מה הטקסט
• לוחץ, ממלא טפסים, מנווט
• פותח טאבים, גולש, מחלץ נתונים
• חולק את ה-login state שלך — אז גישה ל-Gmail, Notion, או ה-app שלך עם session פעיל

התקנה

1. התקן את Claude in Chrome extension מה-Chrome Web Store (גרסה 1.0.36+)
2. וודא ש-Claude Code שלך 2.0.73+: claude --version
3. הפעל את Claude עם claude --chrome, או באמצע סשן: /chrome
4. כדי שיהיה מוגדר תמיד: /chrome → "Enabled by default"

זרימת עבודה: בנייה לפי mockup

[paste screenshot]
implement this design as a React component.
follow the patterns in @src/components/ui/Card.tsx for styling.
use Tailwind only — no new CSS files.
the data shape is in @types/dashboard.ts

@browser open localhost:3000/dashboard
take a screenshot, compare it to the mockup I gave you,
list every visual difference, and fix them one by one

@browser resize the viewport to 375px wide,
take a screenshot, check if the layout breaks,
and fix any issues

‎Live debugging — באג בדפדפן

במקום להעתיק ידנית stack traces, תן ל-Claude לראות את הקונסול ישירות:

@browser open localhost:3000 and check the console for errors when the page loads.
filter for hydration errors specifically.
trace the source in the code and fix it.

שים לב — תגיד ל-Claude מה לחפש, לא "show me all console output". לוגים יכולים להיות מאוד מילוליים.

‎State debugging

@browser open localhost:3000/checkout, fill the form with test data,
click Submit, and watch the network tab. tell me what request goes out
and what response comes back. then check if the UI updates correctly.

בדיקות UX אוטומטיות

במקום לכתוב E2E tests, תן לClaude לעבור על user flow:

@browser test the registration flow:
1. go to /signup
2. try submitting with empty fields - verify error messages appear
3. try invalid email - verify validation
4. try mismatched passwords - verify error
5. submit valid data - verify redirect to /dashboard
report any issues

‎Frontend-specific patterns ב-CLAUDE.md

אם אתה בונה אפליקציה בעברית, כך נראה CLAUDE.md אופייני:

# Project: SaaS dashboard, Hebrew-first

## Stack
- Next.js 15 (App Router), React 19
- Tailwind CSS 4, shadcn/ui components
- Supabase Auth + Postgres
- Drizzle ORM

## UI conventions
- Hebrew-first, RTL primary direction (`dir="rtl"` on html)
- ALL components must support RTL via CSS logical properties
  - Use `ps-` (padding-inline-start), not `pl-` (padding-left)
  - Use `me-` (margin-inline-end), not `mr-` (margin-right)
- Numbers and dates: Intl API with locale `he-IL`
- Variable names, function names, file names: English
- User-facing strings: Hebrew, in i18n files only (no inline strings)

## Components
- Server Components by default (App Router)
- Add 'use client' only when needed: state, effects, browser APIs
- Reuse from @src/components/ui — don't create new primitives
- New components match existing patterns (look at @src/components/Card.tsx)

## Forms
- react-hook-form + zod for all forms
- Server actions for submission, not API routes
- Loading states via useFormStatus

## Build commands
- `pnpm dev` — start dev server
- `pnpm build` — production build (run before commits to catch errors)
- `pnpm lint` — eslint, run before commits
- `pnpm typecheck` — TypeScript check

בעיות נפוצות בפיתוח web ואיך לפתור עם Claude

‎Hydration errors ב-Next.js

I'm getting "Text content does not match server-rendered HTML" on /dashboard.
@browser open the page, copy the full error from the console.
trace which component is causing it, identify why server and client diverge,
and fix it. typical causes: Date.now(), Math.random(), client-only state in
server component.

‎State management מסובך

the cart updates inconsistently. use a subagent to investigate:
1. how state flows from CartProvider to CartButton
2. where mutations happen
3. is there race condition between optimistic updates and server response?
report findings, then propose a fix before implementing.

‎Performance — טעינה איטית

@browser open localhost:3000/products and measure load time.
check the network tab — list the 5 slowest requests.
check for: unnecessary re-renders, large bundle, missing image optimization,
N+1 queries. propose fixes ordered by impact.

‎CSS שלא מתנהג כמו שצריך

[paste screenshot of broken layout]
the Sidebar overflows on mobile.
@browser open localhost:3000 in 375px width, inspect the .sidebar element,
tell me what's causing the overflow, and fix it without breaking desktop.

טיפים מתקדמים לפיתוח web

• שמור localhost ב-allowlist: /permissions → הוסף WebFetch(domain:localhost) כדי שClaude לא יבקש רשות בכל פעם
• ‎Component-by-component, לא כל הדף בבת אחת: בקש לבנות רכיב אחד, לבדוק, לעבור הלאה. קונטקסט מתפוצץ אם תבקש "בנה לי את כל הדאשבורד"
• בקש diff מ-Claude לפני אישור: ב-VS Code זה אוטומטי, ב-CLI אפשר לבקש "show me the diff before applying"
• השתמש ב-plan mode למשימות מורכבות: "design a multi-step form with validation, progress bar, and recovery from network errors. plan first."

הפרק הזה מראה איך לבנות פיצ'ר שלם — DB, API, UI, tests — בסטאק מודרני (Next.js 15 + Drizzle + Supabase). הדוגמה: הוספת מערכת תגיות (tags) לפוסטים ב-PostForYou-style app. הזרימה זהה לכל סטאק.

למה דווקא ככה?

מתחילים בונים פיצ'רים ב-"מהקוד החוצה" — מתחילים מהקומפוננט בדף ומקווים שזה יתחבר ל-DB. ‎זרימה הפוכה עובדת טוב יותר עם Claude:

1. ‎Schema — נחליט על מבנה הנתונים
2. Migration — נעדכן את ה-DB
3. ‎Types — TypeScript types שנגזרים מה-schema
4. ‎Queries — פונקציות גישה לנתונים
5. ‎Server Actions / API — endpoints או actions
6. ‎UI — הקומפוננטים שמשתמשים בכל זה
7. ‎Tests — בסיסיים

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

שלב 0 · תכנון עם plan mode

‎Shift+Tab‎ עד שתגיע ל-plan mode. אז:

I want to add tags to posts. Each post can have multiple tags.
Tags should be reusable across posts.
Users can filter posts by tag.
Read @src/db/schema/posts.ts and @src/db/schema/users.ts to understand
the existing patterns. Then propose a plan that covers:
- DB schema changes (tables, relations)
- Migration approach
- Drizzle queries needed
- Server actions for CRUD
- UI components: tag input on post edit, tag filter on listing
- minimal tests

Don't write any code yet. Just the plan.

סקור את התוכנית, תקן אם צריך (Ctrl+G פותח את התוכנית בעורך), ואז צא מ-plan mode והתחל ליישם.

שלב 1 · ‎Schema + Migration

following the plan, implement step 1 only: the DB schema changes.

requirements:
- new `tags` table: id, name, slug, created_at
- new `post_tags` join table: post_id, tag_id (composite primary key)
- relations defined in @src/db/schema/index.ts
- match the style of existing tables (camelCase columns in code, snake_case in DB)

after writing the schema, generate a Drizzle migration:
`pnpm drizzle-kit generate`

show me the generated SQL before we apply it.

‎Claude יכתוב את ה-schema, יריץ את הפקודה, ויציג את ה-SQL. אם זה נראה תקין — אשר את ה-migration.

שלב 2 · ‎Types ו-Queries

step 2: queries.

create @src/db/queries/tags.ts with:
- getAllTags(): returns all tags ordered by name
- getTagsForPost(postId): returns tags attached to a post
- attachTagsToPost(postId, tagIds): replaces all tags for a post
- getPostsByTag(tagSlug): returns posts with a given tag, paginated

use Drizzle's prepared statements where it makes sense.
match the patterns in @src/db/queries/posts.ts.
add JSDoc comments on each function.

שלב 3 · ‎Server Actions

step 3: server actions.

create @src/app/posts/[id]/_actions.ts.
add a `updatePostTags` server action:
- accepts postId and array of tag names (existing or new)
- uses zod to validate input
- creates new tags as needed (upsert by slug)
- updates the join table
- revalidates the relevant paths
- returns { ok: true } or { ok: false, error: string }

include the auth check — only the post owner can update tags.
follow the pattern in @src/app/posts/[id]/_actions.ts existing actions.

שלב 4 · ‎UI components

step 4: UI.

build a TagInput component at @src/components/posts/TagInput.tsx:
- input with autocomplete from existing tags
- chips for selected tags
- add tag with Enter, remove with X
- Hebrew RTL — use ps-/me- not pl-/mr-
- match the styling of @src/components/ui/Input.tsx

then integrate it into the post edit form at @src/app/posts/[id]/edit/page.tsx.
on submit, call the updatePostTags server action.
show toast on success/error using @src/components/ui/Toast.

שלב 5 · בדיקה ויזואלית

@browser open localhost:3000/posts/1/edit (login as the post owner).
test:
1. add a new tag "marketing" - verify it gets created
2. add an existing tag - verify autocomplete works
3. remove a tag - verify it disappears
4. submit - verify the toast shows
5. reload - verify the tags persisted

if anything breaks, check the console, identify the cause, and fix.

שלב 6 · בדיקות אוטומטיות

step 6: tests.

write minimal tests:
- @src/db/queries/tags.test.ts: test the four query functions
  with a test database. use the patterns in posts.test.ts
- @src/app/posts/[id]/_actions.test.ts: test updatePostTags
  including the auth case (non-owner gets rejected)

run them: `pnpm test tags`. fix any failures.

שלב 7 · ‎Commit

commit these changes. the message should describe the feature
in present tense, list the main files added/changed, and reference
any patterns followed.

למה החלוקה הזו עובדת

במקום לבקש "build me a tag system" שיגרום ל-Claude לקרוא 50 קבצים ולמלא את הקונטקסט בכל פיסת מידע — אנחנו:

• מתכננים פעם אחת בהתחלה (פוקוס)
• בכל שלב נותנים scope ספציפי — קובץ אחד, פונקציה אחת
• מצביעים לפטרנים קיימים בקוד שלנו (Claude מחקה אותם)
• בודקים בכל שלב לפני שעוברים הלאה
• שומרים על קונטקסט נקי

וריאציה: ‎Backend-only feature

אם הפיצ'ר הוא רק backend (cron job, webhook handler, queue processor), הזרימה דומה אבל בלי שלבים 4-5:

1. Plan
2. ‎Schema (אם צריך)
3. Logic (services, queries)
4. ‎Endpoint / handler
5. אימות עם curl או דרך UI קיים
6. Tests
7. Commit

וריאציה: ‎Bug fix

‎Bug אינו פיצ'ר — לא מתחילים מ-schema, מתחילים מהסימפטום:

1. הצג את הסימפטום במדויק (stack trace, screenshot, צעדים לשחזור)
2. בקש failing test שמשחזר את הבאג לפני התיקון
3. אשר ש-Claude הבין את ה-root cause
4. תקן
5. הרץ את הטסט — אמור לעבור
6. הרץ את כל הבדיקות הקשורות — וודא שלא שברת משהו אחר

הזרימה הזו (failing test → fix → green) היא קלאסית, אבל עם Claude היא יעילה במיוחד כי הוא יכול גם לכתוב את הטסט וגם לתקן.

אנטי-דפוסים שכדאי להימנע מהם

• "בנה לי X, X גדול" בפרומפט אחד — Claude יקרא הרבה קבצים, יתחיל ליישם, יטעה, ויהיה לך session מזוהם. תפצל לשלבים.
• לדלג על plan mode במשימות multi-file — תחזור על העבודה פעמיים. עדיף 5 דקות תכנון.
• לא להצביע לפטרנים קיימים — Claude יכתוב במבנה הסטנדרטי שלו, שאולי שונה מהקוד-בייס שלך. כל פעם תצביע: "follow the pattern in X".
• לאשר בלי לראות diff — תמיד תסתכל. גם כשנראה משעמם.
• לא לקבץ בדיקות בסוף — תקן באג, הרץ את כל הטסטים הרלוונטיים, ורק אז commit. אחרת אתה מצטבר באגים.

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

Scope את המשימה

הצבע למקורות

הצבע לדפוסים קיימים

תאר סימפטום, מיקום סביר, ומה זה "תוקן"

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

לפיצ'רים גדולים, התחל בתיאור מינימלי ובקש מ-Claude לראיין אותך:

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 מוכן, התחל סשן חדש להרצת ה-implementation. הסשן החדש מקבל קונטקסט נקי שמתמקד רק בהרצה — ויש לך spec כתוב להפנות אליו.

תוכן עשיר ב-prompt — לא רק טקסט

הרבה משתמשים מקלידים את כל ההקשר. יש דרכים יעילות יותר:

‎@-references — שיהיה Claude יקרא את הקובץ

explain the auth flow in @src/auth/login.ts
compare @src/api/v1/users.ts with @src/api/v2/users.ts
review the changes in @ (כל הפרויקט)

הדבקת תמונות

‎Ctrl+V (או drag-and-drop) — Screenshots של errors, mockups, diagrams. Claude מנתח תמונות native:

[paste error screenshot]
trace this in our code and fix it

[paste Figma mockup]
implement this design as a React component matching @src/components/ui patterns

‎Pipes — להאכיל logs ופלטים ישר ל-Claude

# headless — תוצאה חד-פעמית
cat error.log | claude -p "summarize the errors and group by frequency"

# git diff לסקירה
git diff main | claude -p "review for bugs and security issues"

# tail ל-monitoring חי
tail -f app.log | claude -p "alert me on any 500 errors"

‎Terminal output ב-VS Code

במקום להעתיק שגיאות, השתמש ב-@terminal:name כדי שClaude יראה את הפלט ישירות:

@terminal:dev-server why does the build keep failing?

מתי דווקא prompt עמום הוא טוב

רוב הזמן רוצים ספציפיות. אבל יש מצבים שבהם prompt רחב מועיל:

• חקירה — "what would you improve in @src/api/users.ts?" מגלה לך דברים שלא חשבת לשאול עליהם
• ‎Brainstorming — "what are 5 different approaches to caching here?" נותן אפשרויות במקום לכפות החלטה מוקדמת
• Code review — "review this PR for any issues" פתוח יותר מ-"check for bugs", ויותר טוב לתפיסת בעיות לא צפויות
• ‎Codebase exploration — "what's interesting or unusual about this codebase?"

הכלל: תהיה ספציפי כשאתה יודע מה אתה רוצה. תהיה עמום כשאתה רוצה לגלות.

תקן מוקדם ובכמות

• Esc — עוצר את Claude באמצע פעולה. הקונטקסט נשמר.
• Esc Esc או /rewind — תפריט שחזור לנקודות קודמות.
• "Undo that" — Claude מחזיר את השינויים שלו.
• /clear — איפוס מלא של הקונטקסט.

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

זה הדבר היחיד הכי חזק שאתה יכול לעשות.

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

3 אסטרטגיות מעשיות

אימות UI עם Claude in Chrome

תוסף הדפדפן Claude in Chrome פותח טאבים, בודק את ה-UI, ומבצע איטרציות עד שהקוד עובד. לחלופין: test suite, linter, או פקודת Bash שבודקת פלט. השקיע בכך שה-verification שלך יהיה חזק.

‎Feedback loop אוטומטי — הדפוס החזק ביותר

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

implement the rate limiter for our API.

then enter this loop:
1. run `pnpm test rate-limiter`
2. if any test fails, read the failure, fix the code, go to step 1
3. if all pass, run `pnpm typecheck`
4. if typecheck fails, fix and go to step 1
5. if all green, stop and summarize what you did

stop conditions:
- all checks green (success)
- you've made the same fix attempt twice (regression — abort and ask me)
- 10 iterations maximum

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

אנטומיה של "exit criteria" טוב

‎exit criteria טוב מורכב משלושה חלקים:

1. תנאי הצלחה — מה צריך להיות נכון כדי שהמשימה תיחשב לסיום
2. תנאי כשלון — מתי להפסיק לנסות (כדי למנוע infinite loop)
3. פלט סופי — מה לדווח לי

migrate the user routes from Express to Hono.

success: 
  - all existing tests in tests/routes/users.* pass
  - `pnpm build` succeeds
  - no TypeScript errors

failure (abort and report):
  - more than 5 iterations of fix attempts
  - same error appears 2 times in a row
  - any tests outside the routes/ folder break

report:
  - list of files changed
  - any tests that needed to be updated
  - any new dependencies added
  - anything that surprised you or required judgment

אזהרה על infinite loops

בלי הגנה, Claude יכול להיתקע ב-loop של "fix → test fails → fix differently → test fails →...". שתי הגנות:

• ‎--max-turns ב-headless mode — מספר מקסימלי של פעולות, ‎Claude מסיים אם הגיע
• תנאי "regression" ב-prompt — "אם תיקנת אותו דבר פעמיים — תפסיק"

למשימות אינטראקטיביות (לא headless), אתה תראה אם Claude מסתבך ותעצור עם Esc. למשימות אוטונומיות זה קריטי.

סולם של verification — מהקל לחזק

תמיד תבחר את הרמה הגבוהה ביותר שזמינה לך. אם אין tests לדבר שאתה משנה — בקש מClaude לכתוב אחד לפני התיקון.

מעבר ל-CLAUDE.md ו-Skills, יש מנגנונים נוספים להתאמת Claude Code: Hooks שמריצים סקריפטים בנקודות בזרימת העבודה, ו-Subagents שמאפשרים האצלת עבודה לסוכנים מתמחים בקונטקסט נפרד. MCP — חיבור לכלים חיצוניים — מקבל פרק נפרד (פרק 14) בגלל החשיבות והעומק שלו.

Hooks — דטרמיניסטיים, לא עצות

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

• הרצת eslint או prettier אחרי כל עריכת קובץ
• חסימת כתיבה לתיקיית migrations
• הרצת lint לפני commit
• שליחת notification אחרי build כושל
• תיעוד אוטומטי של כל הפעולות לקובץ audit log

אירועי lifecycle

• PreToolUse — לפני כל קריאה לכלי. יכול לחסום או לאשר.
• PostToolUse — אחרי קריאה לכלי. שימושי לעיצוב/lint אחרי edit.
• UserPromptSubmit — כשהמשתמש שולח prompt
• SessionStart · SessionEnd — בתחילה/סוף סשן
• InstructionsLoaded — אחרי טעינת CLAUDE.md ו-rules

דוגמה 1: Prettier אוטומטי אחרי edit

בכל פעם ש-Claude עורך קובץ JS/TS, מריצים prettier. matcher מסנן את ה-hook לכלי ספציפי.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$CLAUDE_TOOL_FILE_PATH\"",
            "run_if": "$CLAUDE_TOOL_FILE_PATH =~ \\.(js|ts|tsx|jsx)$"
          }
        ]
      }
    ]
  }
}

דוגמה 2: חסימת כתיבה לתיקיית migrations

‎PreToolUse יכול לחסום פעולה ע"י החזרת exit code לא-אפס. כך מונעים מClaude לכתוב קבצים ב-db/migrations/ בטעות:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "if echo \"$CLAUDE_TOOL_FILE_PATH\" | grep -q 'db/migrations/'; then echo 'BLOCKED: migrations dir is read-only' >&2; exit 1; fi"
          }
        ]
      }
    ]
  }
}

דוגמה 3: התראה ל-Slack על build כושל

‎PostToolUse שמזהה כשל בפקודת build ושולח hook ל-Slack:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "if [ \"$CLAUDE_TOOL_EXIT_CODE\" != \"0\" ] && echo \"$CLAUDE_TOOL_INPUT\" | grep -q 'pnpm build'; then curl -X POST $SLACK_WEBHOOK_URL -d '{\"text\":\"Build failed in '$CLAUDE_PROJECT_NAME'\"}'; fi"
          }
        ]
      }
    ]
  }
}

‎Matcher patterns

‎matcher מסנן hook לכלים ספציפיים. תומך ב-regex:

• "Edit" — רק כלי Edit
• "Edit|Write" — Edit או Write
• "Bash" — כל פקודות Bash
• ".*" — הכל (זהירות, יקר ב-performance)

בקש מ-Claude לכתוב hooks בשבילך

הדרך הקלה ביותר ליצור hook — לבקש מClaude:

Write a hook that runs pnpm typecheck after every Edit on .ts files,
and blocks the commit if it fails. Add it to .claude/settings.json.

‎Debugging של hooks

‎/hooks בתוך session מציג את ה-hooks הפעילים. אם hook לא מופעל כשציפית — בדוק:

• ‎matcher מתאים לכלי הנכון? (case-sensitive)
• הפקודה רצה? בדוק עם echo "$CLAUDE_TOOL_FILE_PATH" זמני
• ה-exit code חוזר נכון? (0 = הצליח, !=0 = נחסם)

Subagents — מומחיות בידודית

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

---
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 להשתמש: "Use a subagent to review this code for security issues."

‎Built-in agents — מוכנים לשימוש

Claude Code מגיע עם כמה subagents מובנים שאפשר להפעיל מיד:

• Explore — חקירת קוד-בייס במצב read-only, מותאם לcodebase exploration
• Plan — תכנון פיצ'ר או refactor
• general-purpose — ברירת מחדל לכל משימה

הפעלה מתוך skill עם context: fork:

---
name: research
description: Deep research on a topic
context: fork
agent: Explore
---
Research $ARGUMENTS thoroughly...

Plugins — חבילות מוכנות

‎/plugin פותח את ה-marketplace. Plugins מחברים skills, hooks, subagents, ו-MCP servers ליחידה אחת. עבור שפות מוטיפסות, התקן code intelligence plugin שמספק ל-Claude ניווט מדויק בסמלים וזיהוי שגיאות אוטומטי אחרי עריכות.

‎CLI tools — היעילים ביותר ב-context

אמור ל-Claude להשתמש ב-CLI tools כמו gh, aws, gcloud, sentry-cli. אלו הדרך החסכונית ביותר ב-context לעבוד עם שירותים חיצוניים. גם כלים שלא מכיר — נסה: "Use 'foo-cli-tool --help' to learn about foo tool, then use it to solve A, B, C."

‎Model Context Protocol הוא סטנדרט פתוח שמחבר Claude למאות כלים, בסיסי נתונים, ו-APIs. כשאתה מוצא את עצמך מעתיק נתונים מ-Jira, Notion, או Postgres לתוך הצ'אט — זה הסימן להתקין שרת MCP. אחרי החיבור, Claude יכול לקרוא ולפעול ישירות במקום לעבוד ממה שהדבקת.

מה אפשר לעשות עם MCP

• פיצ'רים מ-issue tracker: "הוסף את הפיצ'ר המתואר ב-JIRA ENG-4521 ופתח PR ב-GitHub"
• נתוני monitoring: "בדוק ב-Sentry ובStatsig את השימוש בפיצ'ר ENG-4521"
• שאילתות DB: "מצא 10 משתמשים אקראיים שהשתמשו בפיצ'ר ENG-4521 לפי ה-Postgres שלנו"
• שילוב עיצובים: "עדכן את תבנית האימייל שלנו לפי העיצוב החדש שפורסם ב-Slack"
• אוטומציה: "צור drafts ב-Gmail להזמנת 10 המשתמשים האלה לסשן feedback"

שלוש שיטות התקנה

1. ‎HTTP server (מומלץ)

השיטה הנפוצה לשירותי ענן. רוב ספקי MCP פופולריים תומכים בזה:

# תחביר בסיסי
claude mcp add --transport http <name> <url>

# דוגמה: חיבור ל-Notion
claude mcp add --transport http notion https://mcp.notion.com/mcp

# דוגמה עם Bearer token
claude mcp add --transport http secure-api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"

2. ‎Stdio server (לוקלי)

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

# דוגמה: חיבור ל-Postgres קריאה בלבד
claude mcp add --transport stdio db -- npx -y @bytebase/dbhub \
  --dsn "postgresql://readonly:pass@prod.db.com:5432/analytics"

# דוגמה: Airtable עם API key
claude mcp add --transport stdio --env AIRTABLE_API_KEY=YOUR_KEY airtable \
  -- npx -y airtable-mcp-server

3. ‎SSE server (Deprecated)

‎Server-Sent Events. הוחלף ב-HTTP. השתמש רק אם אין אופציה אחרת:

claude mcp add --transport sse asana https://mcp.asana.com/sse

ניהול שרתים

# רשימה של כל השרתים
claude mcp list

# פרטים על שרת ספציפי
claude mcp get github

# מחיקה
claude mcp remove github

# מתוך Claude — סטטוס ו-OAuth
/mcp

שלושה Scopes — איפה השרת מאוחסן

# שרת לכל הפרויקטים שלך (user scope)
claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic

# שרת לפרויקט, משותף עם הצוות (project scope)
claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp

‎.mcp.json — קובץ פרויקט משותף

שרתים ב-project scope נשמרים ב-.mcp.json בשורש הפרויקט. תכליתו להיות commit ל-git כך שכל הצוות מקבל אותם שרתים:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@bytebase/dbhub", "--dsn", "${DATABASE_URL}"],
      "env": {}
    }
  }
}

לאבטחה, Claude מבקש אישור לפני שימוש בשרתים מ-.mcp.json. לאיפוס: claude mcp reset-project-choices.

‎Environment variables ב-.mcp.json

תחביר נתמך:

• ${VAR} — מתרחב לערך של VAR
• ${VAR:-default} — VAR אם מוגדר, אחרת default

{
  "mcpServers": {
    "api-server": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": {
        "Authorization": "Bearer ${API_KEY}"
      }
    }
  }
}

‎OAuth Authentication

הרבה שרתים דורשים OAuth. Claude Code תומך מובנה:

1. הוסף את השרת: claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
2. בתוך Claude: /mcp
3. בחר את השרת ועקוב אחר ה-flow בדפדפן להתחברות
4. הטוקנים נשמרים מאובטחים ומתרעננים אוטומטית

ל-revoke: ב-/mcp בחר "Clear authentication".

‎@mention — שימוש ב-MCP resources

שרתי MCP יכולים לחשוף resources שאתה יכול להפנות אליהם עם @:

Can you analyze @github:issue://123 and suggest a fix?
Please review the API documentation at @docs:file://api/authentication
Compare @postgres:schema://users with @docs:file://database/user-model

שרתי MCP פופולריים

• GitHub — https://api.githubcopilot.com/mcp/ — PR reviews, issues, branches
• Sentry — https://mcp.sentry.dev/mcp — מעקב errors
• Notion — https://mcp.notion.com/mcp — קריאה/כתיבה של דפים
• Linear / Asana / Jira — issue trackers
• Postgres / MySQL — דרך @bytebase/dbhub
• Stripe — https://mcp.stripe.com — נתונים פיננסיים
• Slack — קריאת הודעות, שליחה
• Filesystem — גישה לתיקיות מחוץ ל-CWD

אלפי שרתים נוספים ב-github.com/modelcontextprotocol/servers. השתמש בשרתי MCP של צד שלישי על אחריותך — Anthropic לא בודקת את כולם. היזהר במיוחד עם שרתים שיכולים להביא תוכן לא-אמין (סיכון prompt injection).

דוגמאות מעשיות

מעקב errors עם Sentry

claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
# בתוך Claude:
/mcp  # חבר עם OAuth

# ואז:
What are the most common errors in the last 24 hours?
Show me the stack trace for error ID abc123
Which deployment introduced these new errors?

‎GitHub עם PAT

צור Personal Access Token ב-GitHub settings, ואז:

claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
  --header "Authorization: Bearer YOUR_GITHUB_PAT"

# שימוש:
Review PR #456 and suggest improvements
Create a new issue for the bug we just found
Show me all open PRs assigned to me

‎Postgres קריאה בלבד

claude mcp add --transport stdio db -- npx -y @bytebase/dbhub \
  --dsn "postgresql://readonly:pass@prod.db.com:5432/analytics"

# שאילתות בשפה טבעית:
What's our total revenue this month?
Show me the schema for the orders table
Find customers who haven't made a purchase in 90 days

שימוש ב-MCP servers מ-claude.ai

אם התחברת ל-Claude Code עם חשבון claude.ai, שרתי MCP שהוספת ב-claude.ai/customize/connectors זמינים אוטומטית גם ב-Claude Code. /mcp מציג אותם עם סימון שהם מ-claude.ai.

‎Tool Search — חיסכון בקונטקסט

‎MCP servers טוענים את ה-tools שלהם לקונטקסט. אם יש לך הרבה שרתים, זה צורך הרבה tokens אפילו לפני שהתחלת. Tool Search מופעל כברירת מחדל ודוחה טעינה — Claude מחפש כלים רק כשהוא צריך אותם, ורק הכלים שבאמת נדרשים נכנסים לקונטקסט.

אם אתה רוצה שכלים מסוימים תמיד יהיו זמינים בלי חיפוש:

{
  "mcpServers": {
    "core-tools": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "alwaysLoad": true
    }
  }
}

‎MCP output limits

‎Claude מציג אזהרה אם פלט של MCP tool עובר 10,000 tokens. הגבול הקשה הוא 25,000. אם שרת מחזיר תדיר תוצאות גדולות:

export MAX_MCP_OUTPUT_TOKENS=50000
claude

‎Claude Code כשרת MCP

אפשר להשתמש ב-Claude Code עצמו כ-MCP server שאפליקציות אחרות (כמו Claude Desktop) יכולות להתחבר אליו:

claude mcp serve

Skills הם הדרך העיקרית להרחיב את היכולות של Claude. כל skill הוא קובץ SKILL.md עם הוראות; Claude מוסיף אותו ל-toolkit שלו ומפעיל אותו אוטומטית כשרלוונטי, או שאתה מפעיל ישירות עם /skill-name.

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

Skill ראשון — דוגמה מלאה

נבנה skill שמסכם את השינויים הלא-מקומיטים ב-git ומדגיש סיכונים. Claude יטען אותו אוטומטית כשתשאל על השינויים שלך, או שתוכל להפעיל ישירות עם /summarize-changes.

mkdir -p ~/.claude/skills/summarize-changes

---
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.
---

## Current changes

!`git diff HEAD`

## Instructions

Summarize the changes above in two or three bullet points, then list any risks you notice such as missing error handling, hardcoded values, or tests that need updating. If the diff is empty, say there are no uncommitted changes.

איפה Skills חיים

‎Live change detection: עריכת skill ב-session פעיל נכנסת לתוקף מיד, בלי restart. רק יצירת תיקיית skills חדשה לגמרי דורשת restart.

שני סוגי תוכן ב-skill

1. Reference content — ידע

Conventions, patterns, style guides, ידע דומיין. רץ inline כך ש-Claude משתמש בו לצד הקונטקסט של השיחה.

---
name: api-conventions
description: API design patterns for this codebase
---

When writing API endpoints:
- Use RESTful naming conventions
- Return consistent error formats
- Include request validation

2. Task content — פעולה

הוראות צעד-צעד לפעולה ספציפית: deployments, commits, יצירת קוד. בדרך כלל אתה מפעיל אותם ישירות עם /skill-name. הוסף disable-model-invocation: true כדי שClaude לא יפעיל אוטומטית.

---
name: deploy
description: Deploy the application to production
disable-model-invocation: true
---

Deploy the application:
1. Run the test suite
2. Build the application
3. Push to the deployment target

‎Frontmatter — כל השדות

‎String substitutions בתוך ‎SKILL.md

• $ARGUMENTS — כל הארגומנטים שהועברו
• $ARGUMENTS[N] · $N — ארגומנט ספציפי לפי אינדקס
• $name — ארגומנט מסומן (לפי arguments ב-frontmatter)
• ${CLAUDE_SESSION_ID} — מזהה הסשן
• ${CLAUDE_EFFORT} — רמת המאמץ הנוכחית
• ${CLAUDE_SKILL_DIR} — תיקיית ה-SKILL.md (לקריאה לסקריפטים בה)

‎Skill עם ארגומנטים

---
name: migrate-component
description: Migrate a component from one framework to another
---

Migrate the $0 component from $1 to $2.
Preserve all existing behavior and tests.

הפעלה: /migrate-component SearchBar React Vue

הזרקת Context דינמי — הפיצ'ר העוצמתי ביותר

הסינטקס !`command` מריץ פקודות shell לפני ש-Claude רואה את ה-skill. הפלט מחליף את ה-placeholder. זה לא משהו ש-Claude מריץ — זו preprocessing. Claude רק רואה את התוצאה הסופית עם נתונים אמיתיים.

---
name: pr-summary
description: Summarize changes in a pull request
context: fork
agent: Explore
allowed-tools: Bash(gh *)
---

## Pull request context
- PR diff: !`gh pr diff`
- PR comments: !`gh pr view --comments`
- Changed files: !`gh pr diff --name-only`

## Your task
Summarize this pull request...

למספר שורות, השתמש בבלוק קוד שפותח ב-```!:

## Environment
```!
node --version
npm --version
git status --short
```

קבצי תמיכה

Skill לא חייב להיות רק SKILL.md. אפשר להוסיף templates, examples, ו-scripts:

my-skill/
├── SKILL.md           # ראשי (חובה)
├── reference.md       # ‎API docs מפורטים — נטען לפי דרישה
├── examples.md        # דוגמאות שימוש — נטענות לפי דרישה
└── scripts/
    └── helper.py      # סקריפט שClaude מריץ

הפנה לקבצים מ-SKILL.md כדי ש-Claude יידע מה יש בכל אחד. שמור את SKILL.md מתחת ל-500 שורות; חומר ייחוס מפורט — לקבצים נפרדים.

הרצת Skill ב-subagent מבודד

‎context: fork מריץ את ה-skill בקונטקסט נפרד עם sub-agent. תוכן ה-skill הופך ל-prompt שמניע את ה-subagent. שימושי לחקירות שלא רוצים שיזהמו את הקונטקסט הראשי:

---
name: deep-research
description: Research a topic thoroughly
context: fork
agent: Explore
---

Research $ARGUMENTS thoroughly:

1. Find relevant files using Glob and Grep
2. Read and analyze the code
3. Summarize findings with specific file references

‎Skills מובנים (bundled)

Claude Code מגיע עם כמה skills מובנים שזמינים בכל סשן:

• /simplify — פישוט קוד
• /batch — הרצת פעולות במקביל
• /debug — דיבוג מסיסטמטי
• /loop — ‎polling במחזורים
• /claude-api — עזרה עם API של Claude

שליטה במי שמפעיל skill

מחזור החיים של תוכן ‎skill

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

בעת compaction, ה-skill הכי מאוחר שהופעל מקבל עד 5,000 tokens; כל ה-skills שהופעלו מחלקים תקציב משולב של 25,000 tokens. אם השפעת ה-skill נחלשת — או שהמודל בחר גישה אחרת, או שהוא נדחף החוצה ע"י skills מאוחרים יותר. הפעל מחדש כדי לשחזר.

תרחישי שימוש מומלצים לסולו-מפתחים

לפי הפרויקטים הטיפוסיים שלך, כמה skills שיכולים להיות שימושיים:

• /commit — ‎skill עם disable-model-invocation: true שמריץ git status ו-git diff דרך הזרקה דינמית, מסכם, ומציע commit message
• /db-migration — ‎skill ספציפי לפרויקט שיוצר migration ב-Drizzle/Prisma לפי השבלונה שלך
• /rtl-component — ‎skill שמייצר רכיב React חדש עם תמיכת RTL מובנית, dir="rtl", logical properties, ופורמט תאריכים ב-he-IL
• /security-audit — ‎skill עם context: fork שמריץ סקירת אבטחה ב-subagent מבודד
• /hebrew-spell-check — ‎skill שבודק טקסט עברי בקבצים לפני commit (כתיב נכון, ניקוד, RTL)

פתרון תקלות

• ‎Skill לא מופעל אוטומטית: ודא ש-description כולל מילות מפתח שהמשתמש היה אומר באופן טבעי. שאל "What skills are available?" כדי לוודא שClaude רואה אותו.
• ‎Skill מופעל יותר מדי: תקן את ה-description להיות יותר ספציפי, או הוסף disable-model-invocation: true.
• תיאורים נחתכים: אם יש לך הרבה skills, התיאורים נחתכים לפי תקציב תווים. שים את ה-use case המרכזי בתחילת ה-description. אפשר להעלות את התקציב ע"י SLASH_COMMAND_TOOL_CHAR_BUDGET.

אחרי שאתה יעיל עם Claude אחד — תוכל להכפיל את התפוקה עם sessions מקבילים, headless mode, ו-fan-out patterns.

Headless mode (‎-p)

# שאילתת חד-פעמית
claude -p "Explain what this project does"

# פלט מובנה לסקריפטים
claude -p "List all API endpoints" --output-format json

# Streaming לעיבוד בזמן אמת
claude -p "Analyze this log file" --output-format stream-json

שילוב ב-pipelines:

tail -200 app.log | claude -p "Slack me if you see any anomalies"
git diff main --name-only | claude -p "review these changed files for security issues"
claude -p "translate new strings into French and raise a PR for review"

Worktrees — sessions מקבילים

הרץ feature אחד בטרמינל אחד, ובאותו זמן Claude מתקן באג בשני — בלי שה-edits יתנגשו. כל worktree הוא checkout נפרד עם branch משלו:

claude --worktree feature-auth

‎Writer / Reviewer pattern

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

‎Fan-out על-פני קבצים

למיגרציות גדולות, פזר עבודה על-פני הרצות מקבילות:

claude -p "list all 2,000 Python files that need migrating" > files.txt

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

Auto mode להרצה אוטונומית

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

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

‎Safeguards להרצה ללא השגחה

כשClaude רץ ללא השגחה (CI, scheduled task, headless), חיוני לקבוע גבולות. בלעדיהם — Claude יכול להיתקע ב-loop, לשרוף budget, או לעשות נזק לפני שהבחנת:

# הגבל מספר turns (Claude מסיים אם הגיע למגבלה)
claude -p "refactor the auth module" --max-turns 20

# הגבל budget בדולרים
claude -p "fix all type errors" --max-budget-usd 5.00

# שילוב — הכי בטוח להרצה אוטונומית
claude --permission-mode auto -p "fix all lint errors" \
  --max-turns 30 --max-budget-usd 2.00

# fallback למודל זול אם המודל הראשי עמוס
claude -p "translate strings" --fallback-model sonnet

# הגבל כלים ספציפיים בלבד
claude -p "review files" --allowedTools "Read,Grep,Glob"

# bare mode — מהיר יותר, ללא MCP/skills/hooks
claude --bare -p "summarize this log file"

כלל אצבע: ל-headless production תמיד שלב --max-turns + --max-budget-usd. אלה הגנה אחרונה אם משהו השתבש.

שילוב ב-GitHub Actions — דוגמה מלאה

‎workflow שמריץ Claude לסקירת PR אוטומטית בכל פעם שנפתח PR חדש:

name: Claude PR Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install Claude Code
        run: curl -fsSL https://claude.ai/install.sh | bash

      - name: Run Claude review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          git diff origin/main...HEAD > /tmp/diff.txt
          claude -p "Review this PR diff. Focus on:
          - Bugs and logic errors
          - Security issues
          - Missing error handling
          - Tests for new code
          
          Return findings in markdown. Be concise.
          
          Diff: $(cat /tmp/diff.txt)" \
            --max-turns 10 \
            --max-budget-usd 1.00 \
            --output-format json > /tmp/review.json

      - name: Post review as comment
        uses: actions/github-script@v7
        with:
          script: |
            const review = require('/tmp/review.json');
            await github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## 🤖 Claude Review\n\n${review.result}`
            });

טיפים ל-CI:

• השתמש ב-claude setup-token ליצירת long-lived OAuth token (חלופה ל-API key)
• תמיד --max-budget-usd כדי שלא תקבל הפתעה בחשבון
• בקש פלט JSON ופרסר אותו מאשר להניח שהפלט הוא markdown
• הגדר --fallback-model sonnet אם אתה רוצה שיעבוד גם בעומס

Routines — הרצה מתוזמנת

‎Routines רצים על תשתית של Anthropic — ממשיכים גם כשהמחשב כבוי. שימושי למשימות שחוזרות:

דוגמאות לroutines פרקטיים

• סקירת PRs בבוקר — "review all PRs labeled needs-review, post inline comments, summarize in #eng-reviews"
• ‎Audit שבועי של dependencies — "check for security advisories on all packages in package.json. open issues for critical ones."
• ניתוח כשלי CI לילי — "look at the last 24h of failed CI runs. group by root cause. open issue with summary."
• סנכרון תיעוד אחרי merge — "after each merge to main, check if README needs updating. open PR if yes."

דוגמת prompt טוב ל-routine

‎routine רץ אוטונומית — לא יכול לשאול שאלות הבהרה. כתוב את ה-prompt באופן מלא:

# רע — עמום מדי
"check for failing tests"

# טוב — מפורט, קריטריוני סיום ברורים
Run pnpm test. If anything fails:
1. Open a GitHub issue with title "Test failures: [date]"
2. Include the test output (truncated to 100 lines)
3. Tag with `failing-tests` and `auto-generated`
4. If an issue with that title was opened in last 24h, comment instead
5. Post a summary to #eng-alerts on Slack

If all tests pass: silent. No notification needed.

Budget: 5 minutes max. If you can't complete in 5 min, abort and notify me.

צור routine מהדפדפן ב-claude.ai/code/routines, מאפליקציית הדסקטופ, או עם /schedule ב-CLI.

‎Desktop scheduled tasks (חלופה לroutines)

‎Routines רצים בענן של Anthropic — אין להם גישה לקבצים מקומיים, ל-uncommitted changes, או לסביבה הספציפית שלך. אם צריך זה — Desktop scheduled tasks (ב-Desktop app) רצים על המחשב שלך.

טבלת השוואה:

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

1. ה-"kitchen sink session"

איך זה נראה:

[15:00] You: fix the auth bug in login.ts
[15:30] You: actually, can you also add a dark mode toggle?
[16:00] You: btw, what's a good library for date formatting?
[16:15] You: ok back to the auth bug — why isn't your fix working?
Claude: Looking at the code... [reads 8 files about dark mode and dates]

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

תיקון: /clear בין משימות לא קשורות. אם אתה רוצה לחזור לבאג הראשון — /clear, ואז התחל מחדש: "fix the auth bug in @src/auth/login.ts. error: [paste]".

2. תיקון אחר תיקון

איך זה נראה:

You: add validation to the email field
Claude: [adds basic regex]
You: that's wrong, it doesn't catch user@.com
Claude: [adds another check]
You: still wrong, now valid emails get rejected
Claude: [tries again]
You: NO. you're not fixing the actual problem.

הסימן: תיקנת אותו 2-3 פעמים על אותו דבר ועדיין לא עובד.

תיקון:

1. /clear
2. ‎prompt חדש שכולל את הקריטריונים המדויקים: "add email validation to the email field. test cases that must pass: 'a@b.co' valid, 'user@.com' invalid, 'user@example' invalid, 'a@b.c' invalid (TLD must be 2+ chars). use these exact tests."

3. ‎CLAUDE.md מנופח

איך זה נראה: ה-CLAUDE.md שלך עבר 200 שורות. אתה כותב כללים אבל Claude ממשיך להתעלם מחציים. אתה מוסיף "IMPORTANT" ו-"YOU MUST" — לא עוזר.

הסימן: כללים חשובים נאבדים בתוך הרעש. Claude עוקב אחרי 3-4 הכללים הראשונים ושוכח את השאר.

תיקון:

1. פתח את ה-CLAUDE.md ושאל לכל שורה: "האם הסרת השורה הזו תגרום ל-Claude לטעות?"
2. מחק את כל מה שלא עובר את הבדיקה
3. הזז כללים path-specific ל-.claude/rules/ עם paths: frontmatter
4. הזז workflows ארוכים ל-skills (.claude/skills/)

4. ‎Trust-then-verify gap

איך זה נראה:

You: add pagination to the products list
Claude: Done! Added pagination with page/limit params.
You: [merges] [user reports broken]
Investigation: pagination works for English chars only.
Hebrew characters in product names break the cursor.

הסימן: הקוד "נראה סביר" אבל לא ראית אותו רץ במקרים אמיתיים.

תיקון: תמיד בקש verification:

• "after implementing, run the tests and show me the output"
• "@browser open localhost:3000/products and verify pagination works on a list with 50+ items"
• "include test cases for: empty list, single item, exactly N items, Hebrew product names, special chars"

5. חקירה אינסופית

איך זה נראה:

You: investigate why our build is slow
Claude: [reads webpack.config.js] [reads next.config.js] [reads package.json]
       [reads 30 component files] [reads tsconfig.json]
       [reads .eslintrc] [reads README] ...
Status bar: Context: 78% used

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

תיקון: תמיד תן scope לחקירות, או האצל ל-subagent:

# במקום
investigate why our build is slow

# העדף
use a subagent to investigate why our build is slow.
focus on bundle size and number of dependencies.
return a summary of findings, not file contents.

6. ‎"השלמת קוד אופטימית"

איך זה נראה:

You: integrate Stripe checkout
Claude: Done! Added Stripe integration.
       [imports a function that doesn't exist]
       [uses an API endpoint that doesn't exist in Stripe SDK]
       [returns config that the deploy environment doesn't have]
You: [tries to run it] ReferenceError: stripe.checkout.create is not a function

הסימן: Claude כותב קוד שמרגיש סביר אבל מתבסס על API שלא קיים, package version ישן, או הנחות לא נכונות.

תיקון:

1. הצמד אותו לתיעוד אמיתי: "before implementing, fetch the current Stripe Node SDK docs from stripe.com/docs/api"
2. בקש שיריץ את הקוד: "after writing, run a smoke test that creates a checkout session — must actually succeed"
3. הצמד ל-package.json שלך: "check our @package.json — we use stripe v15. write code compatible with that version specifically"

7. רצף השאלות

איך זה נראה:

You: build a CSV export feature
Claude: Should it include all columns or selected? What separator?
       What encoding? Should it stream or buffer? What filename pattern?
       How should errors be handled? Should there be a progress bar?
       ...

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

תיקון: תן לו לחקור ולהציע, ולא לראיין:

# במקום לחכות לשאלות
build a CSV export feature

# העדף — תן הקשר ובקש הצעה
build a CSV export for the orders table.
look at how we handle other exports in @src/exports/.
follow the same pattern. propose your approach in 3 bullet points
before implementing — I'll approve or adjust.

הערה הפוכה: אם המשימה באמת מורכבת — בקש "interview me using AskUserQuestion" כדי לקבל ראיון מובנה (פרק 11).

פקודות בתוך session (‎/-commands)

קיצורי מקלדת

• Esc — עצירת Claude באמצע פעולה
• Esc Esc — תפריט rewind
• Shift+Tab — מעבר בין מצבי הרשאה
• Ctrl+G — פתיחת תוכנית בעורך טקסט (ב-plan mode)
• ↑ — היסטוריית פקודות
• Tab — השלמה אוטומטית
• ? — כל הקיצורים
• Ctrl+V — הדבקת תמונה (לא Cmd+V!)

הפרק הזה מתרגם את כל מה שלמדת ל-checklist מסודר. אם אתה מתחיל עכשיו — עבור לפי הסדר. אם אתה כבר משתמש בClaude Code — סקור את החלק שאתה כנראה דילגת עליו (רוב המשתמשים מדלגים על Skills ו-MCP).

השעה הראשונה — Setup בסיסי

1. התקן את Claude Code — נייטיב מומלץ (פרק 2)
2. ‎claude /login והתחבר
3. פתח VS Code, התקן את התוסף הרשמי (פרק 3)
4. בחר איפה Claude יושב — Secondary Sidebar (ימין) מומלץ
5. ‎cd /path/to/your/project והרץ claude או פתח את הפאנל ב-VS Code
6. שאל "what does this project do?" — Claude יקרא ויסכם
7. הרץ /init — Claude יצור CLAUDE.md ראשוני (פרק 6)

היום הראשון — משימה אמיתית

1. בחר משימה קטנה ואמיתית (תיקון bug קטן, הוספת flag לפונקציה, תיעוד קובץ אחד)
2. ‎Shift+Tab‎ עד שתגיע ל-plan mode
3. תאר את המשימה במשפט אחד וצרף קובץ עם @
4. סקור את התוכנית. ‎Ctrl+G‎ לעריכה אם צריך
5. צא מ-plan mode והפעל
6. סקור כל diff לפני אישור
7. בקש מ-Claude לעשות commit עם הודעה תיאורית
8. נסה /clear כשאתה עובר למשימה הבאה

השבוע הראשון — לבסס הרגלים

• ערוך את CLAUDE.md בכל פעם שאתה רואה את עצמך מתקן את Claude על אותה טעות פעם שנייה
• השתמש ב-/clear בין משימות לא קשורות — תרגיש את ההבדל
• נסה plan mode לפחות פעם ביום
• נסה לפחות פעם אחת — "Use a subagent to investigate ..." כשאתה צריך לחקור
• אם אתה בונה אפליקציה web: התקן את Claude in Chrome extension, נסה --chrome פעם ראשונה (פרק 9)
• בדוק /usage אחרי משימה גדולה — תפתח אינטואיציה לעלויות

החודש הראשון — להתעמק

• צור skill ראשון לפעולה שאתה עושה תדיר (commit message, code review של קובץ ספציפי)
• קרא את פרק 10 (Full-stack workflow) ויישם משימה אחת לפי המסגרת ההיא — תתפלא איך זה משנה
• חבר MCP server ראשון — אם אתה משתמש ב-GitHub / Sentry / Postgres, זה יחסוך לך שעות
• הגדר hook אחד פשוט — לדוגמה הרצת lint אחרי edit
• נסה worktrees — הרץ שני sessions במקביל על אותו repo
• קבע defaultMode בהגדרות אם אתה תמיד עובד באותו מצב

אחרי 3 חודשים — מתקדם

• הקם ‎.claude/rules/‎ מודולרי במקום CLAUDE.md אחד גדול
• צור subagents מותאמים לתחומים שלך (security-reviewer, db-reviewer, copy-editor)
• השתמש ב-auto mode למשימות ארוכות שאתה סומך על הכיוון הכללי
• שלב Claude Code ב-CI עם GitHub Actions לסקירות PR אוטומטיות
• למד את ה-headless mode ושלב ב-pipelines קיימים
• נסה Routines — סקירת PRs יומית בבוקר, audit שבועי של dependencies
• פתח skill עם context: fork שמריץ ב-Explore agent

חמשת התרגלים שמבדילים בין משתמש בינוני למשתמש מתקדם

1. Plan first. תמיד plan mode למשימות multi-file. דקה תכנון = שעה זמן עבודה.
2. ‎/clear אחרי משימה. אל תיתן לקונטקסט להזדהם.
3. הצבע לפטרנים. "follow the pattern in @file.ts" עדיף על תיאור הסגנון.
4. אמת ויזואלית. Screenshot, test, או browser check — אחרי כל שינוי משמעותי.
5. שמור על CLAUDE.md קצר ועדכני. מתחת ל-200 שורות. תקצץ באכזריות.

השליטה לא באה מהיכרות עם כל פיצ'ר — היא באה מתרגול חוזר של חמישה הרגלים פשוטים.

הסעיף הזה לא חלק מהתיעוד הרשמי — אלו עצות מעשיות לסביבה ישראלית טיפוסית.

‎PowerShell על Windows

‎Claude Code עובד טוב ב-PowerShell, אבל אם הותקן Git for Windows הוא יעדיף את Bash דרך Git Bash. זה רצוי, כי הרבה מהדוגמאות בתיעוד הן Bash. אם אתה ב-PowerShell, שים לב שפקודות עם && לא יעבדו — ב-PowerShell משתמשים ב-; או ב--and.

תקשורת בעברית או באנגלית?

אפשר לבקש מ-Claude לתקשר בעברית — הוא יעשה זאת מצוין, כולל הסברים, הערות ותיעוד. עם זאת:

• שמות משתנים, פונקציות, branch names — באנגלית. זה גם best practice וגם ימנע באגים בכלים.
• הערות בקוד — תלוי בצוות. פרויקט סולו? בעברית זה בסדר. צוות בינלאומי? אנגלית.
• ‎CLAUDE.md — כדאי באנגלית. מודלי שפה עובדים יותר טוב עם הוראות באנגלית, ובכל מקרה זה context שאתה לא תקרא הרבה.
• ‎commit messages, PR descriptions — תלוי בצוות. כמובן שאם הצוות בעברית — אז בעברית.

RTL ב-frontend

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

# Localization
- App is Hebrew-first, RTL primary direction
- All UI components must support RTL via dir="rtl" or CSS logical properties
- Use logical properties: padding-inline-start instead of padding-left
- Don't hardcode 'right'/'left' — use 'inline-start'/'inline-end'
- Date/number formatting via Intl API with 'he-IL' locale

‎API keys ו-secrets — שים לב

‎Claude Code רץ מקומית ויכול לקרוא קבצים. הוא לא שולח את הקוד שלך לאף אחד אחר חוץ מ-Anthropic לצורך השלמת ה-prompt. עדיין:

• שמור secrets ב-.env ולא בקוד
• ‎.env.local ו-CLAUDE.local.md ב-.gitignore
• בדוק עם git log -p שלא חשפת בטעות secrets בעבר; אם כן — סבב את הסודות וטפל ב-history עם git filter-repo

‎Multi-project — כמו שלך

אם אתה מנהל כמה SaaS במקביל (כמו פוסטים, קליניקה, וכו'), הגדר user-level CLAUDE.md ב-~/.claude/CLAUDE.md עם העדפות גלובליות שלך, ו-CLAUDE.md ספציפי לכל פרויקט. ה-rules תחת ~/.claude/rules/ יחולו על כל הפרויקטים.

שילוב מומלץ:

• ‎~/.claude/CLAUDE.md — סגנון אישי, העדפות communication, "אני לא חובב bullet points ארוכים"
• ‎./CLAUDE.md — stack של הפרויקט, conventions, build commands
• ‎./.claude/rules/*.md — חוקים path-scoped (frontend rules, API rules, וכו')
• ‎./.claude/skills/ — workflows חוזרים שאתה רוצה להפעיל ידנית

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

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

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

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

‎Anthropic Academy מציעה סדרת קורסים חינמיים עם וידאו, תרגילים ובחנים שעוסקים בעבודה ובפיתוח עם Claude Code, ‎Claude API, ‎Skills, ‎Subagents ו-MCP. הקורסים מתאימים מאוד אחרי שעברת על המדריך הזה — הם מעמיקים בכל נושא עם דמו חי ותרגול ממשי.

ריכזתי את הקטלוג בעברית — כולל מטרות לימוד, תוכנית מלאה, דרישות קדם, מסלולי למידה לפי רמה (מתחיל / מפתח עצמאי / בונה אפליקציות AI / מסלול מלא) וקישור להרשמה ישירה לכל קורס:

הקורסים חינמיים ודורשים רק חשבון ב-Skilljar (לא חייב חשבון Anthropic). בסיום כל קורס מקבלים תעודה. תרגום זה הוא בלתי רשמי — המקור באנגלית הוא הגרסה המחייבת, וזמין ב-anthropic.skilljar.com.