CLOUD SERVICE · AWS

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

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.

Cloud Services Hub →

What is Kiro

Read the extensive description

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.

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.

Key Kiro Features

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.

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.

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.

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.

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.

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.

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.

Kiro Use Cases

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.

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.

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.

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.

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.

Kiro pricing models

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 integrates 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.

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.

Open Amazon DynamoDB →

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.

Open Amazon API Gateway →

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.

Open Amazon CloudWatch →

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.

Open AWS Lambda →

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.

Open Amazon S3 →