ניווט וחיפוש — Navigation and Search

התמונה הגדולה — למה ששת הכלים ולא אחד

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

הנה הרעיון המרכזי: כל כלי עונה על שאלה אחרת:

הכלי	השאלה שהוא עונה עליה	אנלוגיה
Glob	"איפה הקובץ הזה?"	מצביע שמראה על ארון ספציפי
Grep	"מה כתוב בתוך הקבצים?"	מנוע חיפוש פנימי
Read	"מה בדיוק כתוב כאן?"	משקפיים — מסתכלים ישירות
Agent	"איך כל זה מתחבר?"	עוזר מחקר שקורא הכל
WebSearch	"מה קורה בעולם?"	חיפוש בגוגל
WebFetch	"מה כתוב בדף הזה?"	גלישה לכתובת ספציפית

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

Glob — חיפוש קבצים לפי שם

Glob הוא כלי החיפוש הראשון שצריך להכיר. הוא עושה דבר אחד ועושה אותו מצוין: מוצא קבצים לפי שם. חשבו על Glob כמו סייר קבצים חכם — אתם נותנים לו דפוס (Pattern), והוא מחזיר את כל הקבצים שמתאימים לדפוס.

המילה Glob מגיעה מעולם ה-Unix ומשמעותה "Global Pattern Matching". זה לא ביטוי רגולרי (Regex) — זה הרבה יותר פשוט. יש בו שני תווים עיקריים שצריך לזכור:

תו	משמעות	דוגמה	מה מוצא
*	כל תווים בשם הקובץ (ברמה אחת)	*.txt	כל קבצי ה-txt בתיקייה הנוכחית
**	כל עומק של תת-תיקיות (רקורסיבי)	**/*.txt	כל קבצי ה-txt בכל התיקיות, בכל עומק
{a,b}	אחת מהאפשרויות ברשימה	**/*.{json,yaml,yml}	כל קבצי JSON ו-YAML בכל מקום
?	תו בודד כלשהו	file?.txt	file1.txt, fileA.txt — אבל לא file12.txt

דפוסים שימושיים שכדאי לשנן

מה מחפשים	דפוס Glob
כל קבצי React (TSX) בתיקיית src	src/**/*.tsx
כל קבצי ה-config בכל מקום	**/*.config.*
כל קבצי הבדיקות	**/*test* או **/*spec*
כל קבצי Markdown	**/*.md
כל קבצי ה-CSS ו-SCSS	**/*.{css,scss}
קבצי ה-index בכל תיקייה	**/index.*
כל קובצי הנתונים	**/*.{json,csv,xml}

Glob מאחורי הקלעים — מה קורה כשמחפשים

כשאתם מבקשים מ-Claude Code "מצא את כל קבצי ה-Python", זה מה שקורה בפועל:

1. Claude מתרגם את הבקשה שלכם לדפוס Glob: **/*.py
2. Glob סורק את מבנה התיקיות — רקורסיבית מהתיקייה הנוכחית
3. התוצאות ממוינות לפי זמן שינוי (modification time) — הכי חדש ראשון
4. Claude מקבל רשימת נתיבים ומציג לכם

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

לא חייבים לזכור דפוסים — אפשר לתאר

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

• "מצא את קובץ ההגדרות של בסיס הנתונים" → Claude ישתמש ב-Glob עם דפוסים כמו **/*db*config* או **/*database*
• "הראה לי את כל קבצי ה-React" → **/*.{tsx,jsx}
• "איפה ה-README?" → **/README*

Grep — חיפוש תוכן בתוך קבצים

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

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

שלושת מצבי התצוגה

מצב (Output Mode)	מה מציג	מתי משתמשים
content	השורות המתאימות + מספרי שורות	כשצריכים לראות את הקוד/הטקסט עצמו
files_with_matches	רק נתיבי הקבצים (ברירת מחדל)	כשצריכים רק לדעת איפה
count	מספר ההתאמות בכל קובץ	כשצריכים לדעת כמה

סינון תוצאות — לחפש רק במה שרלוונטי

אחד הכוחות הגדולים של Grep הוא היכולת לצמצם את החיפוש:

