הבלוג של ינון פרק

טיפים קצרים וחדשות למתכנתים

גם זה פיתוח תוכנה

16/11/2026

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

איך מתקדמים מכאן?

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

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

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

"מעניין איך זה עובד" היא השאלה הראשונה בדרך להפוך למפתחי תוכנה. גם אם תכנות ב 2026 הוא לא מה שהיה לפני 5 שנים.

תרבות פיתוח מול טכנולוגיה

15/11/2026

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

אבל בניגוד למה שכותבים כל המתלוננים לדעתי הבעיה של האמבל באנדל היא לא AI אלא תרבות פיתוח.

מישהו אישר את הגרסה הזאת.

מישהו לא לקח את האתר ל Security Audit מסודר למרות שהקוד והיכולות השתנו.

מישהו בחר לא לקרוא את הקוד כי AI מייצר יותר מדי שינויים.

אולי מישהו חשב שאם ה AI אומר שהכל בסדר אז אפשר לעלות לאוויר.

המחשבה ש AI יכול להאיץ תהליכי פיתוח תוכנה פי 10 היא היום עדיין תמימות והדיבורים על פי 100 או פי אלף מרגישים מנותקים. כן אפשר לייצר תוכנה עובדת בזמן קצר אבל בני אדם לא מצליחים לקחת אחריות על מערכת שנבנית כל כך מהר. אנחנו עדיין צוואר הבקבוק גם כשאנחנו לא אלה שמקלידים את הקוד.

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

שיקולים בפיתוח תוכנה שאולי צריכים להשתנות

14/11/2026

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

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

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

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

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

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

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

מחשבים שמתקנים את עצמם

12/11/2026

קלוד הפתיע אותי השבוע, או שאולי זה היה העולם. הוא התחיל לבנות איזה פרויקט ואז כתב שהוא יעדכן כשזה יסתיים. אחרי כמה דקות שאלתי "מה הסטטוס של הבניה?" וזה שלח אותו להרהר גם. "למה זה לוקח כל כך הרבה זמן" הוא שאל את עצמו, התחיל לחפש על המכונה, גילה שמותקן אצלי Crypto Miner (זו היתה מכונה וירטואלית עם כתובת IP ציבורית), הריץ סריקת רשת על המכונה זיהה את השירות הבעייתי סגר אותו וביקש רשות לשים חומת אש.

אמריקה.

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

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

https://www.tocode.co.il/talking_ai

היום למדתי: setHTML במקום innerHTML

11/11/2026

במשך שנים ספריות לפיתוח צד לקוח או Full Stack ניסו לעצור אותנו מלהפעיל innerHTML בגלל סכנת ה XSS. הרעיון הוא שאם אנחנו משנים את ה DOM בצורה דינמית מתוכן שאולי הגיע ממשתמשים, אז אולי אותם משתמשים יזריקו קוד JavaScript לעמוד. אף אחד לא פוחד ממשתמש שיזריק לעצמו קוד JavaScript כמובן הבעיה היא הזרקת JavaScript בין משתמשים, למשל מישהו כותב הודעה בפורום ואז מישהו אחר פותח את הפורום ואוטומטית הדפדפן שלו מריץ את ה JavaScript שכתב הראשון.

אולי כאן המקום להתוודות שגם אני נהניתי מבאגים בסגנון זה ובצעירותי נהניתי לזרוק אנשים ממשחק אונליין של 1 נגד 100 באמצעות שליחת הודעה עם קוד JavaScript בצ'אט של המשחק - מה שהשאיר אותי מנצח וגם משועמם (לא היו פרסים).

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

דוגמה? בטח. ניקח את ה HTML הזה:

const html = `<p>Hello from <strong>injected HTML</strong>!</p>
<img src="data:image/png;base64,invalid" alt="" onerror="alert('Injected JavaScript ran!')">`

הקוד הזה:

unsafeOutput.innerHTML = html

