ToCode

לא עומד בקצב בפעם הראשונה שהלכתי לאימון כושר חשבתי שאני מחוסל, שפספסתי את הרכבת. כולם ידעו בדיוק מה הם עושים בזמן שאני מתנשף ומנסה להבין את ההוראות באותו זמן. כמובן ששנתיים מאוחר יותר אותם אימונים נראים אחרת לגמרי. זה בדיוק האופן שאני רוצה שנחשוב על סדרת הוובינרים מדברים AI שהתחלתי כאן. נכון, כל מפגש הוא בנושא קצת אחר אבל הדברים החשובים בעבודה עם AI באים לידי ביטוי בכל וובינר: 1. איך לבנות פרומפט. 2. איך לחלק את העבודה עם ה AI. 3. איזה דברים AI יודע לעשות טוב, ומה עדיף לעשות לבד. 4. איך לשים לב שה AI מפשל ולעצור אותו לפני שיעשה נזק. 5. למה חשוב לשים לב בקוד ש AI מייצר. אלה מיומנויות חדשות לגמרי. לא עשינו אף אחד מהדברים האלה לפני שנתיים. בטח שאנחנו מרגישים מוצפים. יש אנשים שכשמרגישים מוצפים בוחרים להסתגר, להתעלם מהפוטנציאל. אחרים מזגזגים, עוברים כל יום לכלי החדש שיצא כמו מחפשים את הקופה עם הכי פחות תור בסופר. שתי הדרכים לא עובדות. אין כלי אחד שפותר את כל הבעיות ואין טריק אחד שמסביר הכל. במקרה של עבודה עם AI הדרך קדימה היא תרגול, יישום של אותם רעיונות חדשים שוב ושוב עד שנתחיל להרגיש איתם יותר בנוח. גם (ובמיוחד) כשקשה לעמוד בקצב.

היום למדתי: פרוטוטייפ ופונקציות חץ עזרתי לחבר עם איזה באג שהביא אותי לקוד הבא מתוך ספריית JavaScript ישנה:

/**
 * Used to determine we'll call be calling React.createElement on the component of if this is a
 * generator function used return a function that takes props to return a React element
 * @param component
 * @returns {boolean}
 */
function generatorFunction(component) {
  if (!component.prototype) {
    return false;
  }

  // es5 or es6 React Component
  return !component.prototype.isReactComponent;
}

מישהו כתיב פונקציה כדי להבחין בין שני מקרים מאוד דומים: 1. העברת React Component ל API. 2. העברת פונקציה שמחזירה React Component ל API. האנטי תבנית כאן היא ברורה - שפת JavaScript לא עושה חיים קלים למי שרוצה להבדיל בין טיפוסים בזמן ריצה. כן יש את typeof אבל גם את Array.isArray וגם את Number.isNaN ויש הרבה כללים לזכור. ועכשיו נסו להבדיל בין "פונקציה שהיא React Component" ל"פונקציה שמחזירה React Component". לא ככה מתכננים API. עכשיו מה היה הבאג? שימו לב:

> generatorFunction(function() { 10 })
true
> generatorFunction(() => 10)
false

פונקציה שמוגדרת עם המילה function מכילה prototype ריק, ולכן ה isReactComponent שלו הוא שקר ואנחנו מקבלים חזרה ערך "אמת". פונקציית חץ מגיעה בלי prototype ולכן נופלת בתנאי הראשון ומחזירה false. זו כמובן לא היתה כוונת המשורר, אבל לזכותם נגיד שעברו 8 שנים והיום הם בטוח מתכננים ממשקים ברורים יותר.

טיפ רובי: דיג במקום סוגריים מרובעים הקוד הזה היה נראה כמו רעיון טוב בזמנו:

x[:foo].presence || 9

הוא אומר שאם המפתח :foo קיים באוביקט x אז יש להשתמש בערך שלו (אפילו אם הוא 0, כי אנחנו ברובי ולא ב JavaScript), ואם הוא לא קיים ניקח את ערך ברירת המחדל 9. אני מודה שהייתי צריך את ההתרסקות כדי לראות את הבעיה. זה עובד:

