# Kiro

Kiro is an AI-powered development environment from AWS that supports agentic coding and specification-driven software development.

Cloud service · AWS. Updated 2026-11-12. Page: https://blowstack.com/tools/cloud-services-hub/kiro

> Kiro helps engineers turn application requirements into designs, implementation tasks, and code within an integrated development environment. It combines conversational coding assistance with project specifications, persistent development guidance, event-driven agent hooks, and external tool access through the Model Context Protocol.

Practice exams covering Kiro: [AIF-C01 AWS Certified AI Practitioner](https://blowstack.com/practice-exams/aws-certified-ai-practitioner), [SOA-C03 AWS Certified CloudOps Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-cloudops-engineer-associate).

## 10 key features of Kiro

1. **Specification-driven development**: Develop requirements, technical designs, and implementation tasks before changing code. Store the resulting specifications with the repository so reviewers can compare implementation decisions against the intended behavior.
2. **Agentic coding assistance**: Use conversational requests to investigate code, implement changes, and work through development tasks. Review generated edits and command results before accepting them, especially for dependency changes and security-sensitive code.
3. **Version-controlled specification artifacts**: Keep feature specifications as project files rather than relying only on chat history. This makes requirements and design changes visible in pull requests and available to other engineers.
4. **Project steering**: Provide persistent guidance about architecture, coding conventions, libraries, and testing practices through steering files. Keep guidance specific to the repository and update it when project conventions change.
5. **Event-driven agent hooks**: Configure development events to trigger repeatable agent tasks, such as checking related tests or updating documentation after file changes. Retain CI checks for requirements that must be enforced consistently.
6. **Model Context Protocol support**: Connect the agent to external capabilities exposed by MCP servers, such as documentation search or cloud inspection tools. Restrict each server's permissions and review tools that can execute commands or modify resources.
7. **Integrated development workflow**: Work with source files, diffs, terminals, and compatible editor extensions in a VS Code-based environment. Validate extension compatibility and establish reproducible build and test commands for the project.
8. **Customer-managed encryption keys**: Kiro supports customer managed AWS KMS keys for session data encryption and persistent storage.
9. **Private repository connectivity**: VPC connectivity provides private network paths between Kiro and internal code repositories.
10. **Code generation audit logging**: Audit logging can track code generation activities and link them to originating user requests for traceability.

## Where Kiro is used

1. **Implementing a feature from reviewed requirements**: Create requirements and a design for a new application capability, review them with the team, and execute the resulting implementation tasks incrementally. Add acceptance tests that independently verify the specified behavior.
2. **Developing serverless applications**: Use Kiro to edit function code, API contracts, tests, and infrastructure definitions for an AWS serverless application. Validate and deploy through AWS SAM, AWS CDK, or the team's existing pipeline rather than treating generated code as deployment-ready.
3. **Refactoring an existing codebase**: Ask the agent to investigate dependencies and propose a staged refactor with explicit compatibility constraints. Use focused diffs and regression tests to preserve external behavior while changing implementation details.
4. **Applying repository conventions**: Encode recurring architectural and testing guidance in steering files, and use hooks for supporting tasks such as documentation checks. Back mandatory rules with linters, tests, and branch protection.
5. **Investigating application failures**: Combine source-code analysis with sanitized logs or narrowly scoped diagnostic tools to investigate errors. Reproduce the failure in a test and review the proposed fix before promoting it through the deployment pipeline.

## How Kiro is priced

- **Free plan with limited usage**: Kiro offers a free plan with a limited allowance for AI usage. Check the current plan terms for included credits, eligible features, and any introductory allowances before relying on it for ongoing development.
- **Paid subscriptions with usage allowances**: Paid plans provide recurring AI usage allowances, with limits and additional-usage options determined by the selected plan. Estimate costs from the number of developers and their agent usage; AWS resources and external services accessed during development are billed separately.

## Services Kiro works with

Kiro typically participates in AWS architectures at development time rather than in the deployed application's request path. Engineers use it to edit application code, SDK calls, tests, and infrastructure-as-code definitions. AWS SAM, AWS CDK, Terraform, CloudFormation, or an existing CI/CD pipeline then validates and deploys those artifacts. A common example is an API Gateway endpoint backed by Lambda, with DynamoDB for application state and S3 for uploaded objects.

External tool access can extend this workflow through MCP servers or separately configured command-line tools. Documentation tools can supply service-specific context, while narrowly scoped diagnostic tools can retrieve deployment metadata or CloudWatch logs. These capabilities depend on the installed tools and credentials; naming an AWS service in a prompt does not establish connectivity or grant access.

Separate code generation from deployment authority. Use development accounts, short-lived role credentials, and least-privilege permissions, and require explicit approval for production changes. Keep infrastructure definitions and specifications in version control, run automated security and integration checks, and inspect deployment plans before execution. Sanitize logs and tool responses before providing them as agent context. Kiro usage charges remain separate from the AWS resources and external services involved in these workflows.

- **[AWS Lambda](https://blowstack.com/tools/cloud-services-hub/aws-lambda)**: Kiro can assist with Lambda function code, tests, and deployment definitions through project files and development tools; this does not require a native service-to-service integration. For example, use it to implement an event handler and its unit tests, then validate and deploy the function with AWS SAM or AWS CDK. Review execution-role permissions, timeout settings, and retry behavior before deployment.
- **[Amazon API Gateway](https://blowstack.com/tools/cloud-services-hub/amazon-api-gateway)**: Use Kiro to develop API contracts, request validation, and infrastructure definitions for API Gateway. For example, define an authenticated HTTP endpoint backed by Lambda, then add tests for authorization failures and malformed requests. Deploy through established tooling and verify route configuration, CORS behavior, and access logging.
- **[Amazon DynamoDB](https://blowstack.com/tools/cloud-services-hub/amazon-dynamodb)**: Kiro can help implement DynamoDB access code and infrastructure definitions using the repository's SDK and deployment framework. For example, describe an application's access patterns in a specification, then implement conditional writes and queries against the appropriate keys or indexes. Review partition-key distribution, pagination, consistency requirements, and IAM permissions rather than accepting generated data models without analysis.
- **[Amazon S3](https://blowstack.com/tools/cloud-services-hub/amazon-s3)**: Use Kiro to develop S3 client code, bucket infrastructure, and tests for object workflows. For example, implement a short-lived presigned upload URL and validate object metadata before subsequent processing. Review public-access settings, encryption, lifecycle rules, and object-level permissions independently of the generated code.
- **[Amazon CloudWatch](https://blowstack.com/tools/cloud-services-hub/amazon-cloudwatch)**: Kiro can help write structured logging code, CloudWatch Logs Insights queries, and alarm definitions. For example, provide sanitized error output or use an approved read-only tool to investigate a failing Lambda invocation, then add a regression test and an alarm for the failure condition. Access to live telemetry requires separately configured tools and permissions, and diagnostic context should exclude secrets and unnecessary personal data.
- **[Amazon Bedrock](https://blowstack.com/tools/cloud-services-hub/amazon-bedrock)**: Kiro uses foundation models hosted on Amazon Bedrock to power its AI-assisted development features, including generating code and turning specifications into implementation plans.
- **[Amazon VPC](https://blowstack.com/tools/cloud-services-hub/amazon-vpc)**: Kiro can be configured with VPC connectivity to establish private network paths to internal code repositories.
- **[AWS CloudTrail](https://blowstack.com/tools/cloud-services-hub/aws-cloudtrail)**: Kiro integrates with CloudTrail to record supported administrative API activity, providing an audit trail of requests and the identities that made them.
- **[AWS DevOps Agent](https://blowstack.com/tools/cloud-services-hub/aws-devops-agent)**: Kiro connects to AWS DevOps Agent through a dedicated power and its MCP server. Release-readiness review findings appear in Kiro's development workflow, where the coding agent can address identified issues before a pull request is created.
- **[AWS IAM Identity Center (AWS Single Sign-On)](https://blowstack.com/tools/cloud-services-hub/aws-iam-identity-center-(aws-single-sign-on))**: Kiro supports workforce sign-in through IAM Identity Center. Administrators can assign Kiro access to organizational users and groups and manage their subscriptions centrally.
- **[AWS Identity and Access Management (IAM)](https://blowstack.com/tools/cloud-services-hub/aws-identity-and-access-management-(iam))**: Kiro uses IAM permissions to control access to its AWS administrative operations. Administrators can grant subscription-management permissions separately from other AWS account responsibilities.
- **[AWS Key Management Service (AWS KMS)](https://blowstack.com/tools/cloud-services-hub/aws-key-management-service-(aws-kms))**: Kiro can use customer-managed AWS KMS keys to encrypt session data and persistent storage, giving organizations control over the encryption keys protecting that information.
- **[AWS Serverless Application Model (AWS SAM)](https://blowstack.com/tools/cloud-services-hub/aws-serverless-application-model-(aws-sam))**: Kiro provides an AWS SAM power that supplies specialized context and tools for serverless development. It helps the coding agent build, validate, and deploy applications defined with SAM templates.

## Kiro exam questions

Real practice exam questions on Kiro, with the correct answer and its explanation.

### Question 1 (SOA-C03)

**Question:**

A CloudOps team maintains an AWS Lambda function that remediates application latency by increasing worker capacity. After a recent code change, the function exceeded the approved capacity limit. The team adds regression tests for capacity limits and repeated alarm notifications.

The team wants its AI-assisted development environment to automatically run these tests whenever an engineer saves relevant remediation source files. The same tests must also block deployment if they fail, including when changes are submitted without using the development environment.

Which solution meets these requirements?

**Correct answer:** Create a Kiro agent hook for saves to the remediation source files that runs the regression tests. Also configure the deployment pipeline to require the tests to pass before deployment.

**Explanation:** Kiro agent hooks associate development events, such as saving relevant files, with repeatable actions such as running tests. A separate required pipeline check enforces the deployment requirement even when contributors do not use Kiro.

## Practice Kiro in a full exam

Questions on Kiro in each practice exam, with every answer option and an explanation for each:

- [AIF-C01](https://blowstack.com/practice-exams/aws-certified-ai-practitioner): 2 questions
- [SOA-C03](https://blowstack.com/practice-exams/aws-certified-cloudops-engineer-associate): 2 questions

## What is Kiro

Kiro is a development tool, not an application hosting platform or an AWS runtime service. Engineers use it to work with source code, develop features, investigate problems, and prepare applications for deployment. Applications created with Kiro can run on AWS or other platforms; their runtime architecture, permissions, availability, and operating costs remain separate engineering responsibilities.

Kiro is available through both an integrated development environment (IDE) and a command-line interface (CLI).

A central workflow in Kiro is specification-driven development. An engineer describes a feature, then develops requirements, a technical design, and an implementation task plan with the agent. Project specifications are stored as Markdown files, commonly under the `.kiro/specs` directory. Keeping these artifacts in version control lets reviewers evaluate intended behavior and technical decisions alongside the implementation. Specifications are useful planning artifacts, but they do not replace acceptance tests or prove that generated code satisfies a requirement.

Kiro also supports direct conversational development when a formal specification is unnecessary. Engineers can ask the agent to explain code, investigate a failing test, or implement a focused change. Review generated changes as ordinary code contributions: inspect the diff, run relevant tests, validate dependencies, and check security-sensitive behavior. For larger changes, smaller implementation tasks make it easier to identify regressions and preserve review quality.

Steering files provide reusable project guidance, such as repository structure, preferred libraries, coding conventions, and testing expectations. Agent hooks associate development events with repeatable agent actions, such as checking whether a code change needs corresponding tests or documentation. These mechanisms help apply team conventions, but deterministic checks should still run in continuous integration. An agent instruction is not an enforcement boundary.

Kiro can connect to external tools through Model Context Protocol servers. Such servers can expose documentation lookup, repository operations, or cloud management capabilities, depending on their implementation and configuration. Treat each server as an additional software dependency and trust boundary. Review its provenance, restrict credentials, and understand whether exposed tools only read information or can change infrastructure and data.

For AWS projects, a practical setup combines Kiro with infrastructure-as-code files, automated tests, and established deployment pipelines. The agent can help edit AWS CDK, AWS SAM, Terraform, or CloudFormation definitions, while existing command-line tools and pipelines perform validation and deployment. Use short-lived credentials, separate development and production roles, and require approval for consequential operations. Keep secrets out of prompts, specifications, source files, and tool output wherever possible.

Kiro does not automatically configure production monitoring, data protection, or application access control. Engineers must explicitly design these controls and verify the resulting infrastructure. Track Kiro subscription usage separately from charges for deployed AWS resources, build jobs, model endpoints, or third-party tools used during development.

## Learn Kiro in lessons

2 short lessons on Kiro in 2 certification courses.

- AIF-C01: Kiro: specification-driven development (Premium), https://app.blowstack.com/lessons/kiro-specification-driven-development-aif-c01
- SOA-C03: Kiro: conversational code assistance (Premium), https://app.blowstack.com/lessons/kiro-conversational-code-assistance-soa-c03
