Kiro is an agentic IDE in preview that promises to bridge the gap between prototype and production through spec-driven development, agent hooks, and natural language coding assistance. What caught my attention wasn’t just another AI coding assistant, but Kiro’s unique approach to structured development workflows that prioritize planning over improvisation.
Two Paths to AI-Assisted Development
Kiro offers two distinct development approaches vibe vs. spec:
Vibe Coding
Traditional chat-based interaction where you collaborate directly with the AI agent to build software iteratively.
Spec-First Development
A structured approach where you define requirements and design in markdown files, then let the agent implement based on these specifications.
The spec-first approach particularly intrigued me because it emphasizes documentation and planning—letting you iterate on requirements and collaborate with team members before any code is written. This methodology addresses a common pain point in AI-assisted development: the tendency to jump straight into flow coding without proper architectural consideration.
The Three-Layer Spec Framework
Kiro’s spec-driven approach follows a hierarchical structure:
1. Requirements with EARS Syntax
Kiro adopts the Easy Approach to Requirements Syntax (EARS), which brings several advantages to AI-assisted development:
- Clarity: Requirements are unambiguous and easy to understand
- Testability: Each requirement can be directly translated into test cases
- Traceability: Individual requirements can be tracked through implementation
- Completeness: The format encourages thinking through all conditions and behaviors
2. Technical Design Blueprint
The design.md file serves as your system’s technical blueprint, documenting architecture, component interactions, and sequence diagrams. This structured approach to design documentation facilitates better understanding and collaboration on complex systems by capturing implementation details in an organized format.
3. Implementation Tasks
The tasks layer becomes your implementation roadmap. The Kiro agent uses this structured plan to generate the actual application code, ensuring development follows your predefined architecture and requirements.
Security-First Agent Control
One of Kiro’s standout features is its approach to AI Security through granular command control. The platform offers two execution modes:
Autopilot Mode: The agent makes autonomous decisions and executes commands without supervision.
Supervised Mode: You maintain control over agent actions, with the ability to trust specific commands at different granularity levels.
Trust Levels for Command Execution
Kiro’s trust system in supervised mode operates at three levels:
Base Trust
All flags and subcommands of a specific terminal command (e.g., npm *) are trusted.
Kiro requested to execute the command:
npm run test:run
I approved for showcasing reasons and the resulting base trust settings was:
npm *
Partial Trust
All flags and follow-up commands of a specific terminal subcommand (e.g., npm run *) are trusted.
Kiro requested to execute the command:
npm run test:run -- src/components/tests/Timer.test.tsx
I approved for showcasing reasons and the resulting partial trust settings was:
npm run *
Full Trust
The exact terminal command with all subcommands and flags is trusted.
Kiro requested to execute the command:
npm run test:run -- src/components/tests/Timer.test.tsx
I approved for showcasing reasons and the resulting full trust settings was:
npm run test:run -- src/components/tests/Timer.test.tsx
Trust Settings Levels
These trust settings can be configured at both user and workspace level.
User level
{
"workbench.iconTheme": "vs-minimal",
"workbench.colorTheme": "Solarized Light",
"kiroAgent.agentAutonomy": "Supervised",
"kiroAgent.trustedCommands": [
"npm run test:run *",
"npm run security: *",
"npm test *"
]
}path: /Users/[user]/Library/Application Support/Kiro/User/settings.json
Project level
{
"kiroAgent.trustedCommands": [
"npm create *"
]
}
path: [projectDir]/.vscode/settings.json
Hands-On Project Code
To demonstrate Kiro’s spec-driven approach in practice, I’ve created an open-source test project that you can explore: source code repository
The project includes a practical example – a weird animal quiz application that showcases all three layers of Kiro’s methodology: weird animal quiz implementation
This hands-on example demonstrates:
- EARS requirements syntax in practice
- Technical design blueprints
- Task-based implementation planning
- Real command trust configurations
- Agent interaction patterns
Note: This is a work-in-progress test project that illustrates both the potential and current limitations discussed below.
Real-World Development Experience
During my testing, I appreciated Kiro’s “follow function” that provides real-time visibility into agent modifications. This transparency is crucial for understanding and validating AI-generated changes.
However, I encountered some limitations:
Sequential Task Execution: Only one task can run at a time, requiring careful task ordering and sequencing. When a task gets stuck, the entire workflow halts, necessitating manual intervention to stop and restart the stuck task.
Token Limitations: Complex projects quickly hit token limits, even when switching between different language models. My test project remained incomplete after several days due to these constraints.
Development Velocity: Compared to my earlier weird animal quiz rapid development approaches, the spec-driven methodology requires significantly more upfront time investment, though this may pay dividends in larger, more complex projects.
Steering and Conventions
Kiro includes a steering feature that I haven’t fully explored yet, which allows you to define organizational conventions and coding standards. This could be particularly valuable for teams wanting to maintain consistency across AI-generated code.
Conclusion and Future Outlook
Kiro presents an interesting approach to agentic development with several compelling features:
Strengths
- Spec structured approach encourages better planning and documentation
- Granular trusted commands for agent supervision
- Real-time change tracking enhances transparency
- Options to include organisation specific conventions via steering
Current Limitations
- In preview stage at the moment
- Token limit constraints
- Sequential task execution limitations
- Longer development cycles with spec feature compared to rapid prototyping
With proper configuration, Kiro enables a secure and structured approach to AI-assisted development. However, given its preview status, I recommend waiting for more mature releases before adopting it for production workflows.
The spec-first methodology shows promise for teams prioritizing documentation, collaboration, and structured development processes. I’m curious to see how the general availability release addresses current limitations and whether the approach gains traction in enterprise development environments.
Have you experimented with spec-driven AI agents? Share your experiences in the comments below.
Leave a Reply