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

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

לקרוא כל שורת קוד ייקח נצח.

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

מה עושים? משלבים:

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

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

3. טאב שלישי זה הסוכן. תוך כדי מעבר על ה Diff אני שואל שאלות, "למה השורה הזאת שם?", "למה לשמור את זה או את זה ב DB". כשהשינוי גדול אני משתמש בכמה טאבים של סוכנים כי בדרך כלל אני שואל שאלות יותר מהר ממה שהם מצליחים לענות.

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

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

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

2. או שאפשר לבחור לזרוק את כל המימוש, לשפר את הפרומפט ולתת לסוכן לכתוב מחדש.

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

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

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

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

אחד מסיים אחרי יומיים עם קוד עובד ויכול להסביר מה בדיוק קורה במערכת.

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

איך זה קורה?

אפשר לספר על דיוק פרומפטים ו Context Engineering. אפשר לספר על סדר פעולות ואם צריך קודם לעבוד במצב תכנון ואז לממש. אפשר לדבר על MCP ו Skills ופלאגינים.

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

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

גם ב 2026 ולדעתי גם בעתיד הנראה לעין, מפתחים טובים הם אלה שיודעים איך נראה הקוד שפותר את הבעיה לפני שניגשים להפעיל את ה AI שיכתוב אותו. לא כל שורה (כאן המפתח לפרודוקטיביות), לא כל קריאת API, אבל כן הבנה ברורה של המבנה.

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

אם אתם כותבים כדאי לנסות את הכלי הזה:

https://tools.simonwillison.net/llm-cliche-highlighter

הוא מרכז 38 תבניות כתיבה אופייניות ל AI ויכול למצוא אותן בטקסטים שאתם כותבים. בין התבניות שמצאתי בטקסטים שלי שממש מתאימות ל AI הכלי זיהה:

1. שימוש ברצף של שאלות רטוריות.

2. נקודותיים ואז שלושה פריטים.

3. חזרה על אותו צירוף מילים בשני משפטים רצופים לצורך הדגשה.

4. משפט חיובי ואחריו מה שלא הצליח (לדוגמה Reading mostly passed … Writing didn’t)

5. שרשראות של no לדוגמה No fluff, no filler, no jargon

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

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

1. טיפול במקרי קצה שאי אפשר להגיע אליהם (על חשבון מקרי הקצה האמיתיים שלא טופלו).

2. כתיבת המון בדיקות יותר מדי ספציפיות.

3. כפל קוד.

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

5. כתיבת הערות בהגזמה במקום קוד קריא.

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

הבעיה עם עודף קלישאות היא המיסוך. במקום לסמן משהו לגבי המציאות הן מסתירות אותה, מה שדורש מאיתנו להיות הרבה יותר ביקורתיים בעבודה עם תוצרים שקיבלנו מ AI.

טעות בפרומפט גרמה לסוכן לעלות מ 10% שגיאות ל 30%.

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

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

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

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

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

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

"מה בעצם הבעיה?"

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

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

אבל זאת לא ההשוואה הנכונה.

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

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

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

1. בפרויקט יש תיקיית _components ולידה תיקייה בשם components. כן הבנתי שאתם משתמשים ב shadcn אבל האילוצים הטכניים הם בחירה שלכם.

2. הפרויקט מכיל 3 תיקיות עזר נסתרות: .vercel, .next ו .eve.

3. הפרויקט כולל 3 מנגנוני אימות משתמשים: אחד דרך vercel, שני חיבור מקומי בפיתוח ושלישי הוא Placeholder שעלינו להחליף בפלאגין אותנטיקציה אמיתי אחרי שנבחר אחד.

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

הנה DHH מתוך הדוקטרינה של ריילס בשביל השוואה:

We write code not just to be understood by the computer or other programmers, but to bask in the warm glow of beauty. Aesthetically pleasing code is a value unto itself and should be pursued with vigor. That doesn’t mean that beautiful code always trumps other concerns, but it should have a full seat at the table of priorities.

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

class Project < ApplicationRecord
  belongs_to :account
  has_many :participants, class_name: 'Person'
  validates_presence_of :name
