Skip to content

AWS Kiro: Spec-Driven Agentic IDE for Cloud Development

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

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.

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:

  1. 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.
  2. 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.
  3. 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.

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 tests

A 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 replays

You 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 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 rules

A 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 task

Steering 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/:

.kiro/hooks/auto-lint.yaml
name: Fix lint errors on save
trigger:
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.

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.

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.

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.

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