Photo by Paymo on Unsplash Source

Updated October 23, 2026: replaced outdated pricing and model details with Kiro’s current credit plans and model list, added bugfix specs, Quick Spec, parallel tasks and the new hook format, and swapped the Cursor table for a comparison with Spec Kit, OpenSpec and other spec-driven tools.

If you’re looking for a spec IDE, an editor that writes the specification before it writes the code, Kiro is the one to know. AWS launched it in preview in July 2025 and made it generally available on November 17, 2025. Ask it for a feature and it first produces requirements.md, design.md and tasks.md, lets you review each one, and only then starts coding. As of October 2026, Kiro runs as an IDE built on Code OSS, a CLI, a web app and a mobile app; it has a free tier with 50 credits a month and paid plans from $20 to $200; and it offers its Auto model router alongside Claude, GPT-5.6 and open-weight models. If you want the same spec-first workflow without switching editors, GitHub Spec Kit and OpenSpec are the open-source alternatives, compared further down.

Most AI coding tools still compete on the same axis: generate more code, faster, from shorter prompts. Kiro bets on the opposite. It treats specification quality, not generation speed, as the bottleneck, and makes the spec the center of the workflow instead of an optional extra. That idea has spread since launch, to GitHub’s Spec Kit, to OpenSpec, and to the plan modes in Cursor and Claude Code. What still sets Kiro apart is that the spec workflow is the product rather than an add-on.

Related: AI Coding Assistants Compared: Cursor vs Claude Code vs Copilot vs Devin

What Kiro Actually Is (and What It Isn’t)

The Kiro IDE is based on Code OSS, the open-source core of VS Code. If you’ve used Cursor or Windsurf, the form factor is familiar, and onboarding imports your VS Code settings, themes and Open VSX-compatible extensions, so check that the extensions you depend on are published on Open VSX. You sign in with GitHub, Google, AWS Builder ID or IAM Identity Center; you don’t need an AWS account.

Since GA, Kiro has stopped being only an IDE. The same agent now runs in the Kiro CLI, in Kiro Web (browser sessions that work on your GitHub or GitLab repositories and open pull requests, paid plans only), in a mobile app, and in Kiro Crew, an open-source personal agent. Kiro’s team describes how it merged what used to be three separate agents (TypeScript in the IDE, Rust in the CLI, Python on the web) into one harness that every app talks to over the Agent Client Protocol, so a session can start on your laptop and continue in the cloud.

The difference from Cursor is still architectural. Kiro puts three layers between your intent and the generated code:

  1. Specs: Structured documents that capture requirements, design decisions and implementation tasks
  2. Hooks: Automations that run a shell command or an agent prompt when something happens, such as the agent saving a file or finishing a task
  3. Steering files: Markdown files in .kiro/steering/ that define your project’s context, coding standards and tech stack

These aren’t features buried in a settings menu. They’re the core workflow. When you ask Kiro to build a feature in spec mode, it starts by generating a spec, not code.

On models, you either let Kiro choose or pick one yourself. The default, Auto, is a router that, in the words of the models page, will “route each task to the optimal model automatically”, and it is the 1.0x credit baseline. The selectable list includes Anthropic’s Claude Opus 5, Sonnet 5.5 and older Claude models (Opus 5.5 is in experimental support), OpenAI’s GPT-5.6 Sol, Terra and Luna, and open-weight models such as Qwen3 Coder Next, DeepSeek 3.2, MiniMax and GLM-5. Each has a credit multiplier, from 0.05x for Qwen3 Coder Next to 2.2x for Opus 5 and 4.4x for GPT-5.6 Sol. Free-tier users get Claude Sonnet 4.5 and the open-weight models; Claude Fable 5.1 is limited to Enterprise organizations at 6x.

What It Isn’t

Kiro is not a general-purpose speed tool. If you want to bang out a prototype in 20 minutes by describing what you want in plain English, Cursor or Claude Code will get you there faster. Kiro has softened its stance: a vibe mode skips specs entirely, and Quick Spec generates all three documents in one pass. But the default bet is still that upfront time pays for itself by reducing debugging, rework and the “it works but isn’t what I meant” problem that plagues vibe coding.

Spec-Driven Development: Requirements Before Code

The core of Kiro is spec-driven development, a three-phase pipeline that turns a user story into working code through structured intermediate documents.

Here’s how it works in practice. You describe a feature in natural language:

“Add a shopping cart that supports quantity changes, item removal, and persists across sessions using localStorage.”

Kiro doesn’t start writing React components. Instead, it generates three artifacts, each building on the previous one:

