AWS KIRO: Bring structure to AI coding with spec-driven development

1. About: 

1. What is AWS KIRO and Core Capabilities

• Kiro is an agentic IDE that helps you do your best work with features such as specs, steering, and hooks.With KIRO Bring structure to AI coding with spec-driven development
• Kiro turns your prompt into clear requirements, structured designs, implementation tasks validated by robust tests, and code generated by advanced agents.
• Note: (Public Preview) Kiro is currently in public preview. Features and documentation may change as we improve the product.

2. Core capabilities

1. Specs: Specs or specifications are structured artifacts that formalize the development process for complex features in your application. They provide a systematic approach to transform high-level ideas into detailed implementation plans with clear tracking and accountability.

With Kiro's specs, you can:

• Break down requirements into user stories with acceptance criteria
• Build design docs with sequence diagrams and architecture plans
• Track implementation progress across discrete tasks
• Collaborate effectively between product and engineering teams

2. Hooks: Agent Hooks are automated triggers that execute predefined agent actions when specific events occur in your IDE. Rather than manually asking for routine tasks to be performed, hooks set up automated responses to events. Agent Hooks transform your development workflow through intelligent automation.

By setting up hooks for common tasks, you can:

• Maintain consistent code quality
• Prevent security vulnerabilities
• Reduce manual overhead
• Standardize team processes
• Create faster development cycles

3. Steering: Steering gives Kiro persistent knowledge about your project through markdown files in .kiro/steering/. Instead of explaining your conventions in every chat, steering files ensure Kiro consistently follows your established patterns, libraries, and standards.

Key Benefits

• Consistent Code Generation - Every component, API endpoint, or test follows your team's established patterns and conventions.
• Reduced Repetition - No need to explain project standards in each conversation. Kiro remembers your preferences.
• Team Alignment - All developers work with the same standards, whether they're new to the project or seasoned contributors.
• Scalable Project Knowledge - Documentation that grows with your codebase, capturing decisions and patterns as your project evolves.

4. Model Context Protocol (MCP): Model Context Protocol (MCP) extends Kiro's capabilities by connecting to specialized servers that provide additional tools and context.

5. Agentic Chat: Kiro offers a chat panel where you can interact with your code through natural language conversations.

6. Privacy and security: Kiro is an AWS application that works as a standalone agentic IDE. Kiro's security framework is built around AWS's security infrastructure and follows practices to protect your development environment and data.

Refer to for complete security guidelines: Privacy and security - Docs - Kiro 

2. Installation

• 1       Go to kiro.dev and download the installer https://kiro.dev/downloads/
• 2       Open the downloaded file and follow the installation instructions for your operating system (Windows, macOS, or Linux).

3

333.Authentication Methods:

     When you open Kiro for the first time you will be asked to login with a provider of your choice that include social and AWS login options.

•   GitHub: Seamless integration with your GitHub account
•   Google: Sign in with your Google credentials
•   AWS Builder ID: Quick setup for individual developers
•   AWS IAM Identity Center: Enterprise-grade authentication

=> For IBM developers, use AWS Builder ID: Quick setup for individual developers

• In Kiro, choose Login with AWS Builder ID. You will be redirected to your default web browser to complete the sign in process.
• Enter your email address and then choose Next. (IBM email ID)
• Enter your password and then choose Sign in.
• Choose Allow access to authorize the Kiro App.

3. Pricing

• As part of KIRO preview there is special welcome bonus of 100 spec and 100 vibe requests for 14 days for new users.

How does the welcome bonus work?

• The welcome bonus includes 100 spec requests and 100 vibe requests which are available for 14 days. The clock starts on your first Kiro usage, such as a chat message. For example, if you create an account today, but only start using Kiro tomorrow, the 14 day period starts tomorrow. Once your usage starts, you will exhaust your bonus requests after 14 days, or when you run out of requests, whichever comes first.

• You can use the welcome bonus requests regardless of the tier you’re on. Unused requests roll over to the new tier automatically. For example, if you create an account today and use 20 of your 100 bonus spec requests, then upgrade to the Pro tier tomorrow, you will still be able to use your remaining bonus requests while on the Pro tier, as long as you’re still within your 14 days period.

Below are the current pricing options for KIRO: (** this may vary once the KIRO goes from preview to GA)  