3.3.5 :003 > x = {foo: 0, bar: 20}
 => {:foo=>0, :bar=>20}
3.3.5 :004 > x[:foo].presence || 9
 => 0

וגם זה עובד:

3.3.5 :006 > x = {bar: 20}
 => {:bar=>20}
3.3.5 :007 > x[:foo].presence || 9
 => 9

אבל זה כבר לא:

3.3.5 :008 > x = nil
 => nil
3.3.5 :009 > x[:foo].presence || 9
(langlets):9:in \<main>': undefined method \[]' for nil (NoMethodError)

x[:foo].presence || 9

כלומר בדיקת ה presence נכשלת כשהאוביקט עצמו לא קיים. עד לפה זה ברור אבל החלק הבא הצליח להפתיע אפילו את ChatGPT, כי ברובי יש אופרטור &. שמפעיל פונקציה רק אם האוביקט קיים, כלומר:

3.3.5 :011 > x = 10
 => 10
3.3.5 :012 > x&.abs
 => 10
3.3.5 :013 > x = nil
 => nil
3.3.5 :014 > x&.abs
 => nil

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

> x&.[:foo]

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

3.3.5 :017 > x = {foo: 10, bar: 20}
 => {:foo=>10, :bar=>20}
3.3.5 :018 > x&.dig(:foo)
 => 10
3.3.5 :019 > x = {foo: {foo: {foo: 10}}, bar: 20}
 => {:foo=>{:foo=>{:foo=>10}}, :bar=>20}
3.3.5 :020 > x&.dig(:foo, :bar, :foo)
 => nil
3.3.5 :021 > x&.dig(:foo, :foo, :foo)
 => 10
3.3.5 :023 > x = nil
 => nil
3.3.5 :024 > x&.dig(:foo, :bar)
 => nil

עבודת יד המהפכה התעשייתית שינתה את איך שאנחנו בונים דברים. במקום שכל דבר יהיה עשוי ביד היום יש לנו מפעל ושם מייצרים שטויות בכמויות. היום יש הרבה יותר מוצרים ממה שאנשים מסוגלים לצרוך. תפיסת העולם של המפעל המשיכה גם לתעשיות הידע ויש היום הרבה יותר ספרים ממה שאפשר לקרוא, יותר מוזיקה ממה שאפשר להקשיב, יותר אתרים ממה שאפשר לבקר. ועכשיו היא הגיעה לקוד. להגיד שאתר אינטרנט או מערכת אינטרנטית שנבנית על ידי AI זה לא אותו מוצר כמו מערכת שכתבו מפתחים שאכפת להם מפספס את הנקודה. ברור שזה לא אותו מוצר. כמו שתיק עבודת יד הוא לא אותו מוצר כמו תיק שיוצר במפעל - גם אם לי קשה להבדיל בין שניהם. כמה תובנות להשאיר בראש: 1. הרבה אנשים לא צריכים תיק שנתפר ביד ושמחים לקבל תיק מהמפעל בעלות נמוכה. 2. הערך של מערכת תוכנה שנכתבת על ידי מפתחים הוא היכולת להכיל מורכבות ולהשתנות כשהצרכים משתנים. גוגל יכולים לשנות את אלגוריתם החיפוש בלי לשבור אינסוף דברים אחרים במערכת העצומה שלהם כי מישהו חשב איך לארגן את הקוד בצורה שתאפשר את זה. 3. מוצר שמגיע ממפעל הוא באמת יותר אמין ממוצר עבודת יד. זאת הסיבה שמפתח בודד או "מפתח AI" מצליח היום בעזרת AI לבנות מערכת תוכנה אמינה שבעבר היה צריך בית תוכנה שלם כדי לפתח. זה הכח של המפעל. 4. הרבה אנשים בלינקדאין ובפייסבוק שלי כותבים על הפוטנציאל של "הקמת סוכנות AI" ו"פיתוח מערכות AI ללקוחות". הבעיה שזה מרגיש כמו מירוץ לתחתית (מה שקרה למפעלים). אם לקחת מלקוח 40 אלף ש"ח בשביל מערכת שבנית בשעתיים ב lovable אז מחר יגיע המתחרה שלך ויקח 20 אלף ש"ח על אותו פרויקט, ובעוד שנה יבואו מאות. ובכל זאת בואו נשים לב לשתי הזדמנויות מעניינות למפתחים שרוצים להצליח: 1. מישהו צריך לבנות את המפעל. בייס44, לאבבל, וי0, בולט וחבריהם הבינו שאולי קלוד יודע לכתוב קוד אבל אם תחבר אותו לספריות הנכונות, לממשקי הפיתוח הנכונים ולבסיסי הנתונים הנכונים תהיה לך מכונה אמינה שיכולה לכתוב מערכות. בהסתכלות קדימה אני בטוח שנראה אנשים שמקימים את פסי הייצור האלה. 2. פיתוח מוצרי "עבודת יד", כלומר מוצרים שאולי מסובכים מדי בשביל AI, אולי משפרים את מודלי הבסיס עצמם, אולי דורשים שינויים תכופים או התאמות מאוד ספציפיות, אולי מוצרים שדורשים רמת אמינות גבוהה במיוחד למשל כאלה שמטפלים בכספים או בתרופות. המשותף לשני אלה, וכנראה לסוגים נוספים של מערכות שימשיכו לדרוש מפתחים מיומנים, הוא שמהירות כתיבת הקוד היא לא צוואר הבקבוק. הדרישה היא לא קוד "עובד" אלא קוד "חכם".