end

מעט שורות, הרבה משמעות ונקרא כשפה טבעית.

בפרויקט eve החדש זה התוכן של page.tsx:

import { AgentChat } from "@/app/_components/agent-chat";

export default function Page() {
  return <AgentChat />;
}

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

כשקוראים את הקוד של eve אי אפשר שלא להשוות עם ספריית הסוכנים Pydantic AI שסקרתי כאן ממש לא מזמן. אותו סוכן שהגיע ב eve לאלפי שורות בנוי ב Pydantic עם הקוד הזה:

from pydantic_ai import Agent

agent = Agent('openai:gpt-5.2', instructions='You are a helpful assistant.')
app = agent.to_web()

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

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

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

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

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

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

אף אחד לא אהב את זה.

הרבה לפני ה AI בנינו פריימוורקים לצמצום הפער. בנינו תשתיות של Infra As Code וחיבורים לענן כדי שמפתחים יוכלו להקים לעצמם את התשתית ונפרדנו מתפקידי Sysadmin ו DB Admin לטובת Devops. בנינו פריימוורקים לפיתוח צד שרת וצד לקוח יחד והתחלנו לגייס מפתחי Full Stack. פריימוורק כמו Next.js עם האינטגרציה שלו ל Vercel מיועד לתת פתרון פיתוח מקצה לקצה בו מפתח אחד שמכיר את הפריימוורק יוכל לבנות פיצ'ר מלא או מוצר מלא לבד.

ואז הגיע ה AI והאיץ את התהליך.

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

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

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

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

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

3. צוות FrontEnd אחראי על חווית המשתמש וקוד ה Front, שיפור הארכיטקטורה, יצירת אחידות בקומפוננטות ושיפורי ביצועים שקשורים לממשק.

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

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

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

Work with Claude directly in your codebase. Build, debug, and ship from your terminal, IDE, Slack, web, and more.

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

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

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

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

4. שימוש במחשב - חיבור קלוד קוד לתוכנות אחרות על המחשב.

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

ומה קורה ב OpenAI? הנה כמה פיצ'רים עדכניים שלהם:

1. מצב "מטרה" שנועד לטפל במשימות ארוכות.

2. הפעלת סוכנים במקביל והפרדה ביניהם, כולל אינטגרציה עם git worktrees ושליטה במקביל על כל הסוכנים מתוך האפליקציה.

3. שימוש במחשב וחיבור סוכן הקידוד לתוכנות אחרות שמותקנות לי על המכונה.

4. חיבור מרחוק דרך הטלפון.

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

6. הצגת Diff של עבודת הסוכן ומעבר על הקוד מתוך קודקס.

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

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

https://fx.sh/

הוא מגיע אחרי פאי שמתגאה בליבה מינימליסטית ותשתית הרחבות מפותחת:

https://pi.dev/

ועוד סוכנים וותיקים יותר כמו opencode, goose ו cline.

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

האהוב עליי נקרא paseo והוא מספק סביבה להרצה וניהול סוכנים מרובים במקביל, כולל חיבור לטרמינל, עורך טקסט ודפדפן מובנה, אינטגרציה עם תוכנות שמותקנות על המחשב ועם git worktrees בשביל מקביליות. את paseo אפשר לחבר לקלוד קוד וקודקס אבל גם לסוכנים הקטנים יותר כמו fx ו pi כי כולם מדברים ACP.

כלי בשם agent deck מספק יכולות דומות אבל מתוך סביבת Terminal.

וייב קנבן שלוקח את לוח ה Kanban בתור המבנה המרכזי ובונה סוכנים סביבו.

ו kepler מהיוצרים של Git Kraken.

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

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

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

ביקשתי מהסוכן לעבור על הקוד והוא הגיב:

I found eight concrete cases where the uncommitted views cause redundant or oversized queries.

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

המתח היותר משמעותי הוא "האם יש דרך שהתהליך כולו יהיה אוטומטי?" ו"האם הבעיות האלה בכלל חשובות?".

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

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

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

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