May 20, 2026

AWS Kiro IDE review 2026: spec-driven development, the $0.20 credit tax, and when it beats Cursor

By AICoderScope Team · 12 min read

kiroawsreviewcursorcomparisonpricingworkflowagentic

Amazon Q Developer IDE is dead. New signups closed on May 15, 2026 — five days ago. Full end-of-support for paid subscriptions lands April 30, 2027. AWS is putting everything behind its replacement: Kiro, an agentic IDE that launched preview in July 2025, attracted 250,000 developers, and makes a bet so specific it will either look visionary or foolish in 12 months.

The bet: developers generate too much code before they’ve thought the problem through. Kiro forces you to write a spec — requirements, design, tasks — before touching a line of implementation. Only after you’ve reviewed and approved the plan does the agent start coding.

That workflow is genuinely different from every other AI IDE on the market. Whether it’s different in a way that’s worth $20, $40, or $200 a month depends entirely on what kind of code you’re shipping.

This review covers verified pricing, the credit model, the actual workflow, where it beats Cursor, and where it plainly doesn’t.

What Q Developer shutdown means for you right now

If you’ve been on Q Developer Pro, you can keep your subscription and keep adding users until April 30, 2027. No forced migration yet. But AWS has drawn a clear line: the latest coding models — including Claude Opus 4.7, which arrived on Kiro May 7, 2026 — are Kiro-exclusive. Q Developer Pro still has Opus 4.5 and existing models. It won’t get Opus 4.7 or anything newer.

AWS console Q Developer (the chat assistant inside the AWS Management Console), Slack/Teams integrations, and the marketing/documentation site assistants are not affected by this sunset. Those continue.

The IDE plugin you’ve been using in VS Code or JetBrains is what’s going away. If you want AWS’s newest models with agentic coding, Kiro is the only path.

The spec-driven premise

Kiro’s core insight is that most AI coding mistakes aren’t coding mistakes — they’re architectural mistakes that happen before a line of code is written, then get discovered at 400 lines in when an entire feature needs to be torn up.

Spec-driven development runs through three sequential artifacts:

requirements.md captures what you’re building using EARS-style notation (Easy Approach to Requirements Syntax): user stories, acceptance criteria, edge cases. Kiro generates a draft from your prompt; you review and edit it.

design.md covers technical architecture: system components, data flow, API contracts, database schema, and integration points. Again, Kiro drafts it; you approve or revise.

tasks.md breaks the design into sequenced implementation steps with explicit dependencies. Each task maps to specific files and functions. This is what the agent actually executes.

The idea is that design mistakes cost minutes to fix at the requirements stage and days to fix after implementation. On a feature that touches five tables, three API endpoints, and two frontend components, this is obviously true. On a feature that changes a button label, it is obviously overkill.

Kiro acknowledges this with two entry points: Feature Specs for the full three-phase workflow, and a Bugfix Spec that uses a compressed diagnosis-then-fix variant. For quick questions and small edits, Vibe Mode skips specs entirely — it’s a standard AI chat interface, conceptually identical to Cursor Chat.

Pricing: the credit model

As of March 19, 2026, Kiro’s pricing:

Tier	Price	Credits/month	Effective cost/credit
Free	$0	50 (+ 500 bonus first 30 days)	—
Pro	$20/mo	1,000	$0.020
Pro+	$40/mo	2,000	$0.020
Power	$200/mo	10,000	$0.020
Overage	Pay-per-use	—	$0.04/credit

Two request types consume credits at different rates:

Vibe requests (chat, quick edits): $0.04/credit = one request per credit
Spec requests (multi-phase spec generation and execution): $0.20/credit = five times the cost

Kiro’s “Auto” mode — the default in the chat window — routes tasks across multiple models including Claude Sonnet 4 and specialized routing models. Auto consumes 1.3× the credits of running Sonnet 4 directly on the same task.

