If you've been using AI to write code, you've probably noticed that in 2026 there are more tools out there than ever — GitHub Copilot, Cursor that came later, Anthropic's Claude Code, AWS's Kiro, and Google's Antigravity. Each one is positioned a little differently, but a lot of people get tripped up trying to figure out which one is which.

Personally I mostly use VSCode with GitHub Copilot and Claude Code, and I've poked around with Cursor, Kiro, and Antigravity. Friends keep asking me which one they should pick, so this is my attempt at walking through the differences across all five so you can make the call based on your own workflow.

A quick intro to all five tools

Before the comparison, a fast pass on what each one actually does.

GitHub Copilot

GitHub Copilot is the AI coding assistant from GitHub (Microsoft). It launched back in 2021, which makes it kind of the OG of AI coding tools. It's integrated into VSCode and most major IDEs, and the core feature is real-time code completion and suggestions.

After 2025 Copilot changed quite a bit. Inside VSCode it now has Agent Mode, which can search across your codebase, modify multiple files, and run terminal commands automatically.

On top of that, GitHub released Copilot Coding Agent, which is a separate thing from Agent Mode. Coding Agent runs in a cloud environment on GitHub Actions — assign an Issue to Copilot or click "Send to Copilot Coding Agent" in chat, and it goes off and finishes the task in the background, then opens a PR for you to review. It even runs its own code review and security scan first (including Secret Scanning and dependency vulnerability checks), and only hands the PR over once those pass.

Cursor

Cursor is a code editor built around AI from the ground up. It's a fork of VSCode under the hood, so if you're already a VSCode user the switch is basically zero learning curve.

Cursor understands your entire codebase, and its Agent Mode can search files, run terminal commands, and edit across multiple files automatically. In 2026 Cursor also rolled out Background Agents, which clone your repo to the cloud and work on a separate branch — and you can spin up multiple agents to work on different tasks in parallel.

Claude Code

Claude Code is Anthropic's CLI (command-line interface) AI dev tool. Unlike the previous two, Claude Code isn't an editor or an editor plugin — it's a standalone terminal tool.

Basically, you open a terminal, type claude, and it starts understanding your project structure and can read, modify, and create files for you, even running commands. What makes Claude Code special is its support for Hooks, Skills, MCP Server, Channels, and other advanced features that let you compose all kinds of automated workflows around your needs.

If you're new to Claude Code, you might want to start with my earlier post Want to develop with Claude Code? This guide takes you from beginner to advanced — it has a much more detailed walkthrough.

Kiro

Kiro is AWS's AI dev tool. It's also a VSCode fork and it runs on top of Amazon Bedrock. The thing that sets Kiro apart from the rest is that it's built around Spec-Driven Development.

Before Kiro writes a single line of code, it first generates a complete spec document — requirements, system design, data models, task breakdown — and only starts implementing once you've signed off on it. The upside is every piece of code can be traced back to a specific requirement, which is genuinely useful if your project needs proper documentation.

Kiro also has its own Agent Hooks that can trigger an AI Agent automatically on file save, create, or delete events — handy for things like auto-formatting, doc updates, or running git commits. And Kiro's default Auto Agent mixes different models with caching and other optimizations to balance performance against credit consumption.

Google Antigravity

Google Antigravity is the AI development platform Google launched in November 2025 alongside Gemini 3. The base is also a VSCode fork, but the changes are extensive enough that it feels pretty different from regular VSCode.

Antigravity goes hard on the Agent-First approach. It has two main surfaces: a traditional Editor View where you write code, and a Manager Surface, where you can dispatch multiple agents to work asynchronously across different workspaces, watching each agent's progress in real time.

Once an agent finishes a task, it produces an artifact report — task list, implementation plan, screenshots, even browser recordings — so you can see what it actually did. Model-wise, beyond Google's own Gemini 3.1 Pro and Gemini 3 Flash, it also supports Claude Sonnet 4.6, Claude Opus 4.6, and GPT-OSS-120B.