• לפי סוג קובץ — type: "py" מחפש רק בקבצי Python; type: "js" רק ב-JavaScript; type: "md" רק ב-Markdown
• לפי דפוס שם — glob: "*.csv" מחפש רק בקבצי CSV; glob: "src/**" רק בתיקיית src
• שורות הקשר — -C 3 מציג 3 שורות לפני ואחרי כל התאמה. קריטי להבנת ההקשר

טבלת Grep Cheat Sheet — שמרו בצד

זו הטבלה הכי שימושית בפרק. העתיקו אותה, הדביקו ב-CLAUDE.md שלכם, והשתמשו בה כל יום:

מה רוצים למצוא	דפוס Grep	הסבר
מילה ספציפית	"password"	חיפוש פשוט — מוצא כל מופע
הגדרות פונקציות (JS/TS)	"function\s+\w+"	המילה function ואחריה שם
הגדרות פונקציות (Python)	"def \w+"	המילה def ואחריה שם
משפטי import	"import.*from"	כל import שמכיל from
כתובות אימייל	"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+"	דפוס אימייל סטנדרטי
כתובות URL	"https?://[^\s]+"	http או https ואחריהם תווים
הערות TODO/FIXME	"TODO|FIXME|HACK"	שלושה סוגי הערות נפוצות
טקסט בעברית	"[\u0590-\u05FF]+"	תווים בטווח ה-Unicode העברי
מספרי טלפון ישראליים	"0[2-9]\d{7,8}"	מתחיל ב-0, ספרה 2-9, 7-8 ספרות
משתני סביבה	"[A-Z_]+=(.*)"	VARIABLE=value

חיפוש רב-שורתי (Multiline)

כברירת מחדל, Grep מחפש בתוך שורה אחת בלבד. אבל לפעמים מה שמחפשים משתרע על כמה שורות — למשל בלוק של struct ב-Go, או הגדרת class עם ירושה ב-Python. במקרים כאלה, Grep תומך במצב multiline שמאפשר לדפוס לחצות שורות.

מתי זה שימושי?

• חיפוש הגדרת class עם הדקורטורים שלה
• חיפוש בלוקים של HTML עם מבנה ספציפי
• זיהוי דפוסי קוד שמשתרעים על 3-4 שורות

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

Grep בעברית — זה עובד

נקודה חשובה למפתחים ישראלים: Grep עובד מצוין עם תוכן בעברית. Ripgrep תומך ב-UTF-8 באופן מלא, אז אפשר לחפש מחרוזות בעברית, הערות בעברית בקוד, ואפילו שמות משתנים בעברית (אם יש כאלה). הדפוס [\u0590-\u05FF]+ מטבלת ה-Cheat Sheet מוצא כל טקסט עברי, אבל אפשר גם פשוט לחפש מילים בעברית כמו שמחפשים באנגלית — "שגיאה" ימצא את כל המופעים של המילה "שגיאה" בכל הקבצים.

מתי Grep ומתי Glob?

הכלל פשוט:

• יודעים את שם הקובץ (או חלק ממנו)? → Glob. "מצא את כל קבצי ה-config" = Glob
• יודעים מה כתוב בתוך הקובץ (אבל לא את שמו)? → Grep. "מצא את הקובץ שמכיל את פונקציית login" = Grep
• לא יודעים כלום? → תארו מה אתם מחפשים בשפה טבעית ותנו ל-Claude לבחור

Read — גישה ממוקדת לקבצים

Read הוא הכלי הכי ישיר: נותנים לו נתיב לקובץ, מקבלים את התוכן עם מספרי שורות. זה הכלי שמשתמשים בו כשכבר יודעים בדיוק איזה קובץ צריך לקרוא. בעוד Glob מוצא קבצים ו-Grep מוצא תוכן — Read פשוט קורא.

קריאה חלקית — חובה בקבצים גדולים

לא כל קובץ צריך לקרוא במלואו. ל-Read יש שני פרמטרים קריטיים:

• offset — מאיזו שורה להתחיל. "קרא את הקובץ מתחילת שורה 100"
• limit — כמה שורות לקרוא. "קרא 50 שורות בלבד"

