כל מפתח מכיר את הפנטזיה על שכתוב מלא של מערכת הליבה. בדרך כלל היא נגמרת בפגישת ארכיטקטורה עגומה שבה מחליטים להמשיך להוסיף טלאים, כי אף הנהלה שפויה לא תאשר לצוות שלם לעצור את הפיתוח העסקי לשנתיים. השבוע GitHub הודיעה שהיא עשתה בדיוק את זה, אבל בתנאים של 2026. לפי פוסט בבלוג הרשמי של החברה, מפתח יחיד, Stephen Toub, הוביל שכתוב מלא של מנוע הסוכנים שלה מ-TypeScript ל-Rust. לפי החברה, המערכת כוללת כיום מעל 800 אלף שורות קוד Rust בייצור, והפרויקט כולו הושלם תוך חודשים בודדים בלבד.
לא הייתי ממהר להסיק שצוותי פיתוח אנושיים מיותרים מעכשיו. מדובר בניסוי ארכיטקטוני מוצלח, אבל עם לא מעט כוכביות.
ההישג האמיתי היה המבנה
מנוע הסוכנים של Copilot הוא כבר מזמן לא רק הכלי שמציע השלמות בטרמינל דרך GitHub Copilot CLI. הוא משמש תשתית משותפת לעורכי קוד כמו VS Code ולאפליקציות שולחניות כבדות כמו Word, שבהן לכל מגה-בייט של זיכרון יש משמעות קריטית. לכל המוצרים האלה יש דרישות שונות לחלוטין, אך אף אחד מהם לא רצה לממש בעצמו את לולאת הסוכן השלמה על כל מורכבויות האבטחה והאמינות. במקור, המנוע נכתב ב-TypeScript ורץ על גבי Node.js ומנוע V8 עבור מה שנקרא GitHub Copilot cloud agent.
כשהוחלט להגר במאי 2026, ההערכה הראשונית עמדה על כ-130 אלף שורות קוד בלבד. אלא שחלקים מה-TUI הועברו למנוע הליבה, ובמקביל עשרות מפתחים המשיכו לדחוף תכונות חדשות בקצב של מאות PRs בשבוע. בפועל, לאורך הפרויקט נמחקו כ-430 אלף שורות TypeScript ונכנסו כ-300 אלף שורות חדשות בשפה הזו. בצד של Rust, נכנסו כ-1200000 שורות ונופו כ-365 אלף, עד שהקוד התייצב על יותר מ-800 אלף שורות ייצור פעילות.
את רוב הקוד החדש לא כתב מתכנת אנושי שישב מול עורך טקסט. המשימה בוצעה באמצעות צי של סוכנים מבוססי GitHub Copilot שפעלו דרך ה-CLI והאפליקציה, כשהם נעזרים בפיצולים של סשנים ומריצים בדיקות במקביל. המפתח ניהל את הארכיטקטורה, בדק את ה-PRs, ווידא שהמערכת ממשיכה לפעול. סך הכל הוגשו 128 פול-ריקווסטים ישירות לענף הראשי main, בלי להקפיא את הפיתוח השוטף של שאר הארגון אפילו ליום אחד.
למה Node.js הפך לנטל
ההחלטה להיפטר מ-TypeScript לא נבעה מתוך שנאה לשפה או רצון להשתעשע בטכנולוגיה חדשה. כפי שמתואר בהודעה, TypeScript ו-Node.js היו בחירה סבירה לפיתוח מהיר של ממשק שורת פקודה, אך המבנה יצר בעיה ברגע שנזקקו לגישה תכנותית דרך SDK. במקום להפריד שכבות מראש, ה-SDK הולבש מעל ה-CLI במצב headless. כל לקוח שהשתמש ב-Copilot ב-C#, ב-Python, ב-Java, ב-Go או ב-Rust, נאלץ להרים תהליך רקע נפרד של Node.js ו-V8, כאשר התקשורת ביניהם התבססה על פרוטוקול JSON-RPC מעל stdin ו-stdout.
עבור אפליקציית שורת פקודה בודדת מדובר במחיר נסבל. אבל כשכל אפליקציה צרכנית נאלצת לשאת איתה בינארי של Node.js או V8, התקורה נעשית כבדה. כל מופע גבה לפחות 100 מגה-בייט של זיכרון עבודה רק עבור זמן הריצה. תהליך הפעולה דרש ניתוח כמויות גדולות של JavaScript, ייצור bytecode ואופטימיזציות JIT. בנוסף, מודל התהליכיות של Node.js דחף סידוק סדרתי של משימות CPU, וכל אירוע או קריאת קובץ נאלצו לחצות גבולות תהליך. קריסה ב-Node.js הפילה את הסשן כולו, וכל פריסה דרשה ניטור של שני תהליכים נפרדים.
זה אמר שערכות הפיתוח של C#, Python, Go, Java ו-Rust שילמו כולן על זמן ריצה של שפה שנייה שלמה לכל קליינט, בסדר גודל של 100 מגה-בייט זיכרון מינימום, עבור סביבה שלאפליקציה שלהן לא היה בה צורך.Stephen Toub בבלוג של GitHub
המעבר ל-Rust פתר את הפקק הזה מהיסוד. הצורך הוגדר כספרייה ללא ממשק משתמש, עם תקורת משאבים מינימלית ויכולת טעינה מקומית ישירה בתוך התהליך המארח. Rust מאפשרת לקמפל בינארי שחושף ממשק C ABI ישיר עבור כל שפות ה-SDK דרך FFI, לצד שרת מבוסס sockets או stdin/stdout למקרים שבהם עדיין נדרשת הפרדת תהליכים. כך בוטל הצורך במנועי JS זרים ברקע.
איך משכתבים בלי לעצור
הסכנה הגדולה בפרויקטים כאלה היא ניסיון השכתוב במכה אחת. בחברה מיפו את האפשרויות: גישת Big Bang הכוללת עצירת עבודה מוחלטת או פיתוח מקביל בענף צדדי, מול שכתוב הדרגתי במקום. פיתוח מקביל נפסל מיד כי הוא היה גורר מרדף אינסופי אחרי שינויים שוטפים. בחברה בחרו בהחלפה אטומית רכיב-אחר-רכיב, שבה כל חלק מומר מ-TypeScript ל-Rust ונמחק באותו הפול-ריקווסט.
המתודולוגיה הייתה כירורגית. המפתח בודד רכיב ספציפי ב-TypeScript, והנחה את סוכן ה-AI לייצר לו מימוש מקביל ב-Rust. כדי לשמור על רציפות, הוכנסה שכבת תיאום דקה (shim) שחיברה בין קוד ה-TypeScript הקיים למימוש ב-Rust, והקוד הישן נמחק מיד. המפתחים נמנעו במכוון מגישת A/B שבה שתי הגרסאות נשמרות במקביל, כיוון שתחזוקת שתי מערכות במקביל עם ספריות תלות שונות בקוד שמשתנה ללא הרף היא סיוט תחזוקתי, במיוחד ברכיבים מורכבים כמו תזמור סשנים שמנהלים מצב פנימי.
לפי החברה, כל בדיקות המערכת ההיקפיות של ה-CLI וה-SDK המשיכו לרוץ בכל שלב, ואם פול-ריקווסט גרם לבדיקה נדרשת להיכשל הוא לא אושר.
המעבר ההדרגתי אפשר לפרוס גרסאות שכוללות רכיבים חדשים בשימוש של מוצרי צד ראשון בתוך Microsoft ו-GitHub. בדרך זו זוהו רגרסיות נקודתיות בזמן אמת ותוקנו במהירות, תוך שמירה על ענף ראשי יציב ובר-פריסה בכל שלב.
| פרמטר ארכיטקטוני | זמן ריצה מקורי (TypeScript / Node.js) | זמן ריצה חדש (Rust Native) |
|---|---|---|
| מודל ריצה והפעלה | תהליך רקע נפרד (Subprocess) | טעינה ישירה בזיכרון (In-process FFI) |
| פרוטוקול תקשורת | JSON-RPC מעל stdin/stdout | קריאות פונקציה ישירות דרך C ABI |
| תקורת זיכרון למופע | מינימום 100 מגה-בייט עבור Node.js ו-V8 | מינימלית, ללא תלות במנוע JS חיצוני |
| אינטגרציה בין שפות | עטיפת תהליך עבור כל שפה בנפרד | ספריית ליבה אחת משותפת לכל ה-SDKs |
מה ששכחו לספר בהודעה
למרות ההתלהבות מהמהירות שבה הפרויקט הסתיים, ההודעה של GitHub מעלה שאלות שמובילים טכנולוגיים צריכים לתת עליהן את הדעת. בראש ובראשונה, בפוסט נטען שביצועי המנוע שופרו בסדרי גודל, אך לא הוצגו נתוני בנצ'מרק השוואתיים ומאומתים של גורם עצמאי. כל עוד מדובר בטענה כללית של החברה בלבד, קשה לכמת את השיפור המדויק בזמני התגובה.
בנוסף, הטקסט מציג את ההישגים מבלי לחשוף את היקף המשאבים, עלויות הטוקנים והשימוש ב-API שנדרשו להרצת צי הסוכנים לאורך חודשי העבודה. להריץ סוכנים שמייצרים ובודקים מאות אלפי שורות קוד זה עסק יקר, ועבור חברות שאינן מחזיקות בתשתיות ענן עצמיות, החשבון בסוף החודש עלול להפוך את המהלך כולו ללא כלכלי.
שאלת המפתח שנותרה פתוחה נוגעת לתחזוקה העתידית. Rust היא שפה תובענית וקפדנית במיוחד הדורשת הגדרה מפורשת של זמני חיים (lifetimes) ובעלות על זיכרון, כפי שצוין בדיווח בהקשר של רגרסיות במחזור החיים. כתיבה של 800 אלף שורות קוד בידי סוכנים מעלה סיכון ממשי ליצירת קוד מכני מסורבל, שיהיה קשה לקריאה ולניהול עבור מפתחים אנושיים שיידרשו לחקור באגים מורכבים בעתיד.
האם לשחרר את הסוכנים
אם אתם מנהלים צוות פיתוח בישראל ושוקלים להטיל משימה דומה על הסוכנים שלכם, כדאי לעצור רגע לפני שמקלידים את הפרומפט הראשון. המקרה של GitHub היה מועמד אידיאלי לשכתוב: מנוע תשתיתי בעל ממשקים מוגדרים, אילוץ ביצועים אמיתי בדמות צריכת זיכרון חריגה של תהליכי רקע, דרישה ל-C ABI שישמש שישה SDKs שונים, ומעל לכל, מערך בדיקות קצה-לקצה רחב ועמוק שנבנה לאורך זמן.
עבור אפליקציית ווב שגרתית, שכתוב כזה הוא לרוב מתכון לאסון. סוכני קוד אינם מחליפים תכנון ארכיטקטוני, והם לא יצילו פרויקט שסובל מחוסר בבדיקות או מהגדרות מוצר מעורפלות. מי שינסה להעביר מונולית עסקי ל-Rust רק כי אפשר, יגלה מהר מאוד שהסוכן ייצר לו 800 אלף שורות של חוב טכנולוגי חדש, שאיש בצוות לא יודע לתחזק.
הסוכנים הוכיחו שהם מסוגלים להוציא לפועל מהלכים הנדסיים מורכבים. אבל המקלדת אולי שייכת למכונה, האחריות על הבאגים בייצור נשארה שלכם.
מקורות
- Migrating the GitHub Copilot runtime to Rust, using Copilothttps://github.blog/ai-and-ml/generative-ai/migrating-the-github-copilot-runtime-to-rust-using-copilot/
- developer experience Archives - The GitHub Bloghttps://github.blog/tag/developer-experience
- GitHub Copilot CLIhttps://github.com/features/copilot/cli/
- GitHub Copilothttps://weba.co.il/tools/github-copilot/
- Node.jshttps://weba.co.il/tools/node-js/
הידיעה נכתבה מהמקורות שלמעלה בתאריך הפרסום, וכל טענה בה נבדקה מולם. מצאתם טעות? כתבו.