מהו Kiro?
Kiro הוא סביבת קידוד להורדה שנבנתה על ידי Amazon Web Services, שלוקחת את הפיתוח בסיוע בינה מלאכותית לכיוון שרוב הכלים בקטגוריה הזו לא ניסו.
בעוד שרוב כלי הקידוד עם בינה מלאכותית מאפשרים לך להקליד פרומפט ולקבל קוד מיד, Kiro מפעיל קודם תהליך תכנון: הוא קורא את הקשר הפרויקט שלך, כותב מסמך דרישות, יוצר תכנון טכני, מפרק הכול לרשימת משימות ממוספרת, ורק אז מתחיל לכתוב קוד.
Kiro, זמין כ-IDE, כלי שורת פקודה, ממשק אינטרנט (כרגע בגרסת Preview למשתמשים בתשלום), ואפליקציה לנייד (Early Access ב-iOS), ממקם את עצמו ככלי למפתחים שרוצים פלט מובנה וניתן לתחזוקה ולא קוד מהיר שהם יצטרכו לפרק שבוע אחר כך.
למי Kiro מתאים?
- מפתחים שנכוו מקוד שנוצר על ידי בינה מלאכותית ונשבר אחרי יום אחד. תהליך ה-Spec של Kiro כופה תכנון לפני מימוש, כך שהקוד שהוא כותב ניתן למעקב חזרה לדרישות מתועדות, ולא מורכב מניחושים.
- צוותים שעוברים לזרימות עבודה Agentic. Agent Hooks של Kiro מאפשרים לך להפוך משימות חוזרות לאוטומטיות, כמו כתיבת בדיקות או יצירת תיעוד, כשהן מופעלות אוטומטית בכל פעם שקובץ מתאים משתנה, בלי צורך בפרומפט חוזר.
- מפתחי AWS-ecosystem. Kiro בנוי על תשתית AWS, מעבד נתונים בין אזורי AWS בתוך הגאוגרפיה שלך, ומתחבר באופן טבעי לשירותי AWS. אם ה-stack שלך כבר כבד-AWS, Kiro משתלב בלי עומס קונפיגורציה.
- משתמשי VS Code שרוצים בינה מלאכותית שחודרת עמוק יותר מאוטוקומפליט. Kiro IDE בנוי על אותה תשתית כמו VS Code. קיצורי המקשים, ההגדרות והתוספים שלך עוברים במהלך ההטמעה בתוך דקות.
יתרונות וחסרונות של Kiro
- תהליך Spec מתכנן לפני כתיבת כל קוד
- Agent Hooks מבצעים אוטומציה למשימות על אירועי קבצים
- תוספים והגדרות של VS Code מיובאים בצורה חלקה
- מצב Autopilot בונה בלי בקשות אישור מתמידות
- מסמכי Steering נותנים ל-Kiro את ההקשר של הפרויקט שלך
- תומך במספר מודלים מובילים, כולל Opus 4.8
- שילוב MCP server מחבר כלים חיצוניים באופן מקורי
- דורש הורדה; לא נגיש דרך הדפדפן בתוכנית החינמית
- 50 קרדיטים חינמיים נעלמים מהר יותר ממה שנדמה
- פעם אחת נרשם timeout במהלך שלב חידוד הדרישות
פירוט הדירוג
הציונים החזקים ביותר של Kiro הם ב-features and functionality, שבהם תהליך ה-Spec, Agent Hooks והביצוע ב-Autopilot מקדימים כל כלי קידוד עם בינה מלאכותית שסוקר כאן. הוא מאבד גובה בנגישות ובמודל הקרדיטים, ושני אלו דורשים תשומת לב כנה לפני התחייבות לזרימת עבודה.
| Feature | Score (Out of 10) | Why the Score |
|---|---|---|
| קלות שימוש | 7.0 | מוכר לכל משתמש VS Code; דרישת ההורדה והאופי המיועד למפתחים בלבד מוציאים אותו מהישג ידם של משתמשים לא-טכניים |
| Features & Functionality | 9.5 | Spec workflow, agent hooks, autopilot, MCP integration, steering docs: ערכת התכונות המקיפה ביותר מכל כלי קידוד AI שנבדק |
| Design & Customisation | 7.0 | ערכות נושא כהה ובהירה ל-IDE; שליטה חזקה במבנה הקוד שנוצר דרך עריכת spec ומסמכי steering |
| Value for Money | 6.5 | 50 הקרדיטים של התוכנית החינמית ירדו ל-4.28 שנצרכו כבר בשלב התכנון בלבד, לפני שנכתבה אפילו שורת קוד אחת של האפליקציה |
| Performance & Reliability | 7.5 | פלט התכנון היה מפורט וספציפי; timeout אחד מאומת לאחר 7 דקות 24 שניות במהלך חידוד הדרישות |
| Overall | 8.2 | תהליך ה-Spec של Kiro הוא הגישה המובנית ביותר לפיתוח בסיוע בינה מלאכותית שנבדקה עד כה. הציון משקף את ההבדלה האמיתית הזו, שמוגבלת על ידי התוכנית החינמית המצומצמת וכשל האמינות היחיד שתועד במהלך הבדיקה. |
הפיצ’רים של Kiro
- תהליך מונחה Spec: דרישות, עיצוב, משימות, קוד
- Agent Hooks מבצעים אוטומציה למשימות על אירועי קבצים
- מסמכי Steering נותנים ל-agent הקשר פרויקט
- מצב Autopilot מבצע משימות בלי אישור צעד-אחר-צעד
- תמיכה ב-MCP server לשילוב כלים חיצוניים
- ייבוא קונפיגורציית VS Code בפתיחה ראשונה
- תמיכה בריבוי מודלים, כולל Claude Opus 4.8
סקירת Kiro הכנה שלי: מה גיליתי אחרי שבדקתי אותו
רוב בוני האפליקציות עם בינה מלאכותית נופלים לאחת משתי קטגוריות:
- כלים ויזואליים שמייצרים ממשק מתוך תיאור
- וכלי צ’אט שכותבים קוד ישירות בתגובה לפרומפט
Kiro לא מתאים לאף אחת מהן, ולכן סקירה שלו מחייבת גישה אחרת.
Kiro הוא IDE agentic. אינך גורר רכיבים על קנבס, ואינך מקבל תצוגה מקדימה חיה אחרי 30 שניות. מה שאתה מקבל הוא סביבת פיתוח מקומית שמתכננת בנייה לפני תחילתה, מייצרת דרישות, מסמך תכנון ורשימת משימות מובנית, ואז ה-agent עובד דרכן צעד אחר צעד.
האפליקציה שהוא מייצר היא פרויקט אמיתי על המחשב שלך, בקבצים שאתה הבעלים שלהם, תוך שימוש ב-stack שאתה מגדיר.
כדי לבדוק אם התהליך הזה באמת עובד, בניתי פלטפורמת ניהול נכסים מאפס בתוך Kiro.
הפרומפט כלל אימות לנדל”ן ולדיירים, ניהול נכסים ויחידות, מעקב אחר חוזי שכירות, בקשות תחזוקה עם עדכוני סטטוס, שילוב תשלומי Stripe, התראות מייל, ולוח בקרה של משכיר עם דוחות. זהו אותו פרומפט ששימש להערכת Rork, Figma Make, Uizard ו-Retool, מה שמאפשר להשוות איך כל כלי מתמודד עם מורכבות אמיתית במקום עם דוגמה פשוטה.
השאלה שהסקירה הזו ביקשה לענות עליה הייתה ספציפית: האם תהליך ה-Spec first של Kiro מייצר פלט מובנה ותחזיק יותר טוב מכלים שקופצים ישר לקוד?
הנה מה שמצאתי.
להפעיל את Kiro: הורדה, לא לשונית בדפדפן
כל בונה אפליקציות אחר עם בינה מלאכותית שנבדק לצד ההשוואה הזו חי בדפדפן. Kiro לא. כדי להתחיל צריך ללכת ל-kiro.dev, ללחוץ על Downloads, לבחור את מערכת ההפעלה שלך, ולהתקין את האפליקציה על המחשב שלך.

