TL;DR: If your infrastructure lives in AWS, Kiro wins — its Powers system ships first-party CDK, SAM, and CloudFormation tooling that Cursor and Copilot only approximate with hand-configured MCP servers. Cursor 3 still runs the best agents, and Copilot has the lowest floor price. All pricing below verified July 24, 2026.

	Kiro Pro	Cursor 3 Pro	Copilot Pro
Best for	CDK/SAM/CloudFormation work, spec-first teams	Parallel agents, polyglot codebases	GitHub-centric teams on a budget
Price	$20/mo, 1,000 credits	$20/mo, ~$20 usage pool	$10/mo, $15 in AI credits
AWS integration	First-party Powers (IaC, SAM, observability, Transform)	Community MCP servers, manual config	MCP + GitHub Actions, manual config
The catch	Credits don’t roll over; IDE lock-in	Zero AWS-native tooling; agent credit burn	$15 of agent credits evaporates in days

Honest take: An AWS shop shipping CDK or SAM daily should run Kiro Pro and keep Copilot Free for completions. A team that touches AWS twice a month should stay on Cursor and wire up the two MCP servers below instead of switching IDEs.

Why this matchup, and why now

Three things changed since spring. Amazon closed new signups for the Q Developer IDE plugin on May 15, 2026 and pointed everyone at Kiro, its spec-first agentic IDE — we covered the transition in our Kiro review. Then Kiro overhauled its billing: the old two-rate system that charged spec requests five times the vibe-request rate is gone, replaced by a single credit pool with fractional metering, and a new $100/month Pro Max tier landed between Pro+ and Power. Meanwhile GitHub moved Copilot to AI-credit billing in June, which quietly repriced every agentic workflow on the platform.

So the question “which AI IDE should an AWS-heavy team standardize on” has a different answer than it did in May, and most of the comparisons floating around were written before any of this happened.

Pricing, verified July 24, 2026

Every number in this table comes from the official pricing pages today, not from memory or older articles.

Tier	Kiro	Cursor	GitHub Copilot
Free	$0 — 50 credits/mo (+500 bonus, 14 days)	Hobby — limited agent + tab	$0 — 2,000 completions, 50 chat
Entry paid	Pro $20 — 1,000 credits	Pro $20 — ~$20 usage pool	Pro $10 — $15 AI credits
Mid	Pro+ $40 — 2,000 credits	Pro+ $60 — 3× usage	Pro+ $39 — $70 AI credits
Heavy	Pro Max $100 — 5,000 credits	Ultra $200 — 20× usage	Max $100 — $200 AI credits
Top	Power $200 — 10,000 credits	—	—
Team seat	Enterprise: contact sales	$40 Standard / $120 Premium	Business/Enterprise: contact sales
Overage	$0.04/credit	On-demand, metered	$0.01/credit

Three billing details matter more than the sticker prices:

Kiro’s credit model changed. When we reviewed Kiro in May, spec requests cost 5× a vibe request — the “spec tax.” That split is gone. All requests now draw from one pool, billed fractionally in 0.01-credit increments based on task complexity, per Kiro’s pricing announcement. A short chat reply costs a fraction of a credit; a full autonomous spec execution costs many. Credits still don’t roll over month to month.

Cursor’s usage pool equals the plan price. Pro includes roughly $20 of model usage per month; Pro+ triples it for $60, Ultra runs 20× for $200. Cursor 3’s parallel agents — up to 8 at once in isolated worktrees — burn through that pool 3–5× faster than single-agent use, as we noted in our Cursor 3 review. Team seats are $40 (Standard) or $120 (Premium), 20% off annual.

Copilot’s $10 tier includes $15 of agent credits. Completions stay unlimited on paid plans, but chat, agent runs, CLI use, and code review all draw from the credit balance at $0.01 per credit. An afternoon of agent-mode work on a CloudFormation stack can clear $15. AWS-heavy teams doing agentic work on Copilot realistically need Pro+ at $39.

One AWS-specific footnote: Kiro subscriptions in AWS GovCloud (US) regions cost roughly 20% more than commercial-region pricing, and the free tier isn’t offered there at all. If you’re a government contractor, budget for Pro from day one.

AWS integration: first-party Powers vs do-it-yourself MCP