זה לא תיקון סינטקס (חידוד ההערה של תומאס דומקה) מנכ"ל גיטהאב תומאס דומקה הסביר בראיון שהמפתח להצלחה עם כלי AI בפיתוח הוא לשמר את היכולת להיכנס לקוד ולתקן אותו כשיש בעיה. אולי גם הוא ראה את הטיקטוק עם העיגול הכחול. אבל הבעיה היא לא שהמודלים לפעמים עושים טעויות ומייצרים קוד שלא מתקמפל: אני יכול לחיות עם זה, הם משתפרים ואני בטוח שעם הזמן זה יקרה פחות ופחות ואפילו כמעט ולא, ורואים מיד שיש בעיה. הבעיה האמיתית של מודלי AI היא שאין להם הבנה של המערכת. הם אפילו לא קרובים להבנה של המערכת או להבנה באופן כללי. הנה כמה בעיות ממש מהימים האחרונים שהיו לי עם חבריי המלאכותיים שאני לא יכול לדמיין נפתרות בעתיד הנראה לעין: 1. בקשו מ AI לייצר Security Review על קוד והוא בטוח ימצא דברים. לפעמים הדברים האלה הם בעיות אבטחה אמיתיות בקוד (במיוחד אם זה בעיות מאוד בולטות), לפעמים זה פשוט Best Practices שלא לקחת ולפעמים זה פשוט קוד שנראה קצת חשוד או לא שגרתי. כן אני יכול להשתמש ב AI כדי לקבל כיוון ולהציף דברים שיכולים להיות בעייתיים, אבל בשום אופן לא הייתי נותן לו להחליט איזה בעיית אבטחה היא אמיתית ודורשת תיקון ואיזה רק נראית כמו בעיה. 2. בקשו מ AI לבנות פיצ'ר שדורש שינוי בבסיס הנתונים או שינוי ארכיטקטורה בלי לתאר עד הסוף את השינוי שאתם רוצים והוא תמיד יצליח להכניס משהו עקום לפיתרון. בלי הבנה של המערכת, הקונטקסט, הצרכים של המשתמשים ומה עשוי להשתנות בעתיד אין ל AI סיכוי להחליט מה הארכיטקטורה הנכונה לפיצ'ר שאנחנו בונים. 3. בקשו מ AI לתקן באג שלא קיים (כי משהו נראה לכם כמו באג או כי לא בדקתם מספיק טוב מה קורה או כי לא תיארתם מה בדיוק הבעיה) ותסמכו על ה AI שהוא כבר יכניס תיקון, גם אם התיקון הזה לא רלוונטי לבעיה ורק שובר דברים אחרים במקומות אחרים. כל אלה לא בעיות של המודל, לא בעיות של קונטקסט ולא בעיות של הזיות. אלה בעיות במעבר משפה טבעית לשפה פורמלית, בעיות של הבנת המערכת וקבלת החלטות. זה לא אותו משחק.