השתמשתי ב-Pop OS, הפצה מבוססת-Debian של Linux, ולכן בחרתי בחבילת Debian (.deb) מתוך התפריט הנפתח. האתר מציע גם חבילת Universal (.tar.gz) עבור הגדרות Linux אחרות. מתקיני Windows ו-macOS זמינים דרך אותו דף הורדות.
מה זה אומר בפועל:
- הסשן הראשון דורש התקנה מקומית, לא לשונית דפדפן
- אין גישה מבוססת אינטרנט בתוכנית החינמית (ממשק האינטרנט זמין רק בתוכניות בתשלום, כרגע ב-Preview)
- למפתחים, זו לא בעיה
- לכל מי שמשווה את Kiro מול בוני אתרים מבוססי דפדפן, יש לקחת בחשבון את זמן ההגדרה הזה
ההתקנה עצמה הייתה פשוטה. לא היו שלבי קונפיגורציה, לא היו תלותים שצריך לפתור ידנית, והאפליקציה נפתחה בצורה נקייה אחרי התקנת החבילה הרגילה.
התחברות מתבצעת בדפדפן שלך, לא בתוך האפליקציה
ברגע ש-IDE נפתח בפעם הראשונה, הוא לא מבקש ממך להתחבר בתוך חלון האפליקציה. הוא מפנה אותך לדף בדפדפן כדי לטפל באימות שם.