This is where the three tools actually diverge. All of them can talk to AWS through the Model Context Protocol. Only one of them treats AWS as a first-class citizen.

Kiro Powers

Kiro packages AWS tooling as Powers — curated MCP server bundles that activate on demand instead of sitting in your context window permanently. The published registry includes, among others:

• aws-infrastructure-as-code — CDK and CloudFormation authoring with validation and compliance checking
• cloud-architect — CDK-in-Python scaffolding that follows Well-Architected framework guidance
• aws-sam — Serverless Application Model development support
• aws-observability — CloudWatch Logs, Metrics, and Alarms in one bundle
• aws-devops-agent — incident investigation, cost optimization, architecture review
• aws-transform — .NET, COBOL, and SQL Server modernization
• aws-graviton-migration — Arm64 compatibility analysis

The on-demand activation solves a real problem we’ve hit repeatedly when testing MCP-heavy setups: load six AWS MCP servers into a normal client and their combined tool schemas eat a meaningful slice of your context before you type a word, degrading completion quality on long files. Kiro activates the relevant Power only when the task calls for it. You select a Power inside the IDE and it handles the MCP server configuration itself — no JSON editing.

Cursor and Copilot: the awslabs route

Cursor has no AWS-native tooling — by design. It’s cloud-agnostic, and AWS support means installing servers from the awslabs MCP collection, which officially documents Cursor, VS Code, Kiro, Windsurf, Cline, and Claude Code as clients. The one to start with is the AWS IaC MCP Server (it replaced the now-deprecated cdk-mcp-server), which adds CloudFormation validation, CDK guidance, and built-in security scanning. In Cursor’s MCP settings that’s:

{
  "command": "uvx awslabs.aws-iac-mcp-server@latest",
  "env": {
    "AWS_PROFILE": "your-aws-profile",
    "FASTMCP_LOG_LEVEL": "ERROR"
  },
  "disabled": false,
  "autoApprove": []
}

Once it’s running, Cursor’s agent can validate a template or security-scan a CDK stack before synth. The servers are stdio-only (SSE transport was removed back in May 2025), so they run locally against whatever AWS_PROFILE you point them at — which also means your existing IAM boundaries apply unchanged. Pair it with the AWS Pricing MCP Server and you’ve replicated maybe 60% of what Kiro’s IaC and pricing Powers do. See our MCP servers guide for the broader catalog.

Copilot takes the same MCP path with one genuine advantage: the Copilot coding agent runs inside GitHub Actions, so an AWS deploy pipeline that already lives in Actions can hand work to the agent without any new infrastructure. If your CI/CD is GitHub-native and your AWS access flows through OIDC roles in Actions, Copilot slots in with zero new credential surface.

The honest summary: everything Kiro does with AWS, Cursor and Copilot can approximate. But “approximate” means you maintain the MCP config, you watch the context bloat, you assemble the equivalent of aws-transform or aws-devops-agent yourself — and mostly you won’t.

Three real scenarios

Generic feature lists don’t decide tool choices; workloads do. Here’s how the three behave on the tasks AWS teams actually do.

Greenfield Lambda + API Gateway service. Kiro’s spec workflow — requirements.md, design.md, tasks.md, each reviewed before code — feels slow the first day and pays off by the first code review, because the agent commits to an architecture before generating 400 lines against the wrong one. With the aws-sam Power active it scaffolds SAM templates that validate on first deploy. Cursor gets working code on screen fastest, but on a multi-resource service the agent will occasionally drift — an inline IAM policy here, a hardcoded region there — and you catch it in review instead of in a spec. Winner: Kiro, unless the service is small enough to hold in your head.

Migrating a .NET monolith toward AWS. This one isn’t close. Kiro’s aws-transform Power wraps AWS’s actual modernization tooling for .NET, COBOL, and SQL Server workloads. Neither Cursor nor Copilot has anything comparable; you’d be prompting a general-purpose agent through a migration AWS has purpose-built tooling for. Winner: Kiro, decisively.

Updating an existing CloudFormation template. The middle ground. All three handle “add an S3 event notification to this stack” fine once the IaC MCP server (or Power) is wired up, because validation and drift-checking do the heavy lifting. Copilot’s edge: if the template lives in a GitHub repo with review requirements, the coding agent can open the PR, run the checks, and respond to review comments in one loop. Cursor’s edge: eight parallel agents can update eight stacks at once. Kiro’s edge is smallest here — spec-first is overkill for a ten-line diff, though its compressed Bugfix Spec flow keeps it tolerable. Winner: whichever you already pay for.