Phase 1: Requirements Document

A structured breakdown of user stories and acceptance criteria, written in EARS notation (“THE System SHALL …”). For the shopping cart, this would include items like “Cart must handle concurrent tab updates,” “Quantity must be capped at available inventory,” and “Cart state must survive browser refresh.”

You review and edit this document. Add requirements Kiro missed. Remove ones that don’t apply. This is where you catch misunderstandings before they become code.

Phase 2: Design Document

Based on the approved requirements, Kiro generates a technical design: component architecture, sequence diagrams, data structures and error handling. For the cart, it might propose a React Context provider with a useReducer pattern, a localStorage sync hook with debouncing, and TypeScript interfaces for CartItem and CartState.

Phase 3: Task List

The design gets broken into discrete, ordered implementation tasks with clear outcomes. Kiro tracks each task as in progress or completed while it works, and you can run them one at a time or all at once.

Only after you approve the documents does Kiro begin writing code. And because each task references the design and requirements, the generated code is traceable: you can see why a particular implementation choice was made.

This is the opposite of vibe coding. Where vibe coding says “just describe what you want and trust the AI,” spec-driven development says “define what you want precisely, verify the AI understood it, then let it execute.”

What Changed in Kiro Specs Since Launch

The spec system has grown a lot since the preview, and most of the old “too slow for small things” criticism targets a version that no longer exists:

  • Property-based testing (GA, November 2025): Kiro extracts properties from your requirements and generates hundreds or thousands of random test cases to check that the code actually does what the spec says. IDE only.
  • Bugfix specs and Design-First (February 2026): a bugfix spec records current, expected and unchanged behavior in bugfix.md so the fix doesn’t cause regressions, and feature specs can now start from the design instead of the requirements.
  • Quick Spec (May 2026): Kiro scans your workspace, asks clarifying questions about scope, constraints and edge cases, then generates requirements, design and tasks in one pass without approval gates.
  • Parallel tasks (May 2026): “Run all Tasks” builds a dependency graph, never runs tasks that touch the same files at the same time, and executes the rest in concurrent waves, each in its own context. Kiro reports, anecdotally, large specs dropping from over an hour to about a quarter of that.
  • Requirements analysis (May 2026): checks requirements for the wrong level of detail, ambiguity, inconsistency and incompleteness before design starts.
  • Markdown Review (all users since IDE 1.3.11, October 2026): comment on exact passages of a spec document and send all comments to the agent at once.

Specs also work in the CLI and in Kiro Web now, though property-based testing and requirements analysis are still missing from the web app, according to the specs docs.

Related: VS Code 1.109: How the IDE Became a Multi-Agent Development Platform

Hooks: Event-Driven Automation That Keeps Code Consistent

Kiro’s hooks changed shape with IDE 1.0. They are now versioned JSON files in .kiro/hooks/ that fire on events such as PostFileSave, PreToolUse, PostToolUse and Stop, optionally filtered by a file-path regex or tool matcher. The action is either a shell command, which receives session context as JSON on stdin, or an agent prompt injected into the conversation. Anyone who has written Claude Code hooks will recognize the pattern. Legacy 0.x hooks stop running until you migrate them from the Agent Hooks panel, and you can also create hooks by asking the agent in chat.

The docs’ own example runs ESLint whenever the agent saves a TypeScript file:

{
  "version": "v1",
  "hooks": [{
    "name": "Lint on save",
    "trigger": "PostFileSave",
    "matcher": "\\.(ts|tsx)$",
    "action": { "type": "command", "command": "npx eslint --fix" }
  }]
}

Practical uses:

  • Enforce standards: run linters, formatters or type checks after every agent file change
  • Gate risky operations: block a tool call unless preconditions hold (PreToolUse)
  • Generate companion files: create tests, docs or translations when new source files appear
  • Validate before finishing: check code quality before the agent wraps up, with an optional confirmation prompt on Stop

This solves a real problem in AI-assisted development. Without hooks, you write code and then separately remember to ask for tests, docs and type updates. With hooks, those steps happen every time. One cost to watch: agent hook executions consume credits like any other prompt, so an agent hook that fires on every save adds up. Command hooks that just run your linter are the cheap option.

Steering Files: Persistent Context for AI Behavior

Steering files are Markdown documents in .kiro/steering/ that tell Kiro’s agent how to behave in your specific project. They define:

  • Product context: What the application does, who uses it, what the business constraints are
  • Coding standards: Your team’s conventions for naming, error handling, logging and architecture patterns
  • Tech stack details: Which libraries to use, which to avoid, version constraints and integration patterns