יגרום להקפצת ההודעה Injected JavaScript ran, בעוד שהקוד הזה:

safeOutput.setHTML(html)

יציג על המסך את הטקסט בלי להפעיל את ה JavaScript. יש גם אופציה להוסיף sanitizer שלכם שעדיין יוריד אוטומטית כל מה שאולי כולל קוד JavaScript אבל יוכל להוריד גם אלמנטים נוספים שלדעתכם אינם בטוחים.

הפונקציה קיבלה תמיכת דפדפנים ממש לפני כמה חודשים עם כרום ממרץ, פיירפוקס מפברואר, אדג' ממרץ ואופרה מאפריל. ואפל? הם היחידים שלא ממהרים.

למה להכיר כלי פיתוח AI מגוונים

10/11/2026

תלמיד שואל "יש אצלנו בעבודה רק Copilot. שווה לי להתאמץ להכיר עוד כלים? לא עדיף להתמקצע בכלי שכבר יש?"

כמו הרבה שאלות מעניינות התשובה גם כאן מורכבת ומכילה שיקולים שונים. במקום לתת המלצה בואו נחשוב על היתרונות והחסרונות.

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

הסיפור של "למה כן" לדעתי יותר מעניין. כלי פיתוח מבוססי AI מחולקים היום ל-3 קבוצות: יש לנו כלי שורת פקודה, כלים המשולבים ב IDE וסביבות AI Native. כלי שורת פקודה הם כלים כמו Claude Code בשורת הפקודה, copilot של שורת הפקודה, pi ו opencode. הממשק שלהם פשוט והם הראשונים לקבל פיצ'רים חדשים כי הכי קל לכולם להוציא להם עדכונים. הם גם נותנים הכי הרבה שליטה ושקיפות.

כלי AI המשולבים ב IDE הם הכי נוחים והם היום ההעדפה של מפתחים רבים שאני מכיר. זה הקלוד קוד שבתוך VS Code או pycharm. מדובר בממשק שעדיין שם את הקוד במרכז אבל מוסיף תיבת צד של שיחה עם סוכן ומאפשר לדבר עם הסוכן על הקוד.

והקבוצה השלישית, כלי פיתוח AI Native מורכבת מכלים ששמים במרכז את הפיתוח המקבילי ועבודה עם מספר סוכנים. כלים כמו Agent Window של VS Code או paseo.sh ואפילו Claude Code בגרסת ה Desktop. אלה כלים שמראים לי את הסוכנים שרצים במקביל מסודר בצד שמאל וקוראים לי רק כשסוכן מסיים עבודה. הרבה פעמים כלים אלה מספקים ממשק לשליטה מרחוק מהטלפון ופותחים חווית פיתוח חדשה ששמה במרכז את השיחה ואת השינויים שקשורים לאותה שיחה.

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

דיוקים בפרומפט

09/11/2026

פרומפט 1-

כתוב לי פונקציית פייתון רקורסיבית שמחשבת מספר כלשהו בסדרת פיבונאצ׳י היא מקבלת אינדקס ומחזירה את המספר
השתמש ב Memoization כדי לא לבצע חישובים מיותרים

פתרון של קלוד:

def fibonacci(n, memo=None):
    if memo is None:
        memo = {}
    if n < 0:
        raise ValueError("האינדקס חייב להיות מספר אי-שלילי")
    if n in memo:
        return memo[n]
    if n < 2:
        return n
    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]


print(fibonacci(10))   # 55
print(fibonacci(50))   # 12586269025

פרומפט 2-

כתוב לי פונקציית פייתון רקורסיבית שמחשבת מספר כלשהו בסדרת פיבונאצ׳י היא מקבלת אינדקס ומחזירה את המספר
השתמש ב Memoization כדי לא לבצע חישובים מיותרים
אל תבנה מאפס השתמש במה שכבר יש בפייתון
from functools import cache