מסך ההתחברות מציג ארבע אפשרויות:
| שיטת התחברות | למי היא מתאימה |
|---|---|
| מפתחים עצמאיים ופרילנסרים | |
| GitHub | ההתאמה הטבעית ביותר למפתחים עם חשבונות קיימים |
| AWS Builder ID | מפתחים שכבר נמצאים בתוך האקוסיסטם של AWS |
| Your Organization | צוותי enterprise שמשתמשים ב-SSO |
אפשרות GitHub היא בחירה טובה לקהל היעד. לרוב המפתחים כבר יש חשבון GitHub והם יכולים לאמת בלי ליצור פרטי זיהוי חדשים.
כמה דברים שכדאי לדעת לפני שנרשמים:
- התחברות דרך Google או AWS Builder ID (לא AWS Identity Center) מזכה אותך בקרדיט של $20 שמוחל על השדרוג הראשון שלך לתוכנית בתשלום. זהו יתרון חד-פעמי שכדאי להכיר לפני שבוחרים שיטת התחברות.
- התחברות דרך “Your Organization” עוברת דרך enterprise SSO ומהווה את נקודת הכניסה לצוותים שצריכים ניהול זהויות מרכזי.
- באמצעות ההתחברות, אתה מסכים ל-AWS Customer Agreement, Service Terms, Privacy Notice, ול-AWS Intellectual Property License. מכיוון ש-Kiro הוא מוצר של AWS, הנתונים שלך מעובדים בין אזורי AWS בתוך הגאוגרפיה שלך.
תהליך ההטמעה: שלושה שלבי הגדרה שלוקחים פחות משתי דקות
אחרי ההתחברות, Kiro מריץ רצף הגדרה קצר לפני פתיחת ה-IDE הראשי. השלבים הם:
שלב 1: בחר את הערכת הנושא שלך. Kiro Dark או Kiro Light. שניהם מציגים תצוגה מקדימה חיה של הדגשת תחביר קוד לפני האישור.

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

שלב 3: ייבוא מ-VS Code. Kiro מושך את התוספים הקיימים שלך של VS Code (כל מה שזמין ב-Open VSX), ההגדרות וקיצורי המקלדת. התוספים נטענים ברקע בזמן שההטמעה נמשכת, כך שאין המתנה במסך טעינה.

הייבוא מ-VS Code הוא החלק השימושי ביותר מבחינה מעשית ברצף הזה. אם השקעת שנים בהתאמה אישית של סביבת VS Code, המעבר לא מחייב להתחיל מאפס. הייבוא עבד בצורה חלקה בסשן שלי.
מה שההטמעה לא כוללת הוא כל היכרות עם הפיצ’רים המרכזיים של Kiro. לא מסבירים לך מה הם Specs, Agent Hooks או Steering Documents. אתה מגיע למסך הראשי ומגלה את זה בעצמך. זה סביר עבור קהל של מפתחים מנוסים, אבל זה אומר שהסשן הראשון שלך עם הפיצ’רים הייחודיים ביותר של הכלי כרוך בחקירה עצמאית.
בתוך ה-IDE: ארבעת הפאנלים שהופכים את Kiro לשונה
ה-IDE של Kiro נראה כמו VS Code כי הוא בנוי על אותה תשתית. סייר הקבצים, טאבי העריכה, הטרמינל, שורת החיפוש וסרגל התפריטים כולם מתנהגים בדיוק כמצופה.

מה שמבדיל את Kiro מהתקנה רגילה של VS Code הוא הפאנל השמאלי הייעודי, שמכיל ארבעה מקטעים שאינם קיימים באף תוסף ל-VS Code:
| חלק בפאנל | מה הוא עושה |
|---|---|
| Specs | יצירה וניהול של מסמכי מפרט (דרישות, תכנון, משימות) עבור בניות מורכבות |
| Agent Hooks | הגדרת משימות אוטומטיות שמופעלות על אירועי מערכת קבצים |
| Agent Steering and Skills | אחסון מסמכי הנחיה שמעצב את ההתנהגות של ה-agent בכל הסשנים |
| MCP Servers | חיבור כלים ומקורות נתונים חיצוניים ל-agent של Kiro |
הצד הימני של ה-IDE מארח את פאנל הצ’אט. כאן אתה מתקשר עם Kiro וכאן אתה רואה את צריכת הקרדיטים בזמן אמת. “Est.
Credits Used: 0.1, Elapsed time: 57s” מתעדכן אחרי כל פעולת agent, מה שאומר שתמיד אתה יודע מה העלות של כל משימה.
בתחתית סרגל הקלט של הצ’אט, שני בקרים קובעים איך Kiro מתנהג בכל משימה:
- בורר המודלים: בחר Auto (Kiro בוחר את המודל החסכוני ביותר עבור כל בקשה), או בחר מודל מסוים כמו Claude Sonnet 4.6 או Claude Opus 4.8.
- מתג Autopilot: כש-Autopilot פעיל, Kiro כותב ועורך קבצים בלי לחכות לאישור שלך בכל שלב. כשהוא כבוי, Kiro עוצר לפני כל פקודה ושואל אותך Trust, Reject, או Run it manually.

