AWS Kiro: Spec-Driven Agentic IDE for Cloud Development
What you’ll learn
Section titled “What you’ll learn”- How Kiro’s spec-driven development workflow differs from other AI coding agents.
- Using Steering Files to give Kiro persistent project context, identity, and architecture rules.
- Automating repetitive tasks with Hooks — triggered on file saves, test failures, and PR events.
- Connecting Kiro to GitHub, Jira, and databases via the Model Context Protocol (MCP).
- When Kiro’s approach outperforms other tools, and when it does not.
Summary
Section titled “Summary”Kiro is Amazon Web Services’ agentic IDE built on VS Code. Its defining characteristic is spec-driven development: before writing any code, Kiro generates a structured specification — requirements, design, and task list — that you review and approve. Only after approval does Kiro begin implementation. This creates a verifiable record of intent that makes AI-generated code easier to review, test, and maintain.
Kiro also integrates natively with the AWS ecosystem, with built-in intelligence for CDK, CloudFormation, Lambda, ECS, DynamoDB, and other AWS services. It is free during the preview period and available at kiro.dev.
The problem it solves
Section titled “The problem it solves”Most AI coding tools start writing code the moment you describe a feature. For small, isolated changes this works well. For larger features or greenfield modules, the lack of an agreed design creates several problems:
- Unclear requirements become unclear code: An ambiguous prompt produces an implementation that solves one interpretation of the feature. The developer discovers the mismatch only during code review or QA.
- No checkpoint for stakeholder alignment: Product owners, architects, or team leads cannot review a plan before code is committed — they can only react to code that may already need a full rewrite.
- Testing gaps: When the AI generates implementation and tests simultaneously without a plan, the tests tend to verify what the code does rather than what the feature should do.
Kiro addresses all three by inserting a spec review step before implementation begins.
Spec-driven development
Section titled “Spec-driven development”The core Kiro workflow:
1. Developer describes the feature in plain English ↓2. Kiro generates a spec (requirements, design, tasks) ↓3. Developer reviews and edits the spec ↓4. Developer approves the spec ↓5. Kiro implements the spec, file by file ↓6. Developer reviews the diff and runs testsA spec document looks like this:
# Feature: Order Idempotency
## Requirements- POST /orders must accept an Idempotency-Key header (UUID v4)- Duplicate requests with the same key must return the original 201 response- Keys expire after 24 hours- Keys are scoped per authenticated user
## Design- New table: idempotency_keys (key, user_id, response_body, created_at)- Middleware checks for key in table before forwarding to handler- Matching key returns cached response with original status code
## Tasks- [ ] Create migration: idempotency_keys table- [ ] Add IdempotencyMiddleware to Express pipeline- [ ] Update POST /orders handler to record key after success- [ ] Write integration tests covering fresh requests and replaysYou can edit this spec before approving it. Add acceptance criteria, change the design, or add tasks Kiro missed. The spec is committed to the repository alongside the implementation, providing a durable audit trail.
Steering Files
Section titled “Steering Files”Steering Files give Kiro persistent context about your project — the equivalent of CLAUDE.md for Claude Code or .cursorrules for Cursor. They live in .kiro/steering/ and are loaded automatically on every session.
.kiro/└── steering/ ├── product.md # What the product is, who uses it, what it does ├── tech.md # Stack, build commands, testing frameworks └── structure.md # Directory layout, naming conventions, architectural rulesA minimal tech.md:
# Tech Stack
## Backend- Node.js 22, TypeScript 7- Express with Zod validation- PostgreSQL 17 with Drizzle ORM
## Commands- npm run build — production build- npm test — Vitest test suite- npm run lint — ESLint + Prettier
## Rules- Never write raw SQL; use the repository pattern in src/db/- All amounts use the Money value object — never raw floats- Run npm test after every implementation taskSteering Files are committed to source control, so the whole team shares the same context.
Hooks are YAML automation rules that trigger Kiro to act on specific events — file saves, test failures, PR opens. They live in .kiro/hooks/:
name: Fix lint errors on savetrigger: event: file_saved filePattern: "**/*.{ts,tsx}"action: prompt: | {{file}} was saved. Run ESLint and fix any violations automatically. Only fix lint issues — do not change logic. If no violations exist, do nothing.Hooks are most useful for:
- Automatically fixing lint errors on save (keeping the codebase consistently formatted)
- Running the relevant test file when a service changes (catching regressions immediately)
- Generating PR descriptions when a branch is pushed (standardizing team communication)
- Alerting when a new file contains patterns that look like hardcoded secrets
See the Kiro Hooks guide for the full YAML schema and event reference.
MCP integrations
Section titled “MCP integrations”Kiro supports the Model Context Protocol (MCP), allowing it to connect to external systems while generating specs and writing code.
| Integration | What Kiro can do |
|---|---|
| GitHub MCP | Read issues, PRs, and repository contents. “Implement issue #42” → Kiro fetches the issue and writes the spec from its requirements. |
| Atlassian MCP | Read Jira tickets and Confluence pages. “Implement PROJ-456” → Kiro fetches the acceptance criteria before speccing. |
| SQL Server MCP | Inspect live database schemas. Kiro generates queries and migrations that match the actual table structures. |
MCP configurations live in .kiro/mcp.json and use environment variable references for credentials — secrets never go into the JSON file.
See the individual MCP guides: GitHub, Atlassian.
AWS-native capabilities
Section titled “AWS-native capabilities”Kiro is purpose-built for AWS workloads and understands AWS patterns that general-purpose tools hallucinate about:
| AWS service | Kiro capability |
|---|---|
| CDK / CloudFormation | Generates IaC alongside application code, keeping them in sync |
| Lambda + API Gateway | Default pattern for serverless API endpoints; generates handler, event types, and SAM template |
| ECS / Fargate | Scaffolds task definitions, service configurations, and GitHub Actions deployment workflows |
| DynamoDB | Generates table definitions, GSIs, and access patterns from natural-language data requirements |
| IAM | Generates least-privilege IAM policies for the resources it creates |
For non-AWS cloud targets (Azure, GCP), Kiro works fine but requires more explicit prompting — it does not have the same first-class shortcut understanding.
Autopilot mode
Section titled “Autopilot mode”Once a spec is approved, Kiro can run in autopilot: it implements every task in the spec, runs the test suite after each change, and automatically fixes failures before moving to the next task. Progress is visible in the Kiro panel.
Autopilot is effective for:
- Well-defined features with clear acceptance criteria
- Repetitive structural work (adding the same field to multiple layers)
- Greenfield modules where no existing code can be broken
It is not appropriate for tasks where the right design is still unclear — autopilot will implement the spec as written, even if the spec turns out to be wrong. The spec review step is where you catch those problems.
Kiro vs Cursor vs Claude Code
Section titled “Kiro vs Cursor vs Claude Code”| Feature | Kiro | Cursor | Claude Code |
|---|---|---|---|
| Spec before code | Yes (unique) | No | No |
| AWS-native intelligence | Yes | Via AWS CLI | Via Claude + AWS CLI |
| Steering Files | Yes (.kiro/steering/) |
.cursorrules |
CLAUDE.md |
| Hook automation | Yes | Partial (Agent Mode) | Via shell scripts |
| MCP support | Yes | Via extensions | Yes |
| Editor surface | VS Code fork | VS Code fork | Terminal |
| Best fit | AWS cloud applications with reviewable AI output | Multi-model IDE with visual diff review | Terminal workflows, any editor |
Common mistakes
Section titled “Common mistakes”- Approving a spec without reading it: The spec review exists precisely to catch misunderstandings. Skimming it and clicking approve gives up Kiro’s main advantage.
- Too many Steering Files: One long file per concern is better than many short, overlapping files. Kiro loads all Steering Files on every session.
- Overly vague Hook prompts: “Improve this file” produces inconsistent results. Hooks work best with specific, narrow instructions.
- Using autopilot for ambiguous tasks: If the requirements are not clear enough to write an acceptance test, the spec is not ready for autopilot.
When to use it and when not to
Section titled “When to use it and when not to”| Scenario | Recommendation |
|---|---|
| AWS cloud development with reviewable specs | Use Kiro |
| Feature work that needs stakeholder sign-off before implementation | Use Kiro |
| Fast exploratory coding or one-off scripts | Use Cursor or Claude Code |
| Terminal-first development on remote servers | Use Claude Code or Gemini CLI |
| Non-AWS cloud infrastructure (Azure, GCP) | Use Cursor or Claude Code with explicit cloud context |
Key takeaways
Section titled “Key takeaways”- Kiro introduces a spec review step before writing code, creating a verifiable design record.
- Steering Files provide persistent project context committed alongside the application code.
- Hooks automate lint, test, and PR workflows without manual intervention.
- MCP integrations connect Kiro to GitHub issues, Jira tickets, and live database schemas.
- AWS-native intelligence generates CDK, Lambda, ECS, and DynamoDB patterns accurately without extensive prompting.
Related pages
Section titled “Related pages”- Kiro Installation guide — step-by-step setup on Windows
- Kiro Hooks guide — YAML schema, events, and examples
- Kiro MCP overview — connecting to external systems
- Kiro Steering guide — project context configuration
- Cursor AI Editor — IDE comparison
- Claude Code — terminal-native alternative
Official references
Section titled “Official references”- Kiro website — download and product overview
- Kiro documentation — Steering, Hooks, MCP, and spec reference