**For any KIRO FAQ visit: Frequently Asked Questions - Kiro - Kiro

4. Development Demo

• As we discussed above KIRO provides 2 way of SDLC 1 with VIBE Coding 2. SPEC Based Development

A. Spec Based :

=> This demo we will focus on SPEC based development, which is more structured way of SDLC. 

Let's understand the structured flow of SPEC based development in KIRO ..

Below is illustration of KIRO Spec mode development for bookstore microservice app.. 

B. Using Agent Hooks:

Hooks are automated triggers that execute predefined agent actions.

• You can create Hooks from left hand - Click on + over Hooks tab and describe the hooks type you want to create.

In my application I have created 3 Hooks as shown above .. 

•   Service Test Runner Hook: Any changes done by developer in JS file , the agent hook will automatically analyze the changes and run the appropriate tests. If it's a source file change, run the corresponding unit tests and integration tests for that service.
• ** This is a great example reference of real time development, when developer make any changes from the original code, they need to write and perform unit test and integration tests before committing code, which is a quite manual and tedious for developer. **
• This agent hook will automatically trigger that test as soon the code file is changed.
•  below is the illustrations ..

• Steering gives Kiro persistent knowledge about your project through markdown files in .kiro/steering/. Instead of explaining your conventions in every chat.
• You can create agent steering from KIRO left panel using natural language. I my project I have create 2 steering as per below ..
•  => Microservices Development Standards: Defines how my code quality, test coverage etc will be for my entire code. KIRO will look into steering instruction and follow the persistent for my entire SDLC which is defined in my steering.
  Below the detail instruction used in my KIRO steering instruction. 
  

# Microservices Development Standards

## Code Style Guidelines
- Use consistent error handling patterns across all services
- Implement proper logging with structured JSON format
- Follow RESTful API conventions for all endpoints
- Use environment variables for configuration, never hardcode values

## Testing Requirements
- All services must have unit tests with >80% coverage
- Integration tests required for API endpoints
- Use Jest as the testing framework
- Mock external dependencies in unit tests

## Database Patterns
- Use the shared database models from `/shared/database/models/`
- Implement repository pattern for data access
- Always use transactions for multi-table operations
- Follow migration naming convention: `YYYYMMDD_HHMMSS_description.js`

## Service Communication
- Use the shared HTTP client from `/shared/http-client/`
- Implement circuit breaker pattern for external calls
- Always validate input data before processing
- Return consistent error response format:
  ```json
  {
    "error": "Error message",
    "code": "ERROR_CODE",
    "timestamp": "2024-01-01T00:00:00Z"
  }
  ```

## Docker & Deployment
- Each service must have its own Dockerfile
- Use multi-stage builds to minimize image size
- Include health check endpoints at `/health`
- Set proper resource limits in Kubernetes deployments

## Reference Files
- API Schema: #[[file:aws-config/templates/bedrock-test-request.json]]
- Database Schema: #[[file:shared/database/migrations/]]

{
  "mcpServers": {
    "awslabs.aws-diagram-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.aws-diagram-mcp-server"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "PATH": "/home/ubuntu/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      },
      "disabled": false,
      "autoApprove": [
        "list_icons"
      ]
    },
    "awslabs.aws-documentation-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.aws-documentation-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "AWS_DOCUMENTATION_PARTITION": "aws",
        "PATH": "/home/ubuntu/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      },

** I have used couple MCP serevrs, ex: diagram MCP, AWS cost, documentation etc to create a Technical Design Diagram(TDD) for this bookstore application. 

5. Conclusion: KIRO Impact Analysis for Online Bookstore SDLC

Below are benefits, I observed for my Bookstore Microservice Application end to end SDLC, using KIRO - Spec driven features.

KIRO transformed our online bookstore microservices development by automating requirements documentation, architecture design, code generation, comprehensive testing, and complete AWS infrastructure provisioning, delivering a 60% reduction in overall project timeline (from 25 weeks to 10 weeks) while achieving enterprise-grade quality standards across planning, development, testing, and DevOps phases.

**Note: The numbers provided are based on the greenfield deployment of this application within its deployment lifecycle. These may vary depending on the complexity of the code, the application architecture, and the deployment approach (greenfield or brownfield).