עבור בדיקת פלטפורמת ניהול הנכסים, השארתי את Autopilot פעיל במהלך התכנון והשתמשתי באישור ידני במהלך ביצוע המשימות כדי להעריך כל שלב בנפרד.
Verdict: פריסת ה-IDE נוחה בתוך דקות לכל משתמש VS Code. ארבעת המקטעים בפאנל השמאלי הם המקום שבו הערך של Kiro נמצא, והבנה של כל אחד מהם לפני הסשן הראשון שלך קובעת כמה תקבל מהכלי.
מסמכי Steering: לתת ל-Kiro הקשר לפני הפרומפט הראשון שלך
הדבר הראשון שצריך לעשות בתוך פרויקט חדש ב-Kiro הוא לא להתחיל בנייה. הוא ליצור מסמכי Steering.
לחצתי על “Generate Steering Docs” בפאנל של Kiro לפני ששלחתי פרומפט כלשהו. Kiro סרק את תיקיית הפרויקט הריקה ויצר שלושה קובצי markdown בתוך .kiro/steering/:
| קובץ | תוכן |
|---|---|
| product.md | שם המוצר, תיאור, מושגי ליבה בתחום, ויעדים מרכזיים |
| structure.md | מבנה תיקיות צפוי ועקרונות ארגון קבצים |
| tech.md | stack טכנולוגי צפוי, פקודות נפוצות, ועקרונות קידוד |

עבור פרויקט ריק לגמרי, Kiro הסיק ברירות מחדל הגיוניות: React עם TypeScript, Next.js API routes, PostgreSQL, Prisma, Tailwind CSS, ואימות מבוסס JWT. הוא סימן גם את tech.md וגם את structure.md כמצייני מקום שיש לעדכן ברגע שה-stack האמיתי יאומת באמצעות scaffolding.
זה חשוב כי כל פעולה הבאה של ה-agent קוראת את הקבצים האלה לפני שהיא עושה משהו. ברגע שמבצעים scaffolding לפרויקט וה-stack האמיתי מאומת, עדכון tech.md גורם ל-Kiro להחיל את העקרונות האלה אוטומטית על כל המשימות הבאות.
אפשר גם להוסיף קבצי Steering משלך עבור סטנדרטים של עיצוב API, מוסכמות שמות, כללי deployment, או כל מגבלה אחרת שאתה רוצה שה-agent יתייחס אליה כקבועה.
Vibe Mode מול Spec Mode: ההחלטה שמעצבבת את כל הבנייה
כשפותחים את הצ’אט לבנייה חדשה, Kiro מציג לך שני מצבים לפני שאתה מקליד משהו:
Vibe mode מאפשר לך לשוחח קודם ולבנות תוך כדי. בלי מסמכי תכנון, בלי פלט מובנה. הכי מתאים לניסויים מהירים, חקירה בשלבים מוקדמים, או משימות שבהן הדרישות עדיין מתגבשות.
Spec mode מריץ רצף תכנון לפני כתיבת קוד כלשהו. Kiro מייצר דרישות, מסמך תכנון טכני, ורשימת משימות. רק אחרי ששלושתם נבדקו ואושרו הוא מתחיל לכתוב קוד. הכי מתאים לעבודה ברמת production שבה תחזוקתיות חשובה.

בחרתי ב-Spec mode עבור פלטפורמת ניהול הנכסים. לאחר ששלחתי את הפרומפט, Kiro שאל שתי שאלות המשך לפני שיצר משהו:
- “What do you want to start with?” (Requirements, מסומן כמומלץ, או Technical Design)
- “Is this a new feature or a bugfix?” (Build a Feature, מומלץ, או Fix a Bug)

