לדלג לתוכן

5.1 Cursor הרצאה

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

מה זה Cursor - the agentic IDE

Cursor הוא עורך קוד עצמאי, בנוי כ-fork של VS Code. המשמעות: זה לא תוסף שמתקינים על VS Code קיים, אלא אפליקציה נפרדת שיורשת את כל מה שמוכר מ-VS Code - ערכות נושא, תוספים, קיצורי מקלדת, טרמינל מובנה - ומוסיפה עליו שכבת AI שנארגת עמוק בתוך העורך עצמו, ולא רק בפאנל צד.

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

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

שכבות העבודה בתוך Cursor - the interaction layers

ב-Cursor יש כמה דרכים לעבוד מול ה-AI, כל אחת מתאימה לגודל משימה אחר.

הcompletion חכמה - Cursor Tab

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

עריכה ממוקדת - inline edit

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

צ'אט בתוך העורך - chat panel

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

מצב agent - agent / composer mode

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

Tab           -> completion while typing, local, fast
inline edit   -> targeted edit on a selected block
chat          -> conversation, questions, planning
agent/composer -> autonomous multi-file task, with command execution

אינדוקס הפרויקט וכללי context - codebase indexing and rules files

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

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

בדיוק כמו שקובץ CLAUDE.md נותן ל-Claude Code context קבוע על הפרויקט (פרק 2.5), גם ב-Cursor אפשר להגדיר קובצי כללים - Rules - שמכילים הנחיות קבועות: מוסכמות קוד, שפות שאסור/מותר להשתמש בהן, איך לבנות טסטים, אילו ספריות מועדפות. הכללים האלה נשמרים כטקסט בתוך הפרויקט, נכנסים ל-git כמו כל קובץ אחר, וכל בקשה לagent מתחשבת בהם אוטומטית. מבחינה מושגית זה אותו רעיון בדיוק כמו CLAUDE.md - "context קבוע שלא צריך לחזור ולהקליד בכל פעם" - רק בפורמט ובמיקום ספציפיים ל-Cursor.

CLAUDE.md in Claude Code   <-->   Rules files in Cursor
Both: fixed project context, in text, versioned in git, loaded automatically for every request

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

מתי Cursor עדיף על agent טרמינל - when the IDE wins

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

יתרונות אמיתיים של Cursor:

  • משוב ויזואלי מיידי - רואים diff מודגש בצבעים בתוך הקובץ עצמו, עם היסטוריית גרסאות, ואפשר לאשר או לדחות כל שינוי בנפרד בלחיצה. בטרמינל רואים diff טקסטואלי, שגם הוא ברור אבל פחות מוחשי לעריכה נקודתית.
  • הcompletion תוך כדי כתיבה - Cursor Tab מצוין למקצבי עבודה שבהם רוב הזמן עדיין נכתב קוד ידנית, ורק חלק ממנו מבוקש מה-AI. זו חוויה שאין לה מקבילה טבעית בטרמינל.
  • ניווט מהיר בין קבצים רבים - עורך גרפי מלא, עם עץ קבצים, חיפוש גלובלי, קפיצה להגדרה - כל הtools הרגילים של IDE זמינים בלי לצאת מהחוויה.
  • נוח למי שחי בתוך עורך - מפתחים שהרגל העבודה שלהם בנוי סביב IDE (ולא סביב טרמינל) ירגישו בבית מהר יותר.

יתרונות אמיתיים של agent טרמינל כמו Claude Code:

  • עבודה headless ומרוחקת - שרת SSH בלי interface גרפי, סביבת CI/CD, קונטיינר - בכל אלה עורך גרפי פשוט לא זמין, וagent טרמינל עובד בול אותו דבר.
  • הרצה אוטונומית ארוכה - משימות רב-שלביות שרצות ברקע דקות ארוכות, כולל הרצת בדיקות וסבבי תיקון עצמי, בלי שצריך לחכות ליד המסך. אפשר גם להריץ כמה מופעים במקביל מתוך כמה חלונות טרמינל.
  • שקיפות ושליטה מפורטת - קובץ CLAUDE.md, skills, הוקים, sub-agents - כל מנגנוני השליטה שלמדנו בפרקים 4 ו-6 מוגדרים כטקסט וגרסתיים ב-git, ולא תלויים בהגדרות של אפליקציה גרפית ספציפית.
  • סקריפטביליות - קל לשלב agent טרמינל בתוך pipeline אוטומטי, סקריפט, או tool אחר, כי הוא פשוט תהליך שמריצים משורת פקודה.

טבלת סיכום קצרה:

היבט Cursor Claude Code
סביבה עורך גרפי (fork של VS Code) טרמינל
הcompletion תוך כדי הקלדה כן, חזקה (Tab) לא רלוונטי
עבודה headless / מרוחקת מוגבל טבעי
הרצה אוטונומית ארוכה ברקע אפשרי, פחות טבעי טבעי, כולל כמה מופעים במקביל
שליטה בcontext דרך קבצים גרסאתיים חלקי מלא (CLAUDE.md, skills, hooks)
נוחות ויזואלית לעריכות קטנות גבוהה בינונית

זרימת עבודה טיפוסית ב-Cursor - a typical workflow