That said, Antigravity is still iterating fast right now. Rate limits and pricing are in flux, so check the official site for the latest before you commit.

Core feature comparison

Now that you know what each tool does at a high level, here's how they compare on core features.

What the table tells you is that the five tools are converging on features, but each has a clear strength.

In short — Copilot leans on inline completion and GitHub ecosystem integration, Cursor focuses on the editor-native AI experience, Claude Code goes the terminal automation route, Kiro centers on Spec-Driven Development, and Antigravity wraps everything around an Agent-First multi-model architecture. None of them is objectively "better" — it really depends on which one fits your workflow.

Pricing breakdown

Pricing matters to most people, so here's the snapshot for March 2026:

Pricing follows each vendor's official site and can change at any time. GitHub Copilot also offers free Pro access for verified students and open source contributors.

And a quick word on each tool's billing model, because they all count things differently.

GitHub Copilot bills in Premium Requests — the number of times you hit the high-end models (Claude Opus 4.6, o3, etc.). Pro gets 300/month, Pro+ gets 1,500. Once you blow through the quota, Copilot doesn't cut you off — it falls back to the included base model (like GPT-4.1), but response quality drops noticeably. If you don't want the downgrade you can set an overage budget at $0.04 per request.

Cursor gives every paid plan a credit pool. Pro+ has 3x the usage of Pro, Ultra has 20x. If you let Cursor pick the model automatically (Auto mode), it doesn't burn credits — effectively unlimited. If you manually pick a specific model (say Claude Sonnet 4.6), that comes out of the credit pool. Once you're out of credits, you can still use Auto mode, you just lose manual model selection.

Claude Code is bundled into Claude's subscription. Max comes in 5x ($100/mo) and 20x ($200/mo) — the multiplier is relative to Pro, meaning how much more you can do before hitting limits. Max also covers the Claude desktop app, mobile app, and Claude Code together, which makes sense if you also use Claude for non-coding things (writing docs, research, etc.).

Kiro uses a unified credit system — every operation pulls from the same pool, billed by prompt complexity. A simple edit might be under 1 credit, while complex tasks cost more. Kiro's Auto Agent mixes models automatically and runs about 23% cheaper than manually picking Sonnet 4 for the same workload — that's why it's the default. Overage is $0.04 per credit, but it's off by default; you have to opt in via settings.

Antigravity is bundled into Google's AI subscription tiers (AI Pro and AI Ultra). You can also buy AI Credits separately at $25 per 2,500 credits. The pricing and quota strategy is still being adjusted, so double-check the official site before signing up.

So which one fits which scenario?

If you're still not sure which to pick after all that, let me sort them by use case.

You mainly care about the feel of writing code

If your day is mostly writing code and you want a fast, always-on assistant by your side, GitHub Copilot is probably the best fit. Its inline completion is still the smoothest of the bunch, the VSCode integration is the deepest, and it has matching AI features for PR review and Issue triage too — especially handy if your team is already deep into the GitHub ecosystem.

Plus, Coding Agent can handle background tasks and open PRs for you automatically, which is fantastic for team collaboration.

You want an AI experience inside the editor

If you do a lot of cross-file refactoring or you want the entire editor experience designed around AI, Cursor is the way. Composer handles multi-file edits really well, and it supports multiple AI models (Claude, GPT, Gemini, etc.) so you can pick the model that fits the task.

Frontend work is a great example — one feature often touches a bunch of files (component, styles, routes, tests), and Composer chews through all of it in one go. Background Agents also let you spin up multiple agents in parallel in the cloud.

You want deep automation and customization

If you live in the terminal or you need next-level automation and customization, Claude Code is the pick. The combination of Hooks, Skills, and Channels lets you compose all sorts of automated workflows.

For example, you can wire up Hooks to run security checks before every command Claude Code executes, or use Skills to package your team's code review conventions as a reusable skill set. Pair it with Git Worktree and you can even run multiple Claude Code agents on the same project, each handling a different task.

