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

תלמיד שואל "יש אצלנו בעבודה רק 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. כדי לקבל רעיונות ולמצוא שיטות עבודה טובות יותר לא צריך להתקין עוד כלים שעובדים אותו דבר אבל כן כדאי לנסות את שלושת הקטגוריות ולראות איזה שיטת עבודה הכי מתאימה לכם, או אולי לשלב כמה שיטות עבודה לפי הפרויקט וסוג הפיצ'ר שאתם בונים.

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

פקודת 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())

ריילס שחררו גרסה שמתקנת 21 בעיות אבטחה השבוע: https://rubyonrails.org/2026/11/4/Rails-8.0.5.2-and-8.1.4.1-have-been-released

אלפין לינוקס היה פתוח לכניסה לכל אחד בעשר השנים האחרונות פשוט על ידי הכנסת סיסמה ארוכה מ 256 תווים: https://sshhole.com

באג בספריה בשם ברוטלי אפשר לכל אחד להיכנס להמון שרתי לינוקס באמצעות הרצת סקריפט פשוט: https://ubuntu.com/security/CVE-2026-111497

כל זה רק כמה ימים אחרי שהתגלה PHP2Shell אוסף חולשות בליבה של PHP ששוב אפשרו השתלטות מלאה על שרתים שמריצים PHP: https://www.php2shell.com

לפני כמה שנים כל באג כזה היה מעסיק אותנו לחודשים. כש Heartbleed התגלה ב 2014 אתרים שלחו מיילים מבועתים ללקוחות וביקשו מכולם להחליף סיסמאות כי אי אפשר לדעת איזה מידע דלף. היום בעיות בהיקף דומה ואפילו גדול יותר הולכות לאיבוד ברעש הכללי של AI.

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

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

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

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

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

3. איפה שומרים את המיפוי ממזהים לשמות משתמשים - נשמור אותם בבסיס הנתונים או במיפוי זמני? ואם בבסיס הנתונים איך נדע כשמישהו שינה לעצמו את השם? אם במיפוי זמני לכמה זמן נשמור את המידע?

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

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

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

ומה איתנו?

נניח שאני רוצה לבנות מערכת API בפייתון שתעבוד להרבה לקוחות. אני מתייעץ עם ה AI והוא ממליץ לי על FastAPI כשהשורה הראשונה בהמלצה "מהיר מאוד ותומך ב-async". אני יכול להמשיך עם "תראה לי דוגמה" או לשאול מה זה asyncio ומה היתרונות שלו ואז אני מבין בגדול על מה מדובר ויכול להתקדם לכתוב את השרת.

אבל כל זה זה למידה של אתמול.

יותר מעניין להמשיך את השיחה עם "מעניין ואיך זה בנוי?" ואפילו "מה הייתי צריך בשביל לממש event loop מאפס?". השאלה השניה מלמדת אותי שזה אפשרי ושהבסיס הוא Generators אז אני ממשיך עם פרומפט יותר ארוך:

בנה מודול לימוד אינטרקטיבי בסגנון Khan Academy על ״מבנה asyncio בפייתון״
במודול לומדים איך עובד asyncio ומה זה mainloop ואיך בונים אותו מאפס. נרצה לראות מימוש פשוט לדוגמה של Task Scheduler, Poller, Time queue ו Ready queue.

אני רוצה משחק סיכום כיפי שמורכב מ-10 ״אתגרים״ בעברית שמוודאים שהתלמיד הבין את הרעיונות המרכזיים במודול

בנה את זה בתור artifact עם HTML/JavaScript/CSS שיהיה יפה מדליק וכיפי לתלמידים

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

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

בנה מודול לימוד אינטרקטיבי בסגנון Khan Academy על ״מבנה asyncio בפייתון״
במודול לומדים איך עובד asyncio ומה זה mainloop ואיך בונים אותו מאפס.

אני רוצה משחק סיכום כיפי שמורכב מ-10 ״אתגרים״ בעברית שמוודאים שהתלמיד הבין את הרעיונות המרכזיים במודול

בנה את זה בתור artifact עם HTML/JavaScript/CSS שיהיה יפה מדליק וכיפי לתלמידים

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

שים לב:

