Amazon Kiro: The Spec-Driven IDE That Takes Prototypes to Production

Every AI coding tool in 2025 solved the same problem: write code faster. They differed in hotkeys, context windows, and autocomplete speed, but the shape was identical — you prompt, it types. Amazon Kiro, launched in February 2026, bets that the shape itself is wrong. Instead of treating the AI as a faster typist, Kiro treats it as an engineer who writes specs first, then writes code to satisfy them, and then maintains that code when the specs change.

That sounds like a product pitch, so let's get concrete. Here's what Kiro actually does at each stage of a feature build, and why the distinction matters if you're choosing between it and Cursor, Windsurf, or Claude Code for production work.

What Kiro actually is

Kiro is an IDE built by AWS and powered by Claude Sonnet 4.5 and Amazon Nova via Amazon Bedrock. It runs as a VS Code fork on macOS, Windows, and Linux, and ships a web-based interface for lighter work. The core value proposition is spec-driven development: you describe a feature in natural language, Kiro converts it into a structured specification using EARS (Easy Approach to Requirements Syntax) notation, generates an architectural design, sequences implementation tasks from that design, and keeps code in sync as you iterate.

What separates Kiro from a "spec generator bolted onto an IDE" is the feedback loop. When you edit the spec, Kiro flags code that no longer satisfies it. When you edit code in ways the spec doesn't anticipate, Kiro can propose a spec update. The spec isn't documentation that drifts — it's a live contract.

The spec → code pipeline

The workflow has four stages, each of which can be automated to varying degrees.

Stage 1: Requirements capture

You describe a feature in plain text. Kiro's agent parses the description and produces a requirements document in EARS notation. EARS is a structured natural-language format (not code) where each requirement takes a form like: "When the user submits the form with invalid data, the system shall display an inline error message per field." This isn't just formatting — EARS requirements are machine-checkable. Kiro can verify whether a test exercises each one.

Stage 2: Design generation

From the requirements, Kiro generates an architectural design: component breakdown, data flow, interface contracts, and a sequence of implementation tasks. You review and edit the design before any code is written.

# User Authentication Requirements

## Functional Requirements

WHEN the user submits valid credentials
THE SYSTEM SHALL issue a signed JWT with a 1-hour expiry
AND store a refresh token in an HttpOnly cookie

WHEN the user submits invalid credentials three times
THE SYSTEM SHALL lock the account for 15 minutes
AND send a notification to the registered email

WHEN the refresh token expires
THE SYSTEM SHALL redirect the user to the login page
AND invalidate all active sessions for that user

## Non-Functional Requirements
- Login latency: p95 < 300ms
- Token signing: RS256, keys rotated every 30 days

Stage 3: Agentic implementation

Kiro's agent works through the task sequence. You can run in autopilot mode (the agent implements end-to-end with check-ins at gates) or step through tasks manually. Either way, the agent tracks which requirements have been satisfied and which remain open, displayed as a live checklist in the sidebar.

Stage 4: Spec maintenance

When you need to change behavior, you edit the spec, not the code directly. Kiro diffs the spec change against the existing implementation and produces a targeted edit plan. This is where "production-ready" becomes real: on a six-month-old codebase, there's no cognitive load reconstructing what each function was supposed to do. The spec is the source of truth, and the code follows.

Hooks and steering rules

Two features distinguish Kiro's day-to-day experience from a generic AI IDE: hooks and steering rules.

Hooks are trigger-based automations that fire on file system events. The canonical use cases are: generate a test file whenever a new source file is created; update JSDoc comments whenever a function signature changes; run a linter and auto-fix on save. Hooks live in .kiro/hooks/ as YAML files.

name: auto-test-on-create
trigger:
  event: file.created
  pattern: "src/**/*.ts"
  exclude: "**/*.test.ts"
action:
  prompt: |
    Generate a comprehensive test file for the newly created file.
    Cover happy path, edge cases, and error conditions.
    Use the project's existing test patterns as a reference.
  outputPath: "{dir}/{name}.test.ts"

Steering rules are project-scoped instructions that shape every agent action. Think of them as CLAUDE.md but with a declarative schema for priority and scope. A steering rule can specify which files the agent is allowed to touch, which coding standards to enforce, and which AWS services are in-scope for architecture decisions.

