כך בניתי Agentic SDLC אישי עם הכלים שכבר היו לי

פתחתי כרטיס משימה, סימנתי תיבה אחת, וכעבור כמה דקות קיבלתי הודעה בצ'אט: "הנה התוכנית, לאשר?". אישרתי, המשכתי לעבוד על משהו אחר, ובסוף חיכה לי Pull Request מוכן לסקירה. זה לא קסם - זה Agentic SDLC אישי קטן: תבנית עבודה שאפשר לבנות עם הכלים שכבר יש לכם.

הבעיה: כתיבת הקוד כבר לא צוואר הבקבוק

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

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

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

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

התמונה הגדולה

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

השחקנים (ומה אפשר לשים במקומם)

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

לוח המשימות

כאן חיים הכרטיסים והסטטוסים (לעשות ← בעבודה ← בסקירה ← בוצע). לכל כרטיס יש תיבת סימון "אוטומציה" שאומרת לסוכן "מותר לך לגעת בזה". אני משתמש ב-Notion. חלופות: Jira, Monday, Linear, Trello או GitHub Issues - כל אחד עם API או Webhook יסתדר.

שכבת האוטומציה

זה הדבק שמחבר את הכול: מזהה כרטיס חדש, מפעיל את הסוכן, מקשיב לאירועי GitHub ומעדכן סטטוסים בחזרה. אני משתמש ב-n8n שמתארח על שרת שלי. חלופות: Make, Zapier, Pipedream, Temporal, או פשוט GitHub Actions ו-cron.

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

סוכן הקוד

הכלי שקורא את הכרטיס, כותב תוכנית, ואז ממש כותב את הקוד ופותח PR. אני משתמש ב-Claude Code, שמופעל דרך API בשני מצבים: "תכנון" ו"תיקון". חלופות: כל סוכן קוד מבוסס-LLM. הרעיון לא כבול למודל מסוים.

בוט הסקירה

אחרי שנפתח PR, סוכן שני עובר על ה-diff ומשאיר הערות סקירה, בדיוק כמו מבקר אנושי. אצלי זה GitHub Action שמריץ סקירת AI בכל דחיפה. הסקירה עצמה לא חוסמת מיזוג - מה שחוסם זה הטסטים. חלופות: כל מערכת CI עם שלב סקירת LLM.

שכבת הצ'אט והאישור

כאן אני מקבל התראות, ובעיקר מאשר או דוחה תוכניות בלחיצת כפתור. אני משתמש ב-Slack. חלופות: Teams, Discord, Telegram, או אפילו אימייל.

אחסון ולוח בקרה

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

שלב אחר שלב: המסע של כרטיס אחד

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

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

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

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

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

5. הסוכן בונה. אחרי האישור הוא כותב את הקוד, מריץ lint ו-build עד שהם נקיים, ופותח Pull Request.

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

7. אני סוקר וממזג (נקודת אנוש 2). כשהטסטים ירוקים והסקירה נקייה, אני עובר על ה-PR, ואם הכול טוב - ממזג.

8. סגירת מעגל. המיזוג מעדכן את הכרטיס ל"בוצע", והאתר נפרס אוטומטית.

בקרות ובטיחות: איך זה לא בורח מהשליטה

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

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

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

• תקרת הוצאה יומית. יש מכסה יומית של הפעלות (אצלי 25), עם הערכת עלות של כ-0.3 דולר להפעלה, כדי שלא תהיה הפתעה בחשבון.

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

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

• הטסטים הם השער. אי אפשר למזג בלי שכל בדיקות ה-e2e ירוקות.

לוח הבקרה: לראות הכול במקום אחד

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

מה למדתי

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

• אישור אנושי במקומות הנכונים שווה זהב. שתי לחיצות כפתור נותנות לי את כל השליטה בלי להאט את השאר.

• תקרות ומכסות הן לא מותרות. הן מה שמאפשר לישון בשקט כשסוכן רץ.

• אוטומציות קטנות מנצחות אחת ענקית. ארבעה תהליכים קטנים קל להבין, לתקן ולהרחיב.

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

הכלים שהזכרתי

Notion, n8n, Claude Code, GitHub Actions, Slack, Firestore ו-Next.js. אבל שוב - כל אחד מהם ניתן להחלפה. קחו את הזרימה, והרכיבו אותה מהכלים שלכם.

קריאה נוספת

• Thoughtworks - Preparing your team for the agentic software development life cycle

• Forrester - Agentic Software Development: defining the next phase of AI-driven engineering

• InfoWorld - FinOps for agents: loop limits, tool-call caps, and the unit economics of agentic software