Think of steering files as a persistent system prompt for every AI interaction in your project. Instead of repeating “use Tailwind, not styled-components” in every prompt, you write it once and Kiro follows it across specs, hooks and chat. Steering can also be global across all your workspaces, and IDE 1.4 (October 2026) added an optional Memory feature that carries context such as repo conventions between sessions. It is off by default.

This is similar in concept to context engineering for AI agents but implemented at the IDE level rather than the agent framework level. The practical benefit: onboarding a new team member means sharing the project’s steering files, and the AI immediately adopts your team’s conventions.

Related: Context Engineering for AI Agents: The Skill That Matters More Than Prompting

Kiro Pricing in October 2026

Kiro bills in credits, not unlimited seats. Earlier versions of this article described an unlimited free tier and a $19 Pro plan; neither exists now. Current plans from the pricing page:

PlanPrice per monthCredits per month
Free$050
Pro$201,000
Pro+$402,000
Pro Max$1005,000
Power$20010,000
EnterpriseContact salesCentralized billing, SSO, usage analytics

A credit is a unit of agent work, metered to two decimal places. Simple prompts can cost less than one credit; executing a spec task typically costs more. The model multiplies the cost: Kiro’s own example is a task that costs X credits on Auto costing 1.3X on Sonnet 4.6. Spec refinement, task execution and agent hooks all draw on the same pool. Paid plans can buy add-on credits at $0.04 each, and unused monthly credits don’t roll over.

Two discounts are worth knowing about. New users who upgrade through social login or Builder ID get $20 credited toward their first paid plan, prorated. Students get 1,000 credits a month free for a year. GovCloud (US) pricing runs about 20% higher, with no free tier.

How far 1,000 credits go depends heavily on how much you lean on specs, parallel tasks and agent hooks, which is exactly the work Kiro is built for. Watch the usage dashboard for the first month before choosing a tier.

Kiro vs. Spec Kit vs. OpenSpec: Spec-Driven Tools Compared

Kiro’s GA announcement claims it was “the first to bring spec-driven development to AI coding tools.” It is no longer the only one. These are the spec-driven tools people actually weigh it against in late 2026:

KiroGitHub Spec KitOpenSpecBMAD Method
What it isCommercial agentic IDE, CLI and web app (AWS)Open-source toolkit (MIT), v1.2.3Open-source CLI (MIT), v1.14Open-source agile method (MIT), v6.12 stable
CostFree tier (50 credits), $20 to $200 per monthFree; you pay for your agentFree; you pay for your agentFree; you pay for your agent
Where it runsKiro’s own IDE, CLI and browser app41 agents, including Copilot, Claude Code, Codex, Cursor and Kiro CLI30+ assistants via slash commandsYour AI coding tool, via npx bmad-method install or skills
Spec artifactsrequirements.md (or bugfix.md), design.md, tasks.mdConstitution, spec.md, plan.md, tasks.mdPer change: proposal, spec deltas, design.md, tasks.mdBriefs, specifications, architecture docs
Best forTeams that want the spec workflow built into the editorTeams on mixed agents who want gates and extensionsIterating on existing code with less ceremonyLarger initiatives that need product, architecture and UX roles

GitHub Spec Kit is the closest match in workflow and the opposite in packaging: instead of a new editor, it installs constitution, specify, plan, tasks, implement and converge steps into the agent you already use. It even lists Kiro CLI among its 41 integrations, so you can run Spec Kit’s gates inside Kiro’s terminal agent. Our Spec Kit tutorial covers setup and its limits.

Related: GitHub Spec Kit: How Spec-Driven Development Turns AI Agents from Vibe Coders into Engineers

OpenSpec (about 73,000 GitHub stars) keeps each change in its own folder and merges it into the living specs with /opsx:archive. Its README pitches against Kiro: “Powerful but you’re locked into their IDE and limited to Claude models.” The IDE half is weaker now that Kiro ships a CLI and a web app, and the Claude half is out of date, since Kiro’s model list includes GPT-5.6 and open-weight models.

BMAD Method (about 54,000 stars) is less a spec format than a full agile process with specialized perspectives for product, architecture, UX, development and testing. It sizes the process to the work: small changes go straight to build, while bigger initiatives get the full planning depth.

Two more names come up in searches. Intent has a coordinator agent write a “living spec” for each task and hands the pieces to several CLI agents running in isolated workspaces (Augment Code’s Intent page now redirects to intentapp.dev). Tessl, which Birgitta Böckeler’s October 2025 comparison grouped with Kiro and Spec Kit, now calls itself “the agent enablement platform” and focuses on agent skills rather than spec-driven coding.