השאלות האלה קובעות את המבנה של כל מה שבא אחריהן. בחירה ב-“Requirements” פירושה ש-Kiro כותב סיפורי משתמש וקריטריוני קבלה לפני שנוגעים בארכיטקטורה.
הרצף הזה יוצר ארטיפקטי תכנון שונים מהיסוד מאשר להתחיל בתכנון טכני ולהסיק ממנו את הדרישות אחר כך.
תהליך ה-Spec: דרישות, תכנון, ורשימת משימות לפני כל קוד
זהו החלק שהופך את Kiro לשווה הערכה רצינית.
לאחר שבחרתי “Requirements” ו-“Build a Feature,” Kiro יצר קובץ requirements.md בתוך .kiro/specs/property-management-platform/. המסמך הופיע מיד בעורך. יכולתי לקרוא אותו בזמן שהוא נכתב. התוכן כלל:
המילון: 12 מונחי תחום שהוגדרו במדויק, כולל Auth_Service, Property_Service, Lease_Service, Payment_Service, Maintenance_Service, Notification_Service, ו-Dashboard_Service, כאשר כל אחד מהם ממופה לתת-מערכת מתוכננת ספציפית.
תיאור הפלטפורמה: גם התפקידים Landlord ו-Tenant תועדו, יחד עם ה-stack הטכנולוגי שאושר: Next.js, TypeScript, PostgreSQL, Prisma, Tailwind CSS, Stripe, ו-Docker.

לאחר יצירת המסמך הראשוני, Kiro הריץ שלב חידוד אוטומטי. הוא ניתח את כל 12 הדרישות, שלח תתי-agent-ים לחידוד בפרלל על כל אחת מהן, ועדכן את requirements.md עם קריטריוני קבלה מלאים לכל דרישה. הפאנל עקב אחרי זה בזמן אמת: “Refining requirements 12/12.”
ברגע שהדרישות הושלמו, לחצתי על “Continue” ובחרתי “Generate Design and Tasks.” Kiro ייצר יחד את design.md ו-tasks.md. פירוט המשימות היה הפלט הבולט של הסשן:

11 קבוצות משימות, 43 תתי-משימות, לפי סדר המימוש:
- הקמת הפרויקט ותשתית
- אימות (JWT, blacklist, middleware, עמודים)
- ניהול נכסים ויחידות
- ניהול דיירים
- ניהול חוזי שכירות, העלאת מסמכים, ו-cron job
- בקשות תחזוקה
- תשלומי Stripe ו-webhook
- הודעות מייל
- לוח בקרה של המשכיר ודיווח
- רכיבי UI משותפים ו-layouts
- הקשחת API (rate limiting, CORS, health check, environment validation)
כל תת-משימה כללה פקודות מדויקות, נתיבי קבצים, והפניות ניתנות למעקב לדרישות. משימה 1.1, למשל, הפנתה ישירות ל-Requirements R12 (Docker) ול-R10 (REST API). הקשר בין התכנון לביצוע היה מפורש וניתן לאימות לכל אורך הדרך.

Rork, בהשוואה, מדלג על כל השלב הזה ועובר ישירות ליצירת ממשק משתמש מתוך הפרומפט. ההבדל באיכות הפלט נראה לעין: רשימת המשימות של Kiro ספציפית מספיק כדי למסור אותה למפתח אנושי, והוא יבין בדיוק מה צריך להיבנות ובאיזה סדר.
ביצוע משימות: מה Kiro באמת בנה
לאחר שאישרתי את רשימת המשימות, לחצתי על “Start task” על Task 1.1: Initialize Next.js 14 project with TypeScript, Tailwind CSS, and ESLint.

Kiro עדכן את מצב המשימה ל-“in progress” ב-tasks.md, ואז העביר את הביצוע לתת-ה-agent spec-task-execution. ה-agent בדק תחילה את סביבת העבודה, אימת שרק תיקיית .kiro spec קיימת בלי פרויקט Next.js עדיין, והמשיך לבצע scaffolding לפרויקט.

במחזור הביצוע הראשון, עץ הקבצים התמלא ב:
- package.json עם Next.js, React 19.2.4, TypeScript, ותלויות Tailwind
- tsconfig.json, eslint.config.mjs, next.config.ts
- מבנה תיקיות src/ ו-public/
- AGENTS.md ו-CLAUDE.md, שנוצרו על ידי Kiro כקובצי הנחיה ל-agent עבור הפרויקט
- README.md

הקובץ CLAUDE.md ראוי לציון: Kiro הוא מוצר של AWS, אבל הוא פועל על מודלי Claude של Anthropic מתחת למכסה המנוע. הקובץ CLAUDE.md הוא הדרך שבה agents המבוססים על Claude מאחסנים הנחיה התנהגותית ספציפית לפרויקט. הנוכחות שלו בסקאלפ שנוצר משקפת את המודל הבסיסי, גם בתוך ההקשר של תשתית AWS.