זרימה נפוצה נראית כך:

  1. פותחים את הפרויקט ב-Cursor, כמו שהייתם פותחים אותו ב-VS Code רגיל.
  2. במהלך כתיבת קוד "רגילה", משתמשים ב-Tab כדי לחסוך הקלדה - completion בלוקים שלמים, לא רק מילה בודדת.
  3. לשינוי ממוקד בקובץ אחד - למשל לשכתב פונקציה או להוסיף type - משתמשים בעריכה ממוקדת על הקטע הנבחר, בודקים את ה-diff, ומאשרים.
  4. למשימה שדורשת שינוי בכמה קבצים בבת אחת - הוספת שדה חדש שצריך לזרום דרך מודל, API ו-UI - עוברים למצב agent, נותנים תיאור ברור של המשימה (בדיוק כמו פרומפט טוב ל-Claude Code שלמדנו בפרק 2), ונותנים לו לרוץ.
  5. עוברים על כל שינוי בנפרד, קוראים את ה-diff, מאשרים מה שנכון ומתקנים או דוחים מה שלא.
  6. מריצים בדיקות מתוך הטרמינל המובנה של Cursor, בדיוק כמו שהייתם עושים בטרמינל רגיל.

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

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

Add a "phone" field to the user model. Update:
1. The database schema (new migration)
2. The API - input and output of /users
3. The edit form in the frontend, including basic validation
4. The existing tests that check the user model
Run the test suite at the end and show me the result.

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

מגבלות ונקודות זהירות - fair limitations

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

  • עלות - Cursor פועל במודל מנוי, בדרך כלל עם מכסת שימוש חודשית במודלים המתקדמים ביותר; שימוש כבד יכול להגיע למגבלות או לעלות נוספת, בדומה לכל tool מבוסס מודל שפה.
  • שקיפות context - כשה-IDE "מבין" את הפרויקט אוטומטית, לפעמים קשה לדעת בדיוק אילו קבצים נכנסו לcontext של הבקשה, בהשוואה לניהול context המפורש שיש בטרמינל (קבצים שמזכירים בפירוש, CLAUDE.md, פקודות סלאש).
  • נעילה לעורך אחד - עבודה יומיומית ב-Cursor מרגילה אתכם לחוויה ולקיצורים של עורך ספציפי. זה לא רע, אבל חשוב לזכור שהכישורים המרכזיים - כתיבת פרומפט טוב, אימות תוצאה, פירוק משימה - הם כישורים כלליים שעובדים בכל tool, לא ידע ספציפי ל-Cursor.
  • התנהגות "קופסה שחורה" יחסית - אין באותה מידה מנגנוני הרחבה גלויים כמו הוקים וskills מבוססות טקסט; ההתאמה האישית מוגבלת יותר להגדרות שהעורך חושף.

המסקנה המעשית: Cursor הוא tool מצוין להוסיף לארגז הtools, במיוחד לעבודה יומיומית שכוללת הרבה עריכות קטנות-בינוניות בתוך עורך. הוא לא מחליף agent טרמינל למשימות אוטונומיות ארוכות, headless, או כאלה שדורשות שליטה מדויקת בcontext. בפרק 5.6 נראה טבלת החלטה מסודרת שמכסה את כל הtools שנלמד בפרק הזה, ונבין איך לשלב ביניהם בפועל.

כדאי גם לזכור שהתחום הזה משתנה מהר. הגבול בין "עורך עם AI" ל"agent טרמינל" כבר לא חד כמו שהיה - יש תוספים שמביאים agents טרמינל אל תוך עורכים גרפיים (כולל Claude Code עצמו, שיש לו אינטגרציות עם IDE-ים שונים), ויש tools כמו Cursor שמוסיפים יכולות אוטונומיה שדומות יותר ויותר לagent עצמאי. המסקנה המעשית לא משתנה: ללמוד לחשוב במונחים של "מה צורת המשימה" ו"כמה שליטה אני צריך", ולא להתחתן עם interface ספציפי, כי הinterfaces ימשיכו להתפתח והכישורים הבסיסיים - ניסוח בקשה ברורה, אימות תוצאה, פירוק משימה לצעדים - יישארו רלוונטיים בכל tool.

סיכום

  • Cursor הוא עורך קוד עצמאי (fork של VS Code) עם AI משולב עמוק בתוך חוויית העריכה, לא תוסף חיצוני.
  • ארבע שכבות עבודה עיקריות: Tab (completion תוך כדי הקלדה), עריכה ממוקדת (שינוי בקטע נבחר), צ'אט (שאלות ותכנון), ומצב agent/Composer (משימה אוטונומית רב-קבצית עם הרצת פקודות).
  • Cursor עוטף מודלים קיימים (כולל מודלים של Claude) - הוא לא מאמן מודל משלו, בדיוק כמו ש-Claude Code הוא עטיפה סביב מודל.
  • Cursor מצטיין במשוב ויזואלי, בcompletion תוך כדי הקלדה, ובעבודה נוחה בתוך עורך גרפי מלא.
  • הagent טרמינל כמו Claude Code מצטיין בעבודה headless/מרוחקת, בהרצה אוטונומית ארוכה, ובשליטה מפורשת בcontext דרך קבצים גרסאתיים (CLAUDE.md, skills, הוקים).
  • גם ב-Cursor חלה אותה חובת אימות שלמדנו לגבי Claude Code - diff יפה לא הופך קוד שגוי לנכון.
  • המגבלות ההוגנות: עלות מבוססת מנוי, שקיפות חלקית של מה נכנס לcontext, נעילה יחסית לעורך אחד.
  • הבחירה בין הtools היא לפי צורת המשימה, לא נאמנות לtool אחד - ונרחיב על כך בהרצאה 5.6.