The math on Pro: 1,000 credits works out to roughly 1,000 Vibe-mode requests, 200 Spec-mode requests, or a realistic mix of ~700 Vibe and ~150 Spec per month. Compare that to Q Developer Pro at $19/month, which gave roughly 1,000 standard requests with no credit-splitting complexity. If you were a heavy Q Developer Pro user, Kiro Pro at $20 delivers meaningfully less volume, with the billing complexity of monitoring two different request types.

First-time upgraders get a one-time $20 credit applied to their subscription. New signups also receive 500 bonus credits valid for 30 days, giving you a genuine two-week window to evaluate Spec mode before paying.

AWS Startups members can get up to one year of Kiro Pro+ complimentary through the AWS Startups network — worth verifying on the Kiro pricing page if you qualify.

Models available

Paid tiers (Pro, Pro+, Power) get access to:

Claude Opus 4.7 with adaptive thinking (added May 7, 2026) — Kiro-exclusive, not on Q Developer
Claude Opus 4.6 and Claude Sonnet 4.6 — both with 1M context windows
Claude Sonnet 4 and Claude Haiku
GLM-5 — a sparse MoE model with 200K context, useful for repository-scale context

Auto mode blends these behind an intent-detection layer, selecting models based on task complexity. You can override and specify a model directly in settings.

Agent Hooks: automation that actually runs

Agent Hooks are the feature that most reviews undersell. They let you define actions that fire automatically when IDE events occur:

File events: file created, saved, deleted
Lifecycle events: before/after a prompt is submitted, before/after a tool runs, when the agent stops
Spec events: before/after a spec task executes
Manual triggers: run a hook on demand

Each hook can run either a predefined agent prompt or a shell command. Practically, this means you can configure Kiro to auto-generate unit tests when a file is saved, run a security scan when a new file is created, or validate API contracts before a spec task completes — all without manual invocation.

This is a real workflow capability, not a marketing feature. Cursor doesn’t have an equivalent built-in hook system. Building this kind of automation with Cursor requires external scripts and task runners.

The catch: Agent Hooks are most useful when you’ve already committed to Kiro’s workflow. Teams that use Kiro as an occasional overlay on top of Cursor won’t bother configuring hooks. The payoff scales with commitment.

Autopilot vs Supervised mode

Kiro offers two execution modes for all agent tasks:

Autopilot — the agent makes changes across your codebase, executes tool calls, and completes tasks with minimal interruption. You review the result when it’s done.

Supervised — the agent pauses for your approval after each turn that includes file edits. You see exactly what it’s about to do before it does it.

For complex multi-file features in production codebases, Supervised is the sane default. Autopilot is best on greenfield features or contained modules where unexpected file edits have limited blast radius.

Kiro vs Cursor: the honest comparison

These two tools represent different theories about where AI development failures happen.

	Kiro Pro	Cursor Pro
Price	$20/mo	$20/mo
Credits/requests	1,000 credits (~700 vibe + ~150 spec)	Unlimited standard AI usage
Tab autocomplete	Basic	Supermaven model, ~72% acceptance rate, sub-200ms
Agentic approach	Spec-first: plan → review → implement	Prompt-first: immediate multi-file Agent mode
Structured planning	Built-in (requirements.md / design.md / tasks.md)	Plan mode (less enforced, no artifact output)
Agent hooks	Native (file events, lifecycle, spec tasks)	Not built-in
Extension compatibility	Open VSX only	Full VS Code Marketplace
MCP support	Native	Native
Models	Opus 4.7, Opus 4.6, Sonnet 4.6 (1M ctx), Auto	Claude 3.7 Sonnet, Gemini 2.5 Pro, GPT-4.1, others
GovCloud	Available since Feb 2026	Not available

The extension gap is a real pain point. Kiro is built on Code OSS and supports Open VSX plugins — the open-source extension registry. Extensions that are exclusive to the VS Code Marketplace won’t work. For developers whose workflow depends on Marketplace-only extensions (and there are many), this is a hard blocker until those extensions either appear in Open VSX or Kiro adds Marketplace support.