למה זה חשוב? כי כל שורה שנקראת צורכת מקום בחלון ההקשר (Context Window). קובץ של 2,000 שורות שנקרא במלואו "אוכל" נתח משמעותי מהזיכרון של הסשן. אם צריכים רק את הפונקציה בשורות 150-200, אין סיבה לקרוא את כל שאר 1,950 השורות.

Read קורא הרבה יותר מטקסט

הפתעה נעימה: Read לא מוגבל לקבצי טקסט. הוא יכול לקרוא:

סוג קובץ	מה קורה	מגבלות
תמונות (PNG, JPG, GIF)	Claude "רואה" את התמונה ויכול לתאר אותה	אין — עובד על כל פורמט תמונה נפוץ
PDF	Claude קורא את הטקסט מתוך ה-PDF	PDFs גדולים (10+ עמודים): חובה לציין טווח עמודים. מקסימום 20 עמודים בקריאה אחת
Jupyter Notebooks (.ipynb)	מחזיר את כל התאים עם הפלטים שלהם	אין
קבצי טקסט בעברית	עובד ללא בעיה — UTF-8 מלא	אין — קבצי טקסט, CSV, JSON בעברית עובדים מצוין

Read וניהול Context — הקשר ישיר

הנקודה הכי חשובה להבנה לגבי Read: כל שורה שנקראת נכנסת לחלון ההקשר (Context Window). עם חלון של 200K טוקנים (ברירת מחדל), או 1M טוקנים (ב-Max/Team/Enterprise עם Opus 4.6) — זה נשמע הרבה. אבל בפרויקט אמיתי, קריאה של 10 קבצים גדולים יכולה למלא את החלון מהר.

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

Read מול Grep — מתי מה?

הבחירה פשוטה:

• יודעים את שם הקובץ ורוצים לראות אותו → Read. "הראה לי את app.py"
• מחפשים טקסט כלשהו ולא יודעים באיזה קובץ → Grep. "מצא איפה מוגדרת הפונקציה calculate_total"

בפועל, הם משלימים זה את זה: Grep מוצא את הקובץ, Read קורא אותו. Claude Code עושה את השילוב הזה אוטומטית — כשמבקשים "הסבר מה עושה הפונקציה login", Claude קודם מחפש עם Grep, ואז קורא עם Read.

Agent Tool — חקירה עמוקה

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

חשבו על זה ככה: אם Read, Grep ו-Glob הם חיפוש בגוגל — אז Agent הוא לשלוח עוזר מחקר שיושב בספרייה, קורא 20 ספרים, ומגיש לכם דוח מסודר.

מתי להשתמש ב-Agent

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

מתי לא להשתמש ב-Agent

• חיפוש פשוט — "מצא את הקובץ config.yaml" → השתמשו ב-Glob. Agent הוא overkill
• קריאת קובץ בודד — "הראה לי את app.py" → Read. הרבה יותר מהיר וזול
• חיפוש טקסט — "מצא את כל ה-TODOs" → Grep. תוצאה מיידית
• משימה של שלב אחד — אם התשובה דורשת קריאה של קובץ אחד, Agent מיותר

Agent — לפני ואחרי

כדי להבין את הערך של Agent, הנה השוואה בין שתי גישות לאותה משימה — "הבן את מערכת ההזדהות בפרויקט":

בלי Agent (ידני)	עם Agent
1. Grep "login" — 15 תוצאות	1. "Use Agent to investigate the auth system"
2. Read כל קובץ — 8 קבצים	2. Agent קורא 8 קבצים בעצמו
3. ניסיון לעקוב אחרי הזרימה ידנית	3. Agent מזהה את הזרימה ומסכם
4. לשאול שאלות המשך — עוד קריאות	4. מקבלים סיכום מסודר
~15 דקות, ~8 בקשות	~2 דקות, בקשה אחת

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

עץ ההחלטות — תמיד לבחור את הכלי הנכון

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

שילוב כלים — הרמה הבאה

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