MCP integration and the AWS GA moment

Kiro ships native Model Context Protocol support. Any MCP server — database clients, API clients, documentation retrieval — wires in with the same config format used by Claude Code and Cursor. This matters because it means skills from skills-hub.ai are compatible with Kiro with no adaptation.

The event that made Kiro significantly more powerful was the AWS MCP Server going GA in May 2026. This server exposes every AWS service (EC2, S3, Lambda, RDS, DynamoDB, ECS, and 200+ more) as MCP tools with proper Bedrock authentication. For teams already on AWS, this means Kiro can read your production S3 bucket structure, describe your RDS schema, and list your Lambda functions as context for architecture decisions — without you manually pasting that information into the agent.

{
  "mcpServers": {
    "aws": {
      "command": "npx",
      "args": ["-y", "@aws/mcp-server"],
      "env": {
        "AWS_PROFILE": "my-dev-profile",
        "AWS_REGION": "us-east-1"
      }
    },
    "skills-hub": {
      "command": "npx",
      "args": ["-y", "@skills-hub-ai/mcp"]
    }
  }
}

Kiro vs Cursor, Windsurf, Claude Code

The AI coding tool landscape in mid-2026 has four meaningful categories. Here's where each tool plays:

• Cursor Composer 2.5 (released May 18, 2026) is optimized for parallel agentic work inside a familiar VS Code UI. Agent Swarm runs multiple tasks concurrently. Its edge is speed on established codebases where you know what you want built.
• Windsurf 2.0 has Spaces for persistent task context and one-click Devin Cloud handoff. Best for teams that want a managed agent with long-running task state.
• Claude Code is terminal-first and subagent-native. It excels at orchestrating agent pipelines, loading custom SKILL.md files, and running in CI. Best for developers who want to compose complex multi-step workflows.
• Kiro is the only tool that puts specification rigor before implementation. If your bottleneck is not writing code fast enough but shipping code that stays maintainable, Kiro is purpose-built for that.

The comparison that matters most is Kiro vs Cursor, because both are IDE-first. Cursor wins on raw speed and ecosystem familiarity. Kiro wins when the feature is complex enough that "just ship it" produces debt you'll spend the next sprint cleaning up. For greenfield products or teams onboarding new engineers, Kiro's enforced spec trail is the institutional-knowledge benefit AWS's leadership specifically calls out: when the senior engineer who designed the auth flow leaves, the spec stays.

Pricing: free to Pro+

Kiro launched in free preview and transitioned to tiered pricing in May 2026. The tiers are straightforward:

"Interactions" include agent steps, not just top-level prompts. A single "implement this feature" request that triggers a spec generation, architecture design, ten implementation steps, and a hook that writes tests counts as roughly 13 interactions. The free tier is genuinely usable for evaluation, but weekly active use on a real project will exhaust it. The Pro tier at $19 is competitive with Cursor ($20) and cheaper than Claude Code Pro ($25).

Getting started with Kiro skills

Because Kiro supports MCP, the skills-hub.ai registry works with it directly. The @skills-hub-ai/mcp package exposes every skill in the registry as an MCP tool — install it once, and any skill you discover on skills-hub.ai/kiro-skills is immediately available in Kiro's agent context.

# 1. Install Kiro (download from kiro.dev)

# 2. Add the skills-hub MCP server to your Kiro config
npx @skills-hub-ai/cli config --platform kiro

# 3. Browse skills built for Kiro's spec-driven workflow
npx @skills-hub-ai/cli search "spec driven" --platform kiro

# 4. Install the kiro-spec-driven skill directly
npx @skills-hub-ai/cli install kiro-spec-driven

For the spec-driven workflow specifically, the kiro-spec-driven skill on the registry gives your Kiro agent a phased playbook: capture requirements, generate EARS specs, review architecture, implement, and validate against the spec checklist. It's the same workflow described in this post, packaged as a portable SKILL.md file you can install in under thirty seconds.

The broader point is that Kiro is genuinely new in the AI IDE market — not a wrapper, not a rebranded VS Code with better autocomplete, but a different philosophy about where AI belongs in the software development lifecycle. Whether spec-first development fits your team depends on how much of your current pain is writing code versus maintaining code you can no longer reason about. If it's the latter, Kiro is worth a free-tier evaluation this week.