On tab autocomplete, Cursor is in a different category. Kiro’s inline completion is functional but not particularly fast or context-rich. If you’re used to Cursor’s Supermaven-backed completions triggering in under 200ms with multi-line suggestions, Kiro’s tab experience feels like a step back. Kiro is not primarily a completion tool — it’s an agent tool. But you still spend most of your coding time editing, not running agents, and that’s where the gap shows.

The Spec Tax: when it’s worth it

A 5× credit premium for Spec mode over Vibe mode is the most significant pricing decision Kiro has made. It creates a real question you have to answer before each feature: is this task spec-worthy?

The tax is worth it when:

The feature touches more than 3-4 files and has non-obvious dependencies
You’re in a regulated environment where requirements documentation is mandatory regardless of the AI tool
You’ve had an AI agent write 500 lines toward the wrong design before and want to prevent that at the requirements stage
You’re building on top of AWS services where Kiro’s architecture-first design catches IAM, DynamoDB schema, or Lambda handler issues before they’re baked in

The tax is not worth it when:

You’re fixing a bug with a clear root cause
The change is stylistic or presentational
You already know the design and just need implementation help
You’re prototyping and expect to throw it away

One independent developer estimated Kiro makes them “50-75% more productive for design-first, production-conscious work” — explicitly noting this is below the 2-4× claims common in vibe-coding marketing. That’s an honest number for the workflow Kiro is actually built for.

What’s missing

No native AWS service integration — and this is the strangest gap. An IDE built by AWS to replace Q Developer does not deeply integrate with AWS services the way Q Developer did. You don’t get console error diagnostics, CloudFormation-aware suggestions, or IAM policy analysis built in. You can add MCP servers (including the AWS MCP server) to compensate, but it’s not pre-configured. For a $20/month AWS product, this is a real omission.

Credit forecasting — consumption rates aren’t consistently published per operation type. Users coming from Q Developer’s request-counting model will find the credit system harder to predict. Checking your credit burn daily until you calibrate is necessary.

Context loss on task failure — in early access, tasks getting stuck required a full restart with lost context. The May 6, 2026 update introduced parallel Spec task execution and Quick Plan mode, which reduced retry overhead, but complex multi-file tasks still occasionally require restarts.

The AWS trust deficit — Hacker News threads about Kiro reliably include some version of “AWS kills developer tools.” Q Developer is literally being shut down right now, which doesn’t help. Teams considering a deep integration with Kiro’s spec artifacts and hooks are making a multi-month workflow investment; that’s harder to do when AWS has a track record of pivoting developer products.

Honest take

Kiro is the right tool for a specific developer in a specific situation: building non-trivial features on AWS infrastructure in environments where upfront design documentation is either required or repeatedly bitten you before.

If you fit that description, the $20 Pro plan is justifiable. The spec-driven workflow genuinely catches design mistakes early, Agent Hooks add automation that Cursor can’t match out of the box, and Opus 4.7 with adaptive thinking on the same Pro plan you get from Cursor is a meaningful model access advantage.

If you’re a solo developer doing rapid iteration, bug fixes, or exploratory work, pay $20 for Cursor instead. The tab autocomplete is better, the extension compatibility is better, and the model roster at $20 is comparable. The common pattern among developers who’ve tried both is telling: Kiro for structured feature planning on complex projects, Cursor for daily driving.

For the Amazon Q Developer users who now need to migrate: the Kiro free tier gives you 500 bonus credits for your first 30 days — enough to run a real Spec workflow on one meaningful feature and decide if the approach fits your team. The migration docs are at kiro.dev/docs/migrating-from-q-developer/. Don’t wait until April 2027 to make the call.

1V1 STARTER KIT · CURSOR

Skip the week of trial-and-error setting up Cursor.

12 production-tested .cursorrules templates, 3 workflow configs, the cost-control checklist. Everything I wish I had on day one.

Get it for $19 (early bird) →

Sources

Last updated May 20, 2026. Pricing and features change frequently; verify current state at kiro.dev before purchasing.

Was this article helpful?