Where each one breaks

Kiro’s weaknesses are lock-in shaped. Powers are Kiro-only, specs are Kiro-conventions, and if AWS loses interest the way it did with Q Developer — a paid product given barely a year of runway once its replacement shipped — your team’s workflow muscle memory doesn’t transfer. Credits also expire monthly, so a light month is money burned. And it is an entire IDE: teams deep in JetBrains or a tuned VS Code setup are re-platforming, not adding a plugin.

Cursor’s weakness for this audience is simpler: AWS is just another API to it. You’ll maintain MCP configs by hand, and parallel agents that make Cursor shine on application code multiply credit burn on infrastructure work where most of the time goes to validation, not generation. Nothing in Cursor knows what Well-Architected means unless you paste it into a rule.

Copilot’s weakness is the credit math. The $10 Pro tier’s $15 allowance is fine for chat-and-completions, but agentic infrastructure work — long tool loops, template validation, retry cycles — consumes credits the way parallel agents consume Cursor’s pool. Budget $39/seat, at which point Kiro Pro+ at $40 with first-party AWS tooling is staring at you.

Who should not switch

Two groups should ignore Kiro’s pitch entirely. Teams mid-flight on Cursor 3 with parallel-agent workflows tuned — worktree isolation, background tasks, custom rules — are sitting on real switching costs, and Kiro’s agent orchestration is not yet at Cursor 3’s level. And teams whose AWS surface is a couple of S3 buckets and a CloudFront distribution get nothing from Powers they can’t get from one MCP server config pasted into their current editor.

Privacy-first teams have a third option we didn’t score here: Cline with a self-hosted model is the fully open-source route to agentic AWS work — aifoss.dev covers that stack. It’s more assembly, but nothing phones home.

Verdict

For an AWS-heavy team standardizing in July 2026: Kiro Pro ($20) for the engineers doing daily CDK, SAM, or migration work; Copilot Free or Pro underneath for completions; skip Cursor unless you’re polyglot enough that AWS is a minority of your codebase. The Powers registry is the moat — first-party, maintained by the vendor who owns the cloud, and activated without context bloat. Cursor 3 remains the better pure coding agent, and it’s what we’d pick for a team that ships to three clouds. Copilot remains the best $10 anyone spends on completions. But the question was AWS-heavy teams, and for them the tool built by AWS, with AWS’s own modernization tooling wired in, wins on the work that actually fills their sprints.

FAQ

Did Kiro really drop the “spec tax”? Yes. The old model billed spec requests at 5× the vibe rate. Kiro now meters all requests from a single credit pool, fractionally in 0.01-credit steps by task complexity. Heavy spec users effectively got a price cut; heavy chat users pay slightly more per interaction than the old flat rate implied.

Can Cursor generate CDK code without any MCP setup? It can generate CDK code from its model knowledge alone — but without the IaC MCP server it can’t validate templates, security-scan stacks, or check against current resource schemas, so you’re trusting training data for a fast-moving surface. Install the server; it’s one JSON block.

Is Kiro’s free tier usable for evaluation? For evaluation, yes: 50 monthly credits plus a 500-credit bonus in your first 14 days is enough to run a few full spec cycles on a real feature. It is not enough for daily work, and the free tier isn’t available in GovCloud regions.

What happened to Amazon Q Developer? New IDE-plugin signups closed May 15, 2026; existing paid subscriptions run until April 30, 2027. The newest models ship to Kiro only. Our Amazon Q Developer review covers what the outgoing tool did.

Sources

• Kiro pricing — official pricing page
• Announcing new pricing plans and Auto — Kiro blog
• Introducing Kiro Pro Max — Kiro changelog
• Kiro billing for individuals — Kiro docs
• Kiro Powers registry — kirodotdev/powers on GitHub
• AWS MCP Servers — awslabs/mcp on GitHub
• Introducing the AWS IaC MCP Server — AWS DevOps Blog
• GitHub Copilot plans — official pricing page
• Cursor pricing — official pricing page

Last verified July 24, 2026. Pricing and features change frequently; verify current state before purchasing.