Channels in particular is something the other tools can't really match — you can send messages directly to a running Claude Code session over Telegram or Discord, let it work on the task in the background, and have the result delivered back to your phone.

If Channels sounds interesting, I wrote a full setup walkthrough here: Don't want to use the lobster (OpenClaw)? Try Claude Code Channels.

Your project needs strict documentation and spec management

If you're working on a project that requires complete documentation — client work, internal enterprise systems, anything that needs to pass an audit — Kiro's Spec-Driven Development fits perfectly.

Before any code gets written, Kiro produces requirements, system design, and a task breakdown, and every chunk of code traces back to a specific requirement. The upfront cost is higher, but in exchange your project has solid documentation from day one — maintenance and handoffs get a lot easier.

And since Kiro runs on AWS, if your team is already on Lambda, CDK, CloudFormation, or other AWS services, the integration is much smoother than the alternatives.

You want an Agent-First development experience

If you want to play with multiple AI agents working for you in parallel, Google Antigravity is worth a try. Manager Surface lets you dispatch multiple agents to different workspaces, and once they finish a task they produce an artifact report you can review.

The model lineup is also varied — beyond Google's own Gemini family, you can also use the Claude lineup and GPT-OSS series.

That said, like I mentioned earlier, even though Antigravity is a VSCode fork, the UI changes are extensive enough that it feels pretty different from regular VSCode, and it's still iterating fast — so factor that in.

The 2026 main event: AI Agent capability

In 2026 the competition has shifted from code completion to AI Agent capability. The basic idea is: AI shouldn't just answer your questions, it should be able to plan, execute, and even self-correct to finish an entire task on its own.

Here's how the five tools stack up on Agent capability:

The basic Agent features are now table stakes for everyone — the real differences are in the advanced features, and which direction each tool has taken. Pick whichever one matches your needs.

One thing worth calling out: Claude Code and Kiro both have the concept of event-driven automation, but they implement it differently. Claude Code Hooks fire before and after tool execution — useful for safety checks, formatting, that kind of thing. Kiro's Agent Hooks trigger on file events (save, create, delete) and you describe them in natural language, which is a lower bar to entry.

My own workflow

After all that, you might be wondering what I actually use day-to-day.

I mostly use VSCode with GitHub Copilot and Claude Code, and the workflow looks roughly like this:

1. Day-to-day coding — GitHub Copilot's inline completion handles the bulk of it
2. Feature work or refactoring — I open Claude Code and let it plan and handle the cross-file edits
3. Anything that needs automation — also Claude Code, paired with Hooks and Skills to keep output quality consistent

I've touched all five — GitHub Copilot, Claude Code, Cursor, Kiro, Antigravity. Cursor's editor experience is genuinely solid, but I'm too deep into the VSCode ecosystem at this point, and the Copilot + Claude Code combo covers most of what I need, so VSCode stays as my main driver.

If your budget only allows for one, here's my take:

• New to AI coding → GitHub Copilot (the free plan is plenty, students get free Pro)
• Want the best editor-native AI experience → Cursor (Composer is great for cross-file edits, Background Agents are powerful too)
• Prefer terminal or need deep automation → Claude Code (also has a VSCode extension; Hooks + Skills + Channels is a flexible combo)
• Project needs full spec docs → Kiro (Spec-Driven Development takes you from spec to implementation in one flow)
• Curious about Agent-First development → Google Antigravity (free plan is enough to play with)

Wrapping up

Whichever one you end up picking, one thing stays true: A better tool is still just a tool. Your domain knowledge and judgment are what really matter — even with all the driver assists in the world, you still need to understand the car, the road, and the rules.

AI coding tools can help you write code faster, but they won't make decisions for you, and they won't take responsibility for the outcome.

So when you're using these tools, keep your critical thinking on. Review what they suggest, test it, and make sure the final code is safe and reliable.

Hopefully this helps you find the AI coding tool that fits your workflow best — see you in the next post.