בראש תצוגת רשימת המשימות, כפתור “Run all tasks” היה מאפשר ל-Kiro לבצע את כל 43 תתי-המשימות ברצף עם Autopilot פעיל.
הרצתי משימות אחת-אחת כדי להעריך כל שלב. עבור פרויקט אמיתי שבו אתה בטוח בתוכנית שאושרה, הרצה אוטומטית של כל המשימות ובדיקה של הפלט בסוף כל קבוצה היא זרימת עבודה סבירה וחסכונית בזמן.

כל קובץ ש-Kiro יצר במהלך הביצוע היה קובץ אמיתי בספריית הפרויקט המקומית שלי, בבעלותי וניתן לעריכה מהרגע הראשון. זהו הבדל משמעותי לעומת בוני מבוססי דפדפן כמו Figma Make או Uizard, שבהם הפלט הוא או נכס עיצובי או אפליקציה מתארחת שאין לך שליטה מקומית עליה.
ה-timeout בדקה השביעית: מה זה אומר על האמינות
אני רוצה להיות ישיר בעניין הזה כי זה קרה במהלך החלק החשוב ביותר של הבדיקה.
אחרי ש-Kiro חידד את כל 12 הדרישות ואישר את העריכות ל-requirements.md, ה-agent עבר timeout. הודעת השגיאה בפאנל הצ’אט הייתה:
“The request timed out. Please try again. (Conversation ID: 29d25548-c3ce-414c-8f57-702124c7fec6). Elapsed time: 7m 24s.”

זה קרה במעבר בין שלב הדרישות לבין שלב יצירת התכנון. העבודה שהושלמה לפני ה-timeout נשמרה. שום דרישה לא אבדה.
אחרי שאישרתי את השגיאה, לחצתי על “Continue” ובחרתי “Generate Design and Tasks.” Kiro התאושש בלי לחזור על שלב הדרישות, יצר את שני המסמכים בצורה חלקה, והמשיך כרגיל לשאר הסשן.
הקשר שחשוב כאן:
- ה-timeout קרה בפרומפט מורכב שכיסה 12 תחומי דרישות נפרדים עם חידוד מקביל שרץ.
- שלבים פשוטים יותר כנראה לא ייקחו כל כך הרבה זמן.
- Kiro נמצא כרגע ב-Preview, ואמינות בקצה הקיצון של משימות מורכבות היא מאפיין מוכר של כלים בשלב כזה.
- ההתאוששות הייתה נקייה. מנגנון checkpoint שמר את כל העבודה שהושלמה והשלב הבא רץ מיד.
עם זאת, שבע דקות לתוך הפיצ’ר המבדיל ביותר של הכלי, להיתקל ב-timeout זו חוויית כשל אמיתית. אם אתה עובד מול דדליין, כלי שעוצר ודורש retry ידני הוא מתסכל גם כשההתאוששות חלקה.
Agent Hooks: אוטומציה שרצה בלי שהתבקשה
Agent Hooks לא מופיעים באף כלי קידוד AI אחר שנבדק לצד ההשוואה הזו, והם ראויים לתשומת לב מיוחדת כי הם מייצגים דרך חשיבה אחרת על סיוע AI.
Hook הוא משימה שרצה אוטומטית כאשר מתרחש אירוע במערכת הקבצים. אתה מתאר את ההתנהגות בשפה טבעית, Kiro ממיר אותה למאזין אירועים, ומאותו רגע ההתנהגות רצה ברקע בכל פעם שתנאי ההפעלה מתקיים. בלי פקודה להריץ, בלי תזכורת להגדיר.

דוגמאות למה Hooks יכולים לעשות:
- ב-on file save: ליצור בדיקות בסיסיות לכל רכיב שאין לו כבר קובץ בדיקות
- ב-on file save: להריץ ניקוי קוד או בדיקות formatting
- ב-on file creation: ליצור תיעוד לפונקציות חדשות אוטומטית
- ב-on string constant changes: לעדכן קובצי לוקליזציה בלי פעולה ידנית