תרחיש	זרימת כלים
"הסבר לי מה עושה הפונקציה calculate_tax"	Grep (למצוא את הקובץ) → Read (לקרוא אותו)
"מצא את כל קבצי הבדיקות ותספר כמה יש"	Glob (עם דפוס *test*) → ספירה
"מצא את כל הקבצים שמשתמשים ב-API הזה ותסביר מה הם עושים"	Grep (למצוא שימושים) → Read (לקרוא כל קובץ) → סיכום
"הבן את ארכיטקטורת הפרויקט ותן דוח"	Agent (חקירה מקיפה)
"מה אומר התיעוד הרשמי של React 19 על Suspense?"	WebSearch (חיפוש) → WebFetch (קריאת דף ספציפי)

סיור בפרויקט חדש — The Codebase Tour

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

שלב 1: מבנה — "מה יש כאן?"

הפקודה הראשונה תמיד: "Show me the project structure — directories and key files". Claude ישתמש ב-Glob כדי להציג את מבנה התיקיות. עדיף לא לבקש רשימה שטוחה של כל הקבצים (עלול להיות מאות) — אלא מבנה של רמה או שתיים עם הקבצים החשובים.

שלב 2: נקודת כניסה — "מאיפה הכל מתחיל?"

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

• Node.js: package.json → שדה main או scripts.start
• Python: main.py, app.py, או __main__.py
• אתר סטטי: index.html
• Docker: Dockerfile → שורת CMD או ENTRYPOINT

שלב 3: הגדרות — "מה הכלים והתלויות?"

קראו את קובצי ההגדרות: package.json (Node), requirements.txt / pyproject.toml (Python), docker-compose.yml, .env.example. מכאן תבינו את ה-Tech Stack — אילו ספריות, frameworks, ושירותים הפרויקט משתמש בהם.

שלב 4: תיעוד — "מה הפרויקט אומר על עצמו?"

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

שלב 5: סיכום

בקשו מ-Claude: "Summarize what this project does, its tech stack, and how it's organized." התוצאה תהיה פסקה-שתיים שמסכמות הכל. והנה הצעד הקריטי שרוב האנשים מפספסים:

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

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

עבודה עם פרויקטים גדולים — אסטרטגיות לסקייל

הבעיה: לחלון ההקשר (Context Window) יש גבול. גם עם 200K טוקנים (ברירת מחדל), או אפילו 1M טוקנים (ב-Max/Team/Enterprise עם Opus 4.6) — פרויקט גדול של מאות אלפי שורות קוד לא ייכנס בשלמותו. צריך אסטרטגיה.

אסטרטגיה 1: אזורי מיקוד (Focus Areas)

במקום לנסות להבין הכל בבת אחת, עבדו על מודול אחד בכל פעם: "Let's focus only on the authentication module" או "Let's look at the payment processing code". סיימתם? עברו למודול הבא.

אסטרטגיה 2: הקשר ב-CLAUDE.md

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

אסטרטגיה 3: קריאה סלקטיבית

קראו טווחי שורות במקום קבצים שלמים. בקשו סיכומים במקום תוכן גולמי. "Summarize what auth.py does" שורף הרבה פחות context מ-"Read auth.py" (שזה 800 שורות).

אסטרטגיה 4: דחיסה תכופה (Frequent Compaction)

הריצו /compact באופן קבוע כדי לפנות מקום לחקירה חדשה. אתם יכולים אפילו לכוון את הדחיסה: /compact keep only the authentication analysis — ו-Claude ישמור רק את מה שביקשתם.

אסטרטגיה 5: טכניקת פירורי הלחם (Breadcrumb Technique)

שיטה מתקדמת שעובדת מצוין:

1. קראו קבצים מרכזיים → בקשו סיכום
2. שמרו את הסיכום (ב-CLAUDE.md או בהודעה)
3. השתמשו בסיכום כהקשר לחקירה עמוקה יותר
4. חזרו על התהליך — כל סבב מעמיק את ההבנה בלי לבזבז context על טקסט גולמי

אסטרטגיה 6: כללים מותנים (.claude/rules/)