@cache
def fib(n: int) -> int:
    """מחזירה את המספר ה-n בסדרת פיבונאצ'י (fib(0)=0, fib(1)=1)."""
    if n < 0:
        raise ValueError("האינדקס חייב להיות אי-שלילי")
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)


print(fib(10))   # 55
print(fib(100))  # 354224848179261915075

פרומפט 3-

כתוב לי פונקציית פייתון רקורסיבית שמחשבת מספר כלשהו בסדרת פיבונאצ׳י היא מקבלת אינדקס ומחזירה את המספר
השתמש ב Memoization כדי לא לבצע חישובים מיותרים (מה שקיים בפייתון לא צריך לבנות לבד)
שים לב לזכרון תשמור רק כמה שצריך

קוד פייתון של קלוד:

from functools import lru_cache

@lru_cache(maxsize=3)
def fib(n: int) -> int:
    """מחזירה את המספר במקום ה-n בסדרת פיבונאצ'י (fib(0)=0, fib(1)=1)."""
    if n < 0:
        raise ValueError("האינדקס חייב להיות אי-שלילי")
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)


print(fib(30))  # 832040

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

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

יבוא כל דבר בפייתון

08/11/2026

פקודת import בפייתון טוענת מודול חיצוני ובדרך כלל אנחנו לומדים אותה יחד עם הלימוד על מודולים. יוצרים קובץ בשם utils.py ואז מתוך main.py כותבים import utils כדי להשתמש בפונקציות שמוגדרות שם. אבל האמת שמנגנון היבוא של פייתון הרבה יותר גמיש.

מודול sys מגדיר משתנה בשם meta_path שמכיל רשימה של "טוענים":

>>> import sys
>>> [print(i) for i in sys.meta_path]
<_distutils_hack.DistutilsMetaFinder object at 0x1023ab8f0>
<class '_frozen_importlib.BuiltinImporter'>
<class '_frozen_importlib.FrozenImporter'>
<class '_frozen_importlib_external.PathFinder'>

מודול importlib יודע לחבר בין שם של מודול לאוביקט שיטען אותו:

>>> import importlib.util
>>> print(importlib.util.find_spec('sys').origin)
built-in
>>> print(importlib.util.find_spec('json').origin)
/Users/ynonp/.pyenv/versions/3.12.0/lib/python3.12/json/__init__.py
>>> print(importlib.util.find_spec('random').origin)
/Users/ynonp/.pyenv/versions/3.12.0/lib/python3.12/random.py

והחלק הכי טוב? אפשר להוסיף "טוענים" משלנו כדי לטעון דברים חדשים. התוכנית הבאה תדפיס Hello from foo בלי שהיא צריכה קובץ foo.py באותה תיקיה:

import sys
import types
import importlib.abc
import importlib.machinery


class CatchAllFinder(importlib.abc.MetaPathFinder):
    def find_spec(self, fullname, path=None, target=None):
        # Only called as a fallback if registered last
        return importlib.machinery.ModuleSpec(
            fullname,
            CatchAllLoader()
        )


class CatchAllLoader(importlib.abc.Loader):
    def create_module(self, spec):
        return None  # Let Python create the module

    def exec_module(self, module):
        module.hello = lambda: f"Hello from {module.__name__}!"


# Append LAST so normal modules take priority
sys.meta_path.append(CatchAllFinder())

import foo
print(foo.hello())

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

import gmail_mcp as gmail

print(gmail.inbox.read(5))

המשחק כאן יהיה לממש Loader שטוען כל שם שמסתיים ב _mcp ומתחבר ל MCP Server שמתאים לו וכל פונקציה על אותו מודול תפעיל כלי באותו שם. בטח הרבה יותר נחמד מהגרסה המשעממת מהמודול mcp:

import asyncio

from mcp import Client


async def main() -> None:
    async with Client("http://localhost:8000/mcp") as client:
        result = await client.call_tool("add", {"a": 1, "b": 2})
        print(result.structured_content)  # {'result': 3}


asyncio.run(main())