ה-hook נשמר בתוך .kiro/hooks/ כקובץ ניתן לעריכה. אם אתה רוצה להתאים את תנאי ההפעלה או את ההנחיה, אתה עורך את הקובץ ישירות. הקונפיגורציה שקופה וניתנת לניהול גרסאות לצד שאר הפרויקט שלך.
דוגמת ה-test-on-save היא המעשית ביותר: מפתחים דוחים באופן קבוע כתיבת בדיקות עד סוף הספרינט, ו-hook שמוסיף בשקט בדיקות בסיסיות בכל פעם שרכיב נשמר מסיר את ההחלטה הזו לחלוטין. הבדיקות מופיעות בעץ הקבצים אחרי השמירה הבאה בלי שום פעולה מצדך.
צריכת קרדיטים: מה באמת נותנת התוכנית החינמית
מודל הקרדיטים הוא התחום שבו Kiro דורש את הקריאה הכי זהירה לפני התחייבות לזרימת עבודה.
התוכנית החינמית נותנת לך 50 קרדיטים. הנה מה שסשן spec אחד של פלטפורמת ניהול נכסים צרך: 4.28 קרדיטים עבור התכנון בלבד, כולל דרישות, מסמך התכנון, ורשימת 43 המשימות, לפני שנכתבה אפילו שורת קוד אחת של האפליקציה.
בקצב צריכה כזה:
| Scenario | Estimated Free Tier Coverage |
|---|---|
| סשנים של תכנון בלבד (ללא ביצוע קוד) | כ-11 סשנים |
| תכנון יחד עם ביצוע חלקי של משימות | 3 עד 5 סשנים |
| Spec-to-execution מלא בפרויקט מורכב | פרויקט מלא אחד לכל היותר |
מכניקות חשובות שכדאי להבין לפני שנרשמים:
- קרדיטים לא עוברים לחודש הבא. כל מה שנשאר בסוף חודש החיוב נעלם.
- חיוב overage כבוי כברירת מחדל בכל התוכניות בתשלום. צריך להפעיל אותו ב-Settings לפני שמגיעים לתקרה, אחרת Kiro מפסיק לעבוד באמצע משימה.
- בחירת המודל משפיעה על קצב הצריכה. הרצת אותה משימה דרך Claude Sonnet 4.6 עולה פי 1.3 יותר קרדיטים מאשר הרצה ב-Auto mode. מודלי Opus עולים עוד יותר.
- משתמשי התוכנית החינמית מקבלים Claude Sonnet 4.5 וסט של מודלים פתוחים כולל Qwen3 Coder Next, DeepSeek v3.2, ו-MiniMax 2.1. משתמשי תוכניות בתשלום מקבלים Claude Sonnet 4.6, Claude Opus 4.6, ו-Claude Opus 4.8.
- צריכת הקרדיטים גלויה בפאנל הצ’אט אחרי כל פעולת agent ומתעדכנת בלוח המנויים כל חמש דקות.
מעקב הקרדיטים בזמן אמת (“Est. Credits Used: 0.1, Elapsed time: 57s” אחרי כל משימה) הוא פיצ’ר שקיפות שאין כרגע לכלי דומה אחר. אתה יודע בדיוק מה עולה כל משימה כשהיא רצה, וזה משפיע על הבחירה בין Auto mode למודל מסוים עבור משימה נתונה.
תמחור ותוכניות של Kiro
Kiro פועל על מודל מבוסס קרדיטים עם חמישה מסלולים, מתוכנית חינמית עם הקצאה חודשית קבועה ועד תוכנית בעלת קיבולת גבוהה המיועדת לשימוש מקצועי יומיומי.
כל התוכניות בתשלום כוללות גישה למודלים פרימיום, אפשרות להפעיל overage בתשלום לפי שימוש, ואת כל ערכת הפיצ’רים של Kiro, כולל specs, hooks, autopilot, ו-CLI access.
מה חשוב לדעת לפני שבוחרים תוכנית:
- התוכנית החינמית מספקת הקצאת קרדיטים חודשית קבועה ללא צורך בכרטיס אשראי. היא לא פגה, אבל סשן spec מורכב אחד ישאיר חותם מורגש עליה.
- בפעם הראשונה שמשדרגים מחינם לכל תוכנית בתשלום באמצעות Google או AWS Builder ID (לא AWS Identity Center), מקבלים $20 קרדיט שמוחל על עלות המנוי. ההטבה הזו חלה פעם אחת.
- Kiro מחייב ב-1 לחודש הקלנדרי. שדרוג באמצע החודש אומר לשלם תשלום פרופורציונלי אבל לקבל מיד גישה למכסת הקרדיטים המלאה של התוכנית החדשה שלך.
- חיוב overage זמין בכל התוכניות בתשלום לפי תעריף קבוע לכל קרדיט נוסף, אבל הוא כבוי כברירת מחדל. צריך להפעיל אותו ב-Settings לפני שמגיעים לתקרה, אחרת Kiro משהה את העבודה שלך כשהקרדיטים נגמרים.
- קרדיטים שלא נוצלו לא עוברים לחודש הבא.
- כל מפתח צריך מנוי משלו. כרגע אין אפשרות לשיתוף seat צוותי. פיצ’רים של חיוב צוותי מסומנים כ-coming soon.
- המדיניות הסטנדרטית של Kiro היא ללא החזר כספי על ביטול באמצע החודש. הגישה נמשכת עד סוף מחזור החיוב. החזרים נשקלים לפי מקרה רק עבור שגיאות חיוב.
- כרטיסי אשראי הם אמצעי התשלום היחיד שמתקבל.
- תמחור GovCloud (US) גבוה בכ-20% מהתמחור הסטנדרטי, והתוכנית החינמית אינה זמינה בסביבה הזו. גישה ל-GovCloud דורשת תוכנית בתשלום ואימות enterprise דרך AWS IAM Identity Center.
- ממשק האינטרנט נמצא כרגע ב-Preview וזמין למשתמשים בתשלום בלבד. קרדיטים נצרכים באותו קצב בין אם עובדים ב-IDE, ב-CLI, או באינטרנט.
איזו תוכנית מתאימה לאיזה סוג משתמש: התוכנית החינמית מספיקה להרצת הערכה אמיתית. לפיתוח פעיל על פרויקטים אמיתיים, תוכנית בתשלום היא הכרחית כדי לא להיגמר באמצע סשן. התוכניות ברמה הגבוהה יותר מתאימות למפתחים שמריצים כמה סשני Spec מלאים בשבוע או עובדים על כמה פרויקטים מורכבים במקביל.
חלופות ל-Kiro
המתחרה הישיר ביותר ל-Kiro הוא Cursor, עורך הקוד המופעל על ידי בינה מלאכותית שגם הוא בנוי על יסודות VS Code ומיועד למפתחים שרוצים בינה מלאכותית משולבת עמוק בסביבת הפיתוח שלהם.
ההבדל המרכזי הוא פילוסופיית הזרימה. Cursor בנוי להאיץ את מה שאתה כבר עושה: אתה כותב קוד, ו-Cursor מסייע.
Kiro בנוי להשתלט קודם על שלב התכנון: ה-agent מגדיר מה צריך להיבנות לפני שהוא כותב משהו מזה. אם התסכול העיקרי שלך הוא מעבר הקשר איטי בין צ’אט AI לעורך שלך, Cursor פותר זאת בצורה ישירה יותר. אם התסכול שלך הוא קוד שנוצר על ידי AI שחסר מבנה או קשה לתחזוקה, תהליך ה-Spec של Kiro הוא התשובה הרלוונטית יותר.
| Feature | Kiro | Cursor |
|---|---|---|
| קלות שימוש | מוכר למשתמשי VS Code; תהליך ה-Spec מוסיף עקומת למידה | מוכר למשתמשי VS Code; פחות חיכוך בהטמעה |
| Best For | בניות מובנות ומונחות Spec עבור פרויקטים ב-production | עריכת קוד מהירה ומשימות agent בתוך בסיסי קוד קיימים |
| Backend and Data | בונה פרויקטים מקומיים אמיתיים עם שליטה מלאה ב-stack | עורך ומרחיב קבצי פרויקט קיימים עם שליטה מלאה ב-stack |
| Design Flexibility | אין בונה ויזואלי; מפיק קוד אמיתי שבבעלותך המקומית | אין בונה ויזואלי; מפיק קוד אמיתי שבבעלותך המקומית |
| Pricing Model | מבוסס קרדיטים; 50 קרדיטים חינמיים; כל השימוש נמשך מתוך הקצאת קרדיטים חודשית | מבוסס קרדיטים מאז יוני 2025; Auto mode הוא ללא הגבלה; בחירת מודלים פרימיום נמשכת ממאגר קרדיטים חודשי |
פסק דין סופי: האם Kiro שווה את זה?
Kiro בולט בכך שהוא שם את התכנון לפני הקידוד. תהליך המפרט שלו, מסמכי ה-Steering, ופירוט המשימות מייצרים בסיס קוד מובנה וניתן לתחזוקה יותר מכלי AI שקופצים ישר למימוש. פיצ’ר Agent Hooks הוא עוד נקודת שיא, שמאפשרת אוטומציות של זרימת עבודה שממשיכות לרוץ מעבר לפרומפט בודד.
המחירים והעקומת למידה הם פשרות. התוכנית החינמית מוגבלת מדי לפרויקטים גדולים, ומפתחים צריכים להרגיש נוח לעבוד בתוך IDE. במהלך הבדיקה גם נתקלתי ב-timeout, למרות ש-Kiro התאושש בלי לאבד התקדמות.
אם אתה מפתח תוכנה ב-production, Kiro הוא אחד מכלי הקוד עם בינה מלאכותית החזקים ביותר שיש כיום. אם אתה מחפש בונה אפליקציות no-code פשוט, לעומת זאת, הוא לא מתאים.