לפרויקטים ענקיים באמת (1M+ שורות קוד): השתמשו בתיקיית .claude/rules/ עם הפעלה מותנית. כל קובץ rules יכול לכלול frontmatter ב-YAML שמגדיר מתי הוא נטען — למשל, רק כשעובדים על קבצי Python, או רק בתיקיית src/api/. כך Claude מקבל הקשר ממוקד לאזור שבו עובדים, בלי לטעון מידע לא רלוונטי.

דוגמה: בפרויקט עם frontend ב-React ו-backend ב-Python, אפשר ליצור .claude/rules/frontend.md (נטען רק בעבודה על קבצי TSX) ו-.claude/rules/backend.md (נטען רק בעבודה על קבצי Python). ככה ה-context Window מנוצל בצורה מיטבית.

אינטגרציית Git — היסטוריה ומעקב שינויים

Claude Code משולב עמוק ב-Git. הוא יכול להריץ כל פקודת Git דרך כלי ה-Bash, ומבין את הפקודות ואת התוצאות שלהן. בפועל, זה אומר שאתם יכולים לנהל את ה-version control שלכם בשפה טבעית — בלי לזכור את כל הפקודות.

פקודות Git המרכזיות ש-Claude משתמש בהן

פקודה	מה מציגה	מתי שימושי
git status	שינויים נוכחיים (staged ו-unstaged)	לפני כל שינוי — להבין את המצב הנוכחי
git diff	שינויים בפירוט — שורה אחרי שורה	לראות מה בדיוק השתנה
git log --oneline -10	10 ה-commits האחרונים (היסטוריה מהירה)	להבין מה קרה לאחרונה
git blame file.py	מי שינה כל שורה ומתי	לגלות מי כתב קוד בעייתי ומתי
git log -p --follow file.py	היסטוריה מלאה של קובץ ספציפי	להבין את ההתפתחות של קובץ לאורך זמן

מה Claude יכול לעשות עם Git

הרבה מעבר לקריאת היסטוריה:

• יצירת commits: "Commit these changes with an appropriate message" — Claude בוחר הודעת commit מתאימה
• ניהול branches: "Create a new branch called feature/login" — ויותר מזה, גם checkout, merge, ו-rebase
• פתרון קונפליקטים: "Resolve the merge conflicts in this file" — Claude מבין את שני הצדדים ומציע פתרון
• יצירת changelogs: "Generate a changelog from the last 20 commits" — סיכום אוטומטי של שינויים
• סקירת שינויים: "What changed in the last 3 commits? Summarize the changes" — דוח מהיר

Git + חיפוש — שילוב חזק

אחד השילובים החזקים ביותר הוא Git + כלי חיפוש. הנה תרחישים שכיחים:

• "מי הכניס את הבאג?" — Claude משתמש ב-git log -p וב-git blame כדי למצוא את ה-commit שהכניס את השינוי הבעייתי, ואז קורא את הקבצים הרלוונטיים עם Read כדי להבין מה קרה
• "מה השתנה מאז הגרסה האחרונה?" — Claude משתמש ב-git diff v2.0..HEAD ומסכם את כל השינויים
• "הראה לי את כל השינויים בקבצי ה-CSS בשבוע האחרון" — git log --since="1 week ago" -- "*.css"

WebSearch ו-WebFetch — מידע מהאינטרנט

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

WebSearch — חיפוש ברשת

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

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

• "Search the web for the latest React 19 features" — מידע שלא היה בנתוני האימון
• "What's the current pricing for Vercel Pro?" — מחירים משתנים, צריך מידע עדכני
• "Search for best practices for Next.js API routes in 2026" — דפוסים חדשים
• "Is there a library for Hebrew date formatting in JavaScript?" — גילוי כלים חדשים

WebFetch — קריאת דף ספציפי

WebFetch שולף תוכן מ-URL ספציפי ועונה על שאלה. הוא לא מחזיר HTML גולמי — הוא מנתח את התוכן ונותן תשובה ממוקדת.

דוגמאות:

• "Fetch this URL and tell me what it says about pricing: https://example.com/pricing"
• "Read this documentation page and summarize the main API endpoints: [URL]"
• "What does this GitHub issue say? [URL to issue]"

WebSearch + WebFetch — הזרימה הנפוצה

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