1. המודול צריך להיות פשוט. לא להשתמש במילים מתוך async/await עצמה אלא להראות קודם איך בונים כל מושג מתוך מושגים בסיסיים יותר. אני רוצה להתמקד בפיתוח אינטואיציה לגבי asyncio יותר מאשר היכרות עם הפרטים הטכניים שלו
2. המודול צריך ללמד צעד צעד איך בונים mainloop ופונקציות אסינכרוניות ואיך החלקים מתחברים. אפשר להישאר רק עם sleep בתור פעולה לא צריך עבודת רשת בינתיים.

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

https://claude.ai/artifact/S9H8oUouBggjmBizAn6cJF

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

כשהסוכן כותב ״סיימתי הכל בהצלחה״ למה הוא מתכוון?

נתתי ל-4 סוכנים להוסיף 4 פיצ׳רים במקביל לאפליקציית דוגמה לקראת הוובינר של יום חמישי.

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

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

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

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

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

1. צריכים תרגום? תקראו ל claude עם פרומפט שמבקש תרגום.

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

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

אז בשביל מה צריך לכתוב סוכן? אלה התשובות הכי מעניינות שאספנו:

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

2. שליטה בטוקנים - כתיבת סוכן מאפשרת לי לקבוע את ה System Prompt ולבחור בדיוק מה יישלח ל LLM.

3. חיבור לתוכנית שלי באמצעות מימוש כלים - במקום לכתוב MCP אני יכול לכתוב פונקציות פייתון פשוטות שיאפשרו למודל להתממשק עם המערכת הקיימת שלי.

4. פלט מובנה - פניה לסוכן בסקריפט עם claude -p מחזירה תמיד תשובה כמחרוזת. סוכן יכול לדרוש Structured Output כדי לקבל מבנה צפוי של התשובה.

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

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

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

פעם שניה הוא הלך לאיבוד בחיבור בין next.js ל eve. תיקנתי שוב את הפרומפט.

פעם שלישית הוא ניסה להשתמש בבסיס נתונים מקומי שלא עובד על vercel, שוב שדרגתי את הפרומפט עם הנחיה מפורשת לשמור את בסיס הנתונים על neon.

פעם רביעית הוא השתמש ב BetterAuth המשולב ב neon (או לפחות ניסה). תיקנתי את הפרומפט שישתמש במנגנון התחברות מקומי.

פעם חמישית הוא טעה באתחול הפרויקט. השתמש בטעות בתיעוד ישן של eve אז שוב חיזקתי את הפרומפט עם קישור ישיר לתיעוד ואיך מתחילים פרויקט חדש.

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

ופעם שביעית הוא שכח ש .env.local נטען רק מ next.js וצריך לטעון את משתני הסביבה באופן מפורש כשכותבים סקריפטים משורת הפקודה.

ואחרי כל הטעויות האלה הבנתי למה אנחנו אוהבים Coding Agents ואיך כלי פיתוח פשוטים מסתירים את הטפשות של מודלי שפה. אפילו שקלוד מאוד חכם יש יותר מדי נעלמים וניחושים בכתיבת מדריך מראש, אבל כל גרסה של מדריך שנכתבה היה אפשר לתקן ולהביא למצב שהיא עובדת בעזרת לולאת תיקון "תוודא שזה עובד, תקן את הטעויות ותחזור אליי עם קוד רץ". לא כל גרסה היתה יוצאת משהו שרציתי, אבל הרבה יותר מעניין לבחור את ה Tutorial הכי טוב מבין 7 גרסאות (או להמשיך ולייצר גרסאות עד שאני מגיע לגרסה שרציתי).

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

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

https://tocode.ravpage.co.il/ai-daily

יש בו משהו מינימליסטי ויפה אב גם משעמם וקצת מזכיר דף HTML מספר לימוד. (הוא עובד אגב אין בעיה להירשם שם).

וזו הגרסה השניה אחרי הערות:

https://tocode.ravpage.co.il/ai-daily-devs

הרבה יותר יפה אבל משעמם באותה מידה. (גם הוא עובד. אפשר להירשם ותקבלו 4-5 מאמרים על AI למייל כל בוקר מלבד שבתות וחגים).

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

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