If all you want is a reviewable plan before the agent edits files, you may not need a spec tool at all. Cursor’s Plan Mode and Claude Code’s plan mode both sit behind Shift+Tab and produce a plan you approve before any edits. What they don’t give you is a persistent requirements file with acceptance criteria that tasks trace back to. Cursor even keeps plans in your home directory unless you save them to the workspace.

Where Kiro wins: you want the spec workflow built into the editor with real UI around it (task status, Markdown Review comments, parallel waves, property-based tests) instead of Markdown files you drive by slash command. Enterprises that need SSO, model governance and GovCloud get them from one vendor.

Where Kiro loses: small changes, where Böckeler found the workflow “like using a sledgehammer to crack a nut” on a minor bug (before Quick Spec and bugfix specs existed). Credit-based pricing is harder to budget than a flat seat when you lean on specs and hooks. And you’re adopting a whole environment, while Spec Kit and OpenSpec fit into the agent you already use.

Who Should Actually Use Kiro

Kiro makes the most sense for three profiles:

Teams with strong conventions they want AI to follow. If your team has a style guide, architecture patterns and code review standards, steering files and hooks let you encode those rules once and have every AI interaction respect them. That is cheaper than catching convention violations in code review.

Developers building features against product specs. If you already write PRDs or user stories before coding, Kiro’s spec pipeline maps directly onto your existing workflow. The AI generates the technical plan from your product requirements, which means less translation loss between what product wants and what engineering builds.

Organizations that want enterprise controls from one vendor. Kiro Enterprise adds centralized billing, SSO and usage analytics. Administrators can connect IAM Identity Center (and, for Kiro Web, Okta or Microsoft Entra ID), use model governance to decide which models, including Auto, their developers may pick, and run Kiro in AWS GovCloud (US). Individual developers need none of that; a GitHub or Google login is enough.

If none of these describe you, Spec Kit or OpenSpec inside the agent you already use, or plain plan mode in Cursor or Claude Code, will likely serve you better. Kiro is a focused tool that’s excellent at what it’s designed for, not a general-purpose replacement for every AI coding workflow.

Related: Amazon Kiro AI Outage: 6.3 Million Lost Orders and the 90-Day Code Safety Reset

Frequently Asked Questions

What is Kiro IDE and who made it?

Kiro is a spec-driven agentic IDE built by Amazon Web Services (AWS) and based on Code OSS, the open-source core of VS Code. Before writing code, it generates requirements, a design document and a task list for you to review. It became generally available in November 2025 and now also runs as a CLI, a web app and a mobile app. Models include Kiro’s Auto router, Anthropic Claude models, OpenAI GPT-5.6 models and open-weight models.

Is Kiro IDE free to use?

Kiro has a permanent free tier with 50 credits per month and access to Claude Sonnet 4.5 and open-weight models. Paid plans are Pro ($20/month, 1,000 credits), Pro+ ($40, 2,000 credits), Pro Max ($100, 5,000 credits) and Power ($200, 10,000 credits), with add-on credits at $0.04 each. Spec work, task execution and agent hooks all consume credits.

What is spec-driven development in Kiro?

Spec-driven development is Kiro’s core workflow: before writing code, the AI generates three documents, a requirements file (or a bug analysis for bugfix specs), a design document and an implementation task list. You review each one before moving on. For well-understood features, Quick Spec generates all three in one pass after asking clarifying questions, and Kiro can run independent tasks in parallel. This catches misunderstandings before they become code.

How does Kiro compare to GitHub Spec Kit, OpenSpec and Cursor?

Kiro is a commercial product with its own IDE, CLI and web app and credit-based pricing. GitHub Spec Kit and OpenSpec are free, open-source toolkits that add a spec-driven workflow to coding agents you already use, such as Copilot, Claude Code, Codex or Cursor; Spec Kit is more thorough, OpenSpec lighter. Cursor optimizes for speed and offers a Plan Mode, but no persistent requirements-to-tasks pipeline. Kiro is the most integrated option, with parallel task execution and property-based testing built in.

What are Kiro hooks and steering files?

Hooks are JSON files in .kiro/hooks/ that run a shell command or an agent prompt when an event fires, such as the agent saving a file (PostFileSave), calling a tool (PreToolUse, PostToolUse) or finishing (Stop). Steering files are Markdown documents in .kiro/steering/ that define your project’s context, coding standards and tech stack, acting as persistent instructions for all AI interactions.