1. "Search the web for how to implement rate limiting in Express.js" — WebSearch מוצא כמה מאמרים ותיעוד
2. "Fetch this URL and show me the code example: [URL מתוצאות החיפוש]" — WebFetch שולף את הקוד
3. Claude מיישם את הפתרון בפרויקט שלכם — שילוב מידע מהרשת עם קוד מקומי

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

מגבלות חשובות

מגבלה	פירוט
זמינות	רק ב-API של Anthropic (לא Bedrock/Vertex). אם אתם ב-Max plan — זמין
אבטחה	Claude לא יכול לבנות URLs באופן דינמי — הוא רק פותח URLs שאתם נתתם או שעלו בתוצאות חיפוש. הגנה מפני SSRF
תוכן	WebFetch לעולם לא מחזיר HTML גולמי — רק ניתוח ותשובה. לא מתאים ל-scraping

חמש טעויות נפוצות בניווט — ואיך להימנע מהן

אחרי שהכרנו את כל הכלים, הנה הטעויות שמתחילים עושים הכי הרבה — וההמלצה לכל אחת:

#	הטעות	למה זה בעייתי	מה לעשות במקום
1	קריאת קבצים שלמים תמיד	ממלא את חלון ההקשר מהר. קובץ של 1,000 שורות = ~5,000 טוקנים	Read עם offset ו-limit. "Read lines 50-100 of app.py"
2	שימוש ב-Agent למשימות פשוטות	Agent יקר (טוקנים נוספים) ואיטי לעומת Read/Grep	Read/Grep לחיפוש בודד. Agent רק כש-5+ קבצים נדרשים
3	חיפוש כללי מדי	"Find everything about auth" מחזיר מאות תוצאות	היו ספציפיים: "Find the login function definition in Python files"
4	לא לשמור סיכומים ב-CLAUDE.md	כל סשן חדש מתחיל מאפס — בזבוז	אחרי Codebase Tour: "Save summary to CLAUDE.md"
5	לחפש באינטרנט בלי לציין	"What's new in React" — Claude עונה מהזיכרון (לא עדכני)	תמיד: "Search the web for..." כשצריכים מידע עדכני

תרגילים מעשיים

שגרת עבודה — ניווט יומי

בנוסף לשגרה שלמדנו בפרק 4 (בניית פרומפטים), הנה משימות הניווט שכדאי לשלב בעבודה:

בדוק את עצמך

צ'קליסט סיום פרק

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

• מבין/ה את Glob ויודע/ת לחפש קבצים עם דפוסים כמו **/*.tsx ו-**/*.{json,yaml}
• מבין/ה את Grep ויודע/ת לחפש תוכן בתוך קבצים — כולל Regex, סינון סוג, ושורות הקשר
• יודע/ת להשתמש ב-Read עם offset ו-limit לקריאה חלקית של קבצים גדולים
• מבין/ה מתי Agent הוא הבחירה הנכונה (5+ קבצים, קשרים בין מודולים) ומתי הוא overkill
• יודע/ת את עץ ההחלטות בעל פה: Read → Glob → Grep → Agent → WebSearch → WebFetch
• ביצעתי Codebase Tour מלא ושמרתי סיכום ב-CLAUDE.md
• מכיר/ה לפחות 5 דפוסי Grep מטבלת ה-Cheat Sheet
• יודע/ת להשתמש באינטגרציית Git: status, diff, log, blame, commit
• ניסיתי WebSearch ו-WebFetch לפחות פעם אחת
• מבין/ה את אסטרטגיות העבודה עם פרויקטים גדולים: Focus Areas, Breadcrumb, CLAUDE.md
• יודע/ת שתוצאות Glob ממוינות לפי זמן שינוי (חדש → ישן)
• מבין/ה ש-Read קורא גם תמונות, PDFs, ו-Jupyter Notebooks
• מכיר/ה את 5 הטעויות הנפוצות בניווט ויודע/ת איך להימנע מהן
• ביצעתי לפחות שני תרגילים מתוך הארבעה
• מבין/ה שהוספת WebSearch ו-WebFetch ל-Claude Code בוצעה באוקטובר 2025