Discover our first impressions of Kiro, AWS's new agentic IDE that makes it easier for developers to go from prototype to production.
Explore how AWS S3 Vector Store is a major turning point in large-scale AI infrastructure and why a hybrid approach is essential for building scalable, cost-effective GenAI applications.
Explore what an AWS GenAI Competency means, how it can help you evaluate potential partners, and what to look for as you navigate the GenAI landscape.
Learn how to use Amazon Bedrock to build AI applications that will transform your proprietary documents, from technical manuals to internal policies, into a secure and accurate knowledge assistant.
Leveraging our accelerators and technical experience
Browse GenAI Offerings
Guille Ojeda is a Software Architect at Caylent and a content creator. He has published 2 books, over 100 blogs, and writes a free newsletter called Simple AWS, with over 45,000 subscribers. Guille has been a developer, tech lead, cloud engineer, cloud architect, and AWS Authorized Instructor and has worked with startups, SMBs and big corporations. Now, Guille is focused on sharing that experience with others.
View Guille's articlesTools like GitHub Copilot and Cursor have made developers extraordinarily productive at generating code, but they've also created a new class of technical debt: undocumented, AI-generated software that works brilliantly until someone needs to maintain it. AWS's new Kiro IDE tackles this problem head-on with what they call "spec-driven development": a structured approach that forces you to think before you code.
After testing Kiro for a few weeks (as AWS Premier Partners, we at Caylent get some benefits), I can tell you it's not just another AI coding assistant. It's AWS understanding that software development isn't about faster code generation, but about generating better, more maintainable code from the start.
You know the feeling. You fire up ChatGPT or Cursor, describe what you want to build, and watch as beautiful, functional code materializes on your screen. The dopamine hit is incredible (trust me, we've all been there). Within minutes, you have a working authentication system, a REST API, or a React component that handles edge cases you hadn't even thought of.
But then reality hits. Three months later, when you need to modify that AI-generated authentication flow to support single sign-on, you stare at the code like an archaeologist examining ancient hieroglyphs. There's no documentation explaining why certain decisions were made. The variable names make sense to an AI but not to humans. The business logic is scattered across files in ways that seemed clever at the time but now feel arbitrary.
This is the result of what the industry calls "vibe coding": the practice of generating code based on feeling and intuition rather than structured planning. It's fast, it's fun, and it's creating maintenance nightmares across the industry. That's where Kiro is different: its central premise is that the solution isn't to abandon AI assistance, but to add structure to the process.
Kiro is an agentic IDE built on the open-source Code OSS foundation (the same base that powers Visual Studio Code). It feels immediately familiar to developers already comfortable with VS Code, while adding AI capabilities that go far beyond code completion.
What sets Kiro apart from competitors like Cursor or GitHub Copilot isn't its model choice (it uses Claude 4 Sonnet), but its architectural philosophy. While Cursor excels at project-wide context awareness and Copilot focuses on inline assistance, Kiro positions itself as an autonomous project lead. It doesn't just help you write code; it helps you plan, document, and structure entire features before a single line is written.
The heart of Kiro's approach is the Kiro Specs: a workflow that transforms high-level prompts into formal specifications before any code generation occurs. Instead of going directly from idea to implementation, you're guided through a three-phase process: Requirements, Design, and Tasks.
When you describe a feature to Kiro, it doesn't immediately start generating code. Instead, it creates three structured documents:
Make sense so far? The brilliance of this approach becomes apparent when you consider the enterprise development lifecycle. These specifications aren't static documents that get created once and forgotten. They're living artifacts that evolve with your codebase. Update the code, and the specs refresh to stay in sync. Modify the specs, and the task list regenerates to reflect new requirements.
This solves one of the biggest problems with AI-generated code: institutional memory. When a developer leaves a project, their "vibe" leaves with them, but the spec remains. New team members can understand not just what the code does, but why it was built that way and how it fits into the broader system architecture.
Let's say you want to implement a user authentication system with email verification, password reset, and role-based access control. This is exactly the kind of feature that's easy to "vibe code" but becomes a maintenance nightmare without proper documentation.
You open the chat panel, select "Spec" mode, and describe your feature in natural language. Then, rather than jumping into implementation, Kiro will probe for clarification on edge cases, security requirements, and integration points with existing systems.
The requirements.md file that emerges captures not just the happy path scenarios ("As a user, I want to reset my password so that I can regain access to my account"), but also edge cases like handling multiple reset requests, expired tokens, and rate limiting to prevent abuse. This is the kind of thorough requirement gathering that separates experienced engineers from junior developers, and Kiro can systematize it into a repeatable process.
For the design.md file, Kiro will generate detailed TypeScript interfaces, outline the database schema changes required, and define the API endpoints with proper error response structures. More importantly, it will explain the reasoning behind key decisions: why JWT tokens were chosen over session-based authentication, how the password reset flow balances security with user experience, and where the implementation integrates with existing authorization middleware.
The tasks.md file is where the work is broken down into discrete tasks, properly sequenced based on dependencies. Unit tests will be defined for each service method, loading states and error handling will be explicitly called out for the frontend components, and every decision will be documented.
Keep in mind that this process adds overhead to initial development. The value of this is realized on complex features where the upfront planning prevents costly refactoring later. And if you think about it, this is exactly what you do (or should be doing) for any complex feature.
Beyond the spec-driven workflow, Kiro introduces "Agent Hooks", an event-driven automation framework that monitors your filesystem for changes and triggers AI actions in response. Think of it as Git hooks, but powered by an AI agent that can understand context and make intelligent decisions.
I can set up a hook to automatically update the project's README.md file whenever I modify API endpoints, and the hook will monitor changes to files matching a pattern like "src/api/**/*.ts" and instruct Kiro to "analyze the updated API endpoints and refresh the API documentation section of the README with current endpoint signatures and descriptions."
Or you could monitor the entire codebase for potential security issues before commits. When triggered manually (hooks can also fire on command), it would scan for hardcoded credentials, SQL injection vulnerabilities, and common security anti-patterns.
The real power of hooks becomes apparent when you consider team-wide standards enforcement. It's governance through automation, removing the human element from routine quality checks.
Important: hooks are only as good as the instructions you provide. Vague or ambiguous instructions lead to inconsistent behavior (you know how it is with AI). The system works best when you provide specific, actionable guidance that leaves little room for interpretation.
Perhaps the most enterprise-focused feature in Kiro is "Agent Steering": a system for providing persistent project knowledge through markdown files stored in the .kiro/steering/ directory. This addresses a fundamental problem with AI coding assistants: they lack institutional memory about your specific project's conventions, architectural decisions, and business context.
When you run Kiro's "Setup Steering for Project" command, it creates three foundational files. The product.md file captures your product's purpose, target users, and key features, essentially the business context that helps Kiro understand why certain technical decisions matter. The tech.md file documents your technology stack and technical constraints. The structure.md file outlines file organization, naming conventions, and architectural patterns.
You can also write custom steering files tailored to your project's needs, such as api-standards.md file that defines your REST conventions, a testing.md file to document your testing approach, or a security.md file with security requirements.
These steering files support three inclusion modes. Files marked with "inclusion: always" are included in every interaction, perfect for fundamental standards that should influence all code generation. Files with "inclusion: fileMatch" are loaded only when working with files that match specific patterns. Files with "inclusion: manual" are available on-demand when you reference them explicitly in chat.
MCP allows Kiro to securely connect to external data sources and specialized tools without exposing sensitive information. The most immediately useful MCP integration is the AWS Documentation server, which provides Kiro with access to current AWS service documentation, API references, and best practices. Instead of relying on training data that might be outdated, Kiro can query live and up to date AWS documentation.
More significantly for enterprises, MCP enables integration with private knowledge bases, internal APIs, and proprietary documentation systems. You can configure Kiro to access your company's internal wiki, coding standards repositories, or architecture decision records without sending that sensitive information to external AI services. The MCP server acts as a secure intermediary, processing queries locally and providing only relevant, sanitized responses to the AI model.
Kiro is currently free during its public preview phase, but AWS has announced a three-tier pricing model for general availability. The free tier will include 50 agent interactions per user per month, enough for light experimentation but not serious development work. The Pro tier at $19 per user per month provides 1,000 agent interactions, while the Pro+ tier at $39 per month offers 3,000 interactions.
Performance-wise, Kiro feels responsive for most operations. Spec generation typically completes in 30-45 seconds for moderate complexity features, while agent hook execution ranges from 2-5 seconds for simple tasks to 2+ minutes for comprehensive code analysis.
Teams focused on rapid prototyping or early-stage product development might find the spec-driven approach too structured and time-consuming. If you're building quick proof-of-concepts or need to iterate rapidly on uncertain requirements, Cursor's more conversational approach or Copilot's lightweight assistance might serve you better.
Kiro also requires a mindset shift that not all developers will embrace (though I would argue that every developer should, even if not with Kiro). Engineers accustomed to diving directly into code implementation might initially resist the structured planning phase. This works great for teams that already value documentation and architectural planning, but could feel constraining for developers who prefer exploratory coding approaches.
Kiro is particularly suitable for enterprise teams that prioritize maintainability and documentation over raw development speed. If your organization struggles with technical debt from AI-generated code, or if you need to ensure that AI assistance aligns with established architectural patterns, Kiro's spec-driven approach offers genuine value.
The migration path from existing tools is straightforward thanks to the VS Code foundation. Extensions, themes, and keyboard shortcuts transfer seamlessly, reducing the friction of evaluation and adoption. However, teams would need to invest time in creating steering files and configuring hooks to realize Kiro's full potential. I'd suggest you plan for 2-3 weeks of setup and team training to see meaningful productivity gains.
Looking ahead, Kiro represents AWS's bet that the future of AI-assisted development lies not in maximizing code generation speed, but in systematizing the entire development process. The spec-driven approach forces developers to think more deliberately about requirements and architecture, potentially producing more maintainable software even if the initial development takes longer.
For organizations that have been burned by AI-generated technical debt (or for those who have been accumulating technical debt but haven't realized it yet), Kiro's structured approach offers a compelling alternative. For teams that thrive on rapid iteration and creative exploration, the additional process overhead might feel constraining.
Caylent Catalysts™
Accelerate your generative AI initiatives with ideation sessions for use case prioritization, foundation model selection, and an assessment of your data landscape and organizational readiness.
Caylent Catalysts™
Accelerate investment and mitigate risk when developing generative AI solutions.
Guille Ojeda