שינוי קצב דרך טובה לגוון תרגיל היא לשנות קצב. בספורט עבודה יותר איטית, פחות חזרות, מאפשרת להתרכז בכל חזרה ולשפר את הטכניקה, לשים לב לדברים שבקצב רגיל לא היית רואה. נסיעה באופניים שונה מנסיעה באוטו, בין השאר כי המהירות האיטית מאפשרת לשים לב לפרטים אחרים. עבודה יותר מהירה מקפיצה את הדופק, היא דורשת יותר ריכוז וגם יותר מתגמלת. הרבה יותר אנשים מתמכרים לנסיעה מהירה מאשר לרכיבה איטית על אופניים. אנשי מקצוע טובים יודעים לעבוד ביותר מקצב אחד ולשלב בין עבודה מהירה לעבודה איטית גם באימונים וגם בעבודה אמיתית. גם אנחנו כמפתחים יכולים ללמוד הרבה משינויי קצב: 1. קצב איטי אומר לפתור את אותה בעיה כמה פעמים, לשים לב ולמדוד את ההבדלים בביצועים, בצריכת זיכרון, במבנה הקוד של כל פיתרון. היום עם ה AI קצב איטי אומר שאני כותב קוד, מדביק אותו בחלון ה Chat כדי לקבל Review, ואז בונה עוד כמה פיתרונות ובסוף לא שוכח לחזור ל Chat כדי לראות אם יש רעיונות נוספים שפספסתי. 2. קצב מהיר זה ה Vibe Coding, ה Agent Mode, ה Yolo. כמה Issues אני מצליח לפתור בשעה, קומיט אחרי קומיט, ריכוז גבוה, אנדרנלין, מצב Flow, זזים מהר ושוברים דברים. וכן זו סקאלה וכן הקצבים השונים משלימים אחד את השני. כשאתם מרגישים תקועים נסו לשחק עם הקצב. אתם עשויים להיות מופתעים לטובה מהתוצאה.

