The Shift You Can’t Ignore
A year ago, AI coding assistants were autocomplete on steroids. You’d type a function signature, and the tool would guess the body. Useful but fundamentally passive.
That era is over.
The tools available today are agents. They don’t wait for you to type. They read your project, reason about what needs to happen, make a plan, write the code, run the tests, fix the failures, and come back with a working result. Some of them do this in cloud sandboxes while you’re reviewing a different feature.
If you’re building cloud projects, for example deploying infrastructure, writing Lambda functions, building APIs, configuring services, these tools don’t just save time. They change the kind of projects you can take on alone.
Here are five worth knowing, how they differ, and the protocol that connects them all.
1. Claude Code
What it is: Anthropic’s agentic coding tool, available as a CLI, a VS Code extension, a JetBrains plugin, and a standalone desktop app.
Why it matters for cloud projects: Claude Code isn’t just an editor feature but a layered agentic system. It separates memory, hooks, skills, subagents, and MCP into distinct layers, each changing what the model can see or do.
When you’re building a serverless API, you don’t just ask Claude Code to “write a Lambda function.” You give it a goal: “build an API Gateway endpoint that takes a PDF, extracts text with Textract, summarizes it with Bedrock, and stores the result in DynamoDB” and it plans the approach, writes the handler, generates the IAM policy, creates the SAM template, and runs sam build to verify it compiles.
The subagent capability is where it gets powerful for larger projects. You can spin up multiple Claude Code agents working on different parts of your stack in parallel, one on the frontend, one on the backend, one on the infrastructure, each with its own context window and working memory.
Standout feature: Skills: reusable instruction sets you can create and share. Write a skill that encodes your team’s CDK patterns, IAM guardrails, or naming conventions, and every future Claude Code session follows them automatically. It’s institutional knowledge made executable.
2. Kiro
What it is: Amazon’s agentic IDE, built on top of VS Code with Bedrock models powering the agents.
Why it matters for cloud projects: Kiro takes a fundamentally different approach from every other tool on this list. Where others start with code, Kiro starts with specs.
When you describe a feature, Kiro doesn’t immediately generate code. It first writes a requirements document, then a technical design, then breaks everything into a numbered task list. Only then does it start writing code, and it does so against the spec, not just the prompt. This spec-driven development means the agent can implement more complex features in fewer shots because it has explicit documentation of what it’s building and why.
For cloud projects, this changes the game. Instead of “write me a Step Functions workflow,” you describe the business requirement (”process incoming invoices, classify them, route high-value ones for approval”). Kiro generates the spec, designs the architecture (which Step Functions states, which Lambda functions, what DynamoDB schema), and then implements each task in sequence.
Standout feature: Parallel agents with specs: Kiro can run multiple agents simultaneously, each working on a different task from the spec. Property-based tests catch edge cases that unit tests miss. The spec acts as the contract between agents, so they don’t step on each other.
3. Cursor
What it is: An AI-native IDE (forked from VS Code) that made “agent mode” mainstream.
Why it matters for cloud projects: Cursor pioneered the idea that your IDE should have an agent window alongside your file tree. Since Cursor 3.0, the Agents Window lets you launch multiple agents, each in its own worktree, each with its own model and mode. One agent can be planning a refactor with Opus while another implements a different feature in parallel.
The Cloud Agents feature (Cursor 3.5) is the headline for cloud builders. These agents run in isolated cloud VMs with full terminal, browser, and desktop access. They can work across multiple repos in parallel and report results back to your IDE asynchronously. This means you can kick off an agent to set up a complete CI/CD pipeline in one repo, deploy a CloudFormation stack in another, and review both results when they’re done, without your local machine doing any of the work.
Standout feature: Background agents in cloud VMs: fire off complex infrastructure tasks (Terraform plans, CDK deployments, integration test suites) and they run in the cloud while you keep coding locally. You review the output when it’s ready.
4. Codex
What it is: OpenAI’s coding agent, now powered by GPT-5.2-Codex and running as both an in-IDE tool and a standalone app.
Why it matters for cloud projects: Codex has evolved from a code completion model into a full autonomous agent. The latest version can operate your computer alongside you, meaning it doesn’t just write code, it interacts with terminals, browsers, and cloud consoles.
For cloud builders, the most relevant capability is long-horizon work. Codex is optimized for tasks that span many files and many steps, exactly what cloud projects demand. A migration from one database to another, a refactor of a monolith into microservices, converting CloudFormation templates to CDK, these are multi-hour, multi-file tasks that Codex can handle with its context compaction and improved handling of large code changes.
The Codex app supports coordinating teams of agents across the full lifecycle: designing, building, shipping, and maintaining software. You can assign one agent to write the Lambda functions, another to write the tests, and a third to configure the deployment pipeline, and they coordinate through shared context.
Standout feature: Full lifecycle coordination: from design to deployment to maintenance, with agents that can learn from previous actions and remember your preferences across sessions.
5. GitHub Copilot
What it is: GitHub’s AI pair programmer, now with full agent mode and deep GitHub integration.
Why it matters for cloud projects: Copilot’s advantage isn’t just the model, it’s the platform integration. Copilot lives inside the GitHub ecosystem: pull requests, issues, code review, Actions workflows, and the security graph. When you ask Copilot to work in agent mode, it can create branches, open PRs, run CI checks, and iterate on failures, all within the GitHub flow your team already uses.
The agent mode is genuinely agentic: it executes multi-step workflows independently, chooses appropriate tools based on context, and iterates based on feedback and results. For cloud projects, this means you can describe an infrastructure change, Copilot writes the Terraform, opens a PR, the CI pipeline runs terraform plan, Copilot reads the plan output, and fixes any issues, all before you review.
Standout feature: Agent Skills: reusable, domain-specific bundles of knowledge and tool usage that Copilot loads automatically when relevant. You can create skills for your team’s AWS patterns, security policies, or deployment conventions. Skills compose with MCP servers, so a skill can both encode prompting logic and call external tools.
The Thread That Connects Them: MCP and Skills
You’ve probably noticed two terms recurring across all five tools: MCP and Skills. This isn’t a coincidence, they represent the two layers that are standardizing how AI coding agents work.
MCP — Model Context Protocol
MCP is an open protocol that lets any AI agent connect to any external tool through a single standardized interface. Think of it as USB-C for AI: instead of writing a custom integration for every tool your agent needs to talk to, you expose the tool once as an MCP server, and any MCP-aware agent can use it.
For cloud builders, this is transformative. An MCP server for AWS means your coding agent can query CloudWatch logs, read DynamoDB tables, check deployment status, or fetch secrets from Secrets Manager, all through the same protocol, regardless of whether you’re using Claude Code, Kiro, Cursor, Codex, or Copilot.
MCP servers are already available for AWS services, databases, monitoring tools, and CI/CD platforms. The ecosystem is growing fast because the investment is write-once: build an MCP server for your internal tool, and every AI coding agent your team uses can immediately access it.
Skills — Portable Knowledge
Skills take different forms across tools (Claude Code calls them “skills,” Copilot calls them “agent skills,” Kiro uses “specs”), but the concept is the same: reusable instruction sets that encode how your team builds software.
A skill might encode:
Your team’s CDK patterns and naming conventions
Security guardrails (no wildcard IAM policies, encryption at rest required)
Architecture preferences (EventBridge over SNS for event routing, DynamoDB over RDS for session storage)
Deployment standards (blue-green only, canary for Lambda)
Skills are the bridge between “AI that writes code” and “AI that writes code the way your team writes code.” Without skills, every agent session starts from zero. With skills, institutional knowledge persists.
The Bottom Line
These five tools aren’t competing to be the best autocomplete. They’re competing to be the best engineering partner, one that understands your cloud architecture, follows your team’s standards, connects to your infrastructure, and works autonomously on complex tasks while you focus on the decisions that matter.
The advice? Don’t pick one and ignore the rest. Try them on a real project. The cloud space moves fast, and the tool that fits your workflow today might not be the one you expected.
Start building. The agents are ready.