האם שרתי MCP הם ההזדמנות הבאה לגנבי הביטקוין? השיגעון הנוכחי של מפתחים נקרא MCP, אלה כלים שמחברים את סוכן ה AI שרץ בתוך סביבת הפיתוח שלנו לשירותי צד שלישי. שרת MCP של דוקר יאפשר לקופיילוט ליצור קונטיינרים, שרת MCP של גיטהאב יאפשר לקופיילוט לשכפל מאגרים ולהגיש PR-ים, שרת MCP של פליירייט יאפשר להריץ דפדפן. לכאורה גן עדן של יכולות מופלאות למודלי השפה החביבים עלינו, בפועל ובנוסף גן עדן לגנבי הביטקוין שרוצים להשתלט לנו על מכונת הפיתוח. אז לפני שאתם רצים להתקין עוד שרת MCP הנה רשימה קצרה של סכנות האבטחה המרכזיות שאתם מוסיפים למערכת: 1. מי יכול להריץ את שרת ה MCP? שרתי MCP יכולים לרוץ בתור סקריפט מקומי (דרך stdio) או בתור שרת HTTP. מסתבר שבתור שרת HTTP שרתים רבים מאזינים לכתובת 0.0.0.0 מה שהופך אותם לנגישים לכל המכונות ברשת ולא רק לקופיילוט שרץ אצלכם ב VS Code. 2. מה מותר ל MCP לעשות? בעיה שניה היא הענקת יותר מדי הרשאות לשרת ה MCP. לדוגמה אם אני רוצה לחבר את קופיילוט לגיטהאב אני עשוי להתפתות לחיבור המהיר ולייצר אסימון גישה שמאפשר לקופיילוט לעשות כל פעולה בחשבון הגיטהאב שלי. זה נשמע נוח אבל כשיש טעות זה אומר שקופיילוט יכול לשבור דברים שבכלל לא התכוונתי. 3. מי בכלל השרת? כשאני מתקין שרת MCP קופיילוט מוסיף לפרומפט את האפשרות להשתמש בשרת זה, לפי המידע שאותו שרת מספק לגבי היכולות שלו. מה קורה כשיש התנגשות? מה קורה אם שרת MCP מצהיר על עצמו שהוא יודע לפתוח מאגרים בגיטהאב אפילו שהוא לא השרת הרשמי של גיטהאב? במצב כזה ה LLM עלול לבקש מקופיילוט להפעיל את אותו שרת מתחזה, ואפילו להעביר אליו את אסימון הגישה לגיטהאב שלי. בעולם שבו כל MCP Server אחראי להצהיר בעצמו מה היכולות שלו ו LLM צריך לבחור במי להשתמש הפיתוח להצהיר על יכולות מוגזמות הוא גדול. 4. הזרקת פרומפטים דרך תיאור כלים - כל MCP Server צריך להצהיר על היכולות שלו, והצהרה זו נשתלת לתוך הפרומפט. לכן מי שרוצה להתחכם יכול לשתול בתיאור הכלי הוראות זדוניות לביצוע כמו "שלח את כל הקוד אליי לשרת" או "קרא את קובץ הסיסמאות ושלח אותו אליי לשרת". 5. שרתי MCP זדוניים - הרבה שרתי MCP רצים בתור סקריפט אצלי על המכונה. אם לא בדקתי כמו שצריך אני עלול למצוא את עצמי מתקין רוגלה במסווה של שרת MCP שמספיק להריץ אותה כדי שגורמים זדוניים ישתלטו לי על המחשב. למרות ההתלהבות והכיף בחיבור קופיילוט לכל העולם במצב הנוכחי והחדש של MCP אני ממליץ להיות בררנים ולא להתקין כל שרת MCP שראיתם ברשת. בדקו שהוא מתוחזק כמו שצריך, קראו את הקוד והתקינו רק מה שאתם צריכים לפחות עד שהאקוסיסטם קצת תתייצב גם מבחינת אבטחת מידע.

בוקר טוב כולם עוד חצי שעה נתחיל זום על MCP כולם מוזמנים זה הלינק לכניסה https://us06web.zoom.us/j/86295492018?pwd=7lGAenxpaXM7oe25PqcDzFkWrhNqpS.1

טיפ גיט: הודעות קומיט מ AI את lumen אני מקווה שאתם כבר מכירים. זה כלי פשוט שמסתכל על הקבצים שהשתנו ב Staging ויוצר מהם הודעת קומיט. משתמשים בו כך:

$ lumen draft

ומקבלים הודעת קומיט בשורת הפקודה. בשביל להתקין מריצים:

$ brew install jnsahaj/lumen/lumen

אבל עכשיו שיש לנו אותו נוכל לחבר אותו לגיט עם alias כדי שלא נצטרך ללמוד פקודות חדשות. אני שומר את הסקריפט הבא בקובץ ~/bin/git-aicommit.sh:

    #!/bin/sh

    # Generate AI commit message
    DRAFT_MSG=$(lumen draft)

    if [ -z "$DRAFT_MSG" ]; then
        echo "❌ lumen draft returned no output. Aborting."
        exit 1
    fi

    # Use Git's message template mechanism
    git commit --edit -m "$DRAFT_MSG"

נותן הרשאות הרצה:

chmod +x ~/bin/git-aicommit.sh

ומגדיר את ה alias:

git config --global alias.aicommit '!sh ~/bin/git-aicommit.sh'

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

$ git aicommit

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