Amp vs Claude Code: I ran both on the same Python task

You're on Claude Code and you've heard about Amp. You want to know if it's worth the switch, not another feature table.

Short version up top.

TL;DR

Amp is Sourcegraph's coding agent. It routes across models automatically, picking a cheap model for small work and a frontier model for real reasoning. Claude Code is Anthropic's agent. It's Anthropic-only.

Stay on Claude Code if you live in the Claude ecosystem and want one predictable bill against a model you understand. The $20 Pro or $100 Max plan caps your spend.

Look hard at Amp if what you've always wanted is automatic model switching, or if you want to point an agent at AI subscriptions you already pay for. Amp subscribers can link a ChatGPT or X Premium+/SuperGrok subscription and use those tokens with no per-token fee on top. Parallel agent runs ("orbs") are visible out of the box.

Most people reading this don't need to switch. They need to know what Amp does that Claude Code doesn't, and where both fall down. So that's the rest of this, including a real run where both agents choked on the same thing.

What Amp actually is

Amp is the successor to Cody, Sourcegraph's old assistant. It launched May 2025. Cody Free and Pro were shut down in July 2025.

In December 2025 Amp spun out as its own company, led by Quinn Slack, the Sourcegraph co-founder. It is now the main product of that company.

It runs in the terminal and in your editor: VS Code, Cursor, Windsurf, JetBrains, Zed, Neovim. You can run it headless with amp -x.

The pitch is simple. Amp uses the best model for each job instead of locking you to one. That's the whole identity.

I ran both on the same task

I gave both the same real job, straight from my actual backlog: a Python agent built with FastMCP, wired into an agent-SDK web chat app.

Amp got it built. Start to finish took me two days, which for a multi-agent setup with an MCP server and a web frontend is fast. I was impressed.

On cost, I'll be straight with you: I'm not going to hand you a per-task dollar figure, because I didn't capture a clean before-and-after on my credit balance and I'm not going to invent one. What I can tell you is how it felt. Amp felt expensive. Claude Code and OpenAI both subsidise their own models inside their own products, and that subsidy is doing a lot of quiet work to make those tools feel cheap. Amp passes the real inference cost straight through. So you're seeing the unsubsidised number, and the unsubsidised number stings. Amp's pricing is honest pass-through, and it's the thing nobody warns you about when they say "zero markup," because zero markup also means zero subsidy.

The model switching is the part I'd actually switch for. It's the optimisation I've wanted from Claude Code since day one. You're not paying top-tier rates to rename a variable. Amp drops to a faster, cheaper model for the small stuff and saves the heavy reasoning for when it matters. A lot of engineers have quietly wished for exactly this, and Claude Code still doesn't do it out of the box.

The thread model is nicer to live in. Every interaction is saved as a thread you can reopen and share. Claude Code keeps history too, but it's buried. Amp puts it in front of you.

Parallel agents are where the CLI earns its keep. When Amp spins up subagents you can watch each one's progress. In Claude Code you're bolting on TUI plugins to get the same view. Out of the box, Amp just shows you.

What broke: ruff

The failure that taught me the most was about terminal agents in general.

Amp choked on ruff. It couldn't get the Python linting right, threw bad errors, and I couldn't get it to a clean state no matter how I prompted. Frustrating.

So I tried the same thing in Claude Code. It couldn't find or fix the ruff warnings either.

Then I opened it in Cursor and it handled ruff fine.

Cursor has an unfair advantage on this specific class of problem, and the advantage is the IDE. Cursor sees the linter output inline, live, the moment it fires. A terminal agent has to run ruff, read the output, and reason about it from text. An IDE agent is sitting inside the surface where the squiggly red line already exists.

So if your work is lint-heavy Python and that tight feedback loop matters, neither CLI agent is going to feel as good as the editor. It's a terminal-agent problem, and it follows the category rather than either product. Worth knowing before you pick a tool for that kind of work.

How each one handles context and models

This is the real architectural split, not a spec sheet.

Amp routes across providers. You don't manage any of this. Amp picks the model per mode, and the subagents run their own models underneath.

The named modes changed since June: deep, smart, and rush became a low/medium/high/ultra ladder, and each rung now pairs an Agent model with an Oracle model rather than running a single one. The models underneath turned over almost completely too: Gemini has dropped out of the default routing, GLM-5.2 has appeared at the cheap end, and Anthropic's Fable 5 sits at the top. If you read this post in June, throw away the old mapping. This is the routing table Amp is running now, and given the churn it's worth checking ampcode.com/models yourself before making a decision on it.

One practical consequence: Amp's own pricing FAQ says Anthropic models are the main reason high and ultra cost more, and those two modes need either a Gigawatt subscription, added paid credits, or your own Anthropic API key.

Amp's Librarian is the differentiator most people miss. It's a subagent that searches remote codebases without leaving your session: all public GitHub plus your connected private repos. It rides Sourcegraph's code-intel infrastructure, which is the one thing Sourcegraph has always been good at. Ask it to go read how a framework you depend on actually works, and it will.

Claude Code is local-first. It walks your filesystem, reads files, greps on demand. No pre-built index. It reads CLAUDE.md for guidance and supports subagents with their own context windows. You can bolt on remote or semantic search through MCP servers, but it's not native the way Amp's Librarian is.

Anthropic's own engineering blog is honest about the core limit: Claude Code's ability to help in a big codebase is bounded by its ability to find the right context. Too much and performance drops. Too little and it's blind. That's the problem the Librarian is built to solve.

The models tell the rest of the story. Amp is multi-provider by design. Claude Code is Anthropic-only: Sonnet by default, Opus on Max plans and via API, no OpenAI or Google models. If model choice matters to you, that's a one-sided difference, and note it now runs in the other direction too, since Amp reaches for Anthropic's top model at its high and ultra modes while Claude Code can't reach for anyone else's.

What each one costs

This is the sharpest contrast, and it moves, so check both pages before you commit.

Amp: subscription or credits

This is the part that changed most since June, and it changed in the direction of Claude Code.

Amp now sells two subscriptions, both marked beta. Megawatt is $20/month: all product features, 750 hours of small orbs, at least $20 of included agent usage, and access to low and medium modes only. Gigawatt is $200/month: everything in Megawatt plus 1,000 hours of large orbs, at least $200 of included agent usage, and all modes including high and ultra. Amp's wording is "at least the subscription cost per month in agent usage", so the floor is your money back in tokens, and heavy patterns may get more.

The old model hasn't gone away. You can still pay as you go at raw API pricing for everything, with no subscription and no commitment, and that's still zero markup for individuals and non-enterprise workspaces: a thread that incurs $2 of Anthropic usage and $0.50 of OpenAI usage deducts $2.50 from your balance. If you burn through a subscription's included usage, you top up with paid credits until it replenishes at the end of the month.

Two things in the subscription are genuinely different from anything Claude Code offers. The first is orb hours. Orbs are Amp's sandboxes for parallel agents, and the plans are priced in hours of them precisely so you stop counting minutes. The second is bring your own AI subscription: link a ChatGPT or X Premium+/SuperGrok account and Amp subscribers pay no per-token fee on usage routed through it, up to whatever that third-party subscription allows. If you already pay OpenAI $20 or $200 a month, that's a real reduction in what Amp costs you on top.

Limits worth knowing: high and ultra modes aren't available on Megawatt unless you add paid credits, each person can hold at most two subscriptions, and you can't resell the quota. Enterprise moved to usage-based pricing with bring-your-own inference keys, SSO and directory sync, and zero data retention. The old "+50% and a one-time $1,000 unlock" is gone from the page.

The free tier is still the weak spot. It was $10/day in credits, roughly $300/month, replenished hourly and ad-free from March. Amp started pausing or reducing it on May 23, 2026 for less-active users and people on older clients, and it hasn't come back as a dependable way in. Plan on paying: the $20 Megawatt plan is now the realistic trial, not a free grant.

Claude Code: subscription with caps

Claude Code is a subscription. Pro is $20/month, Max 5x is $100, Max 20x is $200. Usage runs against a 5-hour rolling window plus weekly caps, shared across Claude Code, Claude.ai chat, and Cowork. Hit the ceiling and you're throttled, not charged.

Two things worth knowing. Anthropic doubled the 5-hour limits on May 6, 2026, and removed the peak-hours reduction for Pro and Max. And every paid plan has an opt-in extra-usage toggle: when you hit your included limit you can choose to continue at API rates with a spend cap you set.

Which means the "Amp meters, Claude Code throttles" line I opened with in June has now collapsed from both directions. Claude Code can meter if you let it, and Amp will happily sell you a flat $20 or $200 a month. The two products have converged on the same shape: a monthly fee that includes a chunk of usage, with pay-as-you-go underneath when you exceed it. Pick on models and features, not on billing philosophy.

If you'd rather pay per token directly, Claude Code runs on the Anthropic API: Opus 5 and Opus 4.8 at $5/$25 per million in/out, Sonnet 5 at $3/$15 (introductory $2/$10 through 2026-08-31), Haiku 4.5 at $1/$5.

For reference, Anthropic's own docs put measured Claude Code spend at roughly $13 per developer per active day, $150 to $250 per developer per month, with most users under $30/day. That's real spend, not an estimate.

The honest cost read

Amp shows you a number that ticks as you work. Some people find that clarifying. Others find it stressful. The HN threads on Amp are full of both: engineers who love seeing exact per-task cost, and engineers who spent $5, then $10, then $20 in single sittings and got nervous watching the meter.

Claude Code hides the meter behind a flat fee. You trade visibility for predictability.

Neither is cheaper in the abstract. On pay-as-you-go, Amp is cheaper if your usage is light and bursty, and Claude Code is cheaper if you're a heavy daily user because the flat rate amortises and cache reads are bundled. Now that Amp sells subscriptions at the same $20 and $200 price points, the comparison at those tiers comes down to what each includes: Claude Code gives you rate-limited access to Anthropic models, Amp gives you at least your money back in metered usage across a wider model set plus orb hours, but caps Megawatt to low and medium modes, so the $20 tiers are not buying you the same class of model.

One thing the credit model exposes that the subscription hides: the real, unsubsidised cost of inference. Claude Code and OpenAI both subsidise their own models inside their own products. Amp passes the raw provider cost straight through. So Amp can feel more expensive even when it isn't marking anything up, because you're seeing the number the subscription is quietly absorbing for you.

Where each one breaks

The real failure modes for both tools, because a comparison that only lists wins is marketing.

Claude Code burned limits too fast in early 2026. Users flooded GitHub and Reddit in March reporting the 5-hour limits exhausting faster than expected. One measured suite (WOZCODE, May 2) hit 161 turns versus 52 on the same 11 prompts depending on config, with people hitting the cap before lunch. Even after the May 6 doubling, heavy agentic tool use drains faster than chat does. The "before lunch" framing is aggregated from user reports; the turn counts are the measured part.

Claude Code had a real quality regression. Anthropic published its own postmortem on April 23, tracing it to three separate changes that hit Claude Code, the Agent SDK, and Cowork. Resolved by April 20 in v2.1.116. Credit to them for owning it publicly, but it happened.

Amp's failure modes are barely documented. That could mean it has fewer problems, or it could mean a smaller user base files fewer reports. I lean toward the second read: Amp is younger and pricier, so it has fewer users generating bug threads. Not enough public signal to call it either way with confidence.

Amp's cost is the failure mode everyone names. Go read any Amp discussion. The single most common complaint isn't quality, it's the meter. "Great, but pricey" shows up over and over. The model is working as designed. But if a ticking balance makes you code more cautiously, that caution is a real cost too.

The benchmark question

There is no head-to-head benchmark of Amp versus Claude Code. Nobody has run both on the same eval with the same harness. Amp has no published SWE-bench score at all, vendor or independent.

Terminal-Bench (January 2026) tested Claude Code, Codex CLI, and Gemini CLI on agent-level terminal tasks. Amp wasn't included. So Claude Code has an agent benchmark and Amp has none.

You'll see model-level SWE-bench numbers floating around, but read them carefully: those are model scores, not agent scores. When I first wrote this, Amp's smart mode and Claude Code's Max default were both Opus 4.8, so the two agents were drawing on identical model strength and the comparison was at least clean. That's no longer true. Amp's routing has moved to a mix that's mostly OpenAI with Anthropic's Fable 5 at the top, so the two products are now running different models at every tier. Any model-level leaderboard score tells you even less about agent behaviour than it did in June, because the Librarian, the orb layer, and tool-use overhead are all unmeasured. Treat any "Amp is X% better" claim as unfounded. The data still doesn't exist.

That absence is exactly why a real run matters. When there's no benchmark, the honest comparison is one engineer running both on the same job and reporting what happened, including what broke. Which is the scene above.

The verdict

Stay on Claude Code if you want a predictable bill and you're happy in the Anthropic ecosystem. The flat subscription is easier to reason about, the model is consistent, and the rate limits just got more generous.

Switch to Amp, or run it alongside, if automatic model routing is the feature you've been missing, or you want parallel agent runs you can actually watch without bolting on plugins. The Librarian is a genuine edge if you do a lot of cross-repo or framework-internals research.

The catch with Amp used to be the meter, and on pay-as-you-go it still is: you pay for exactly what you burn, and heavy work at the top modes climbs fast. But the $20 Megawatt subscription now gives you a flat-fee way in, so "you'll watch a balance tick down" is no longer the whole story. What is still true: the free tier got clawed back in May and hasn't returned as a dependable option, so going in you should expect to pay something.

For most engineers already shipping on Claude Code, don't switch. Keep Claude Code as the daily driver and reach for Amp when you want multi-model routing or remote-codebase search on a specific task. Run the same job through both once and see what each one does with your actual code. And if your work is lint-heavy Python, keep an editor in the loop, because both CLI agents went blind on ruff in a way Cursor didn't.

Start by doing this

5 mins: Install Amp (curl -fsSL https://ampcode.com/install.sh | bash), sign in, and run one small real task from your backlog. Watch the credit balance move. That's the unsubsidised cost of inference, and seeing it once tells you more than any pricing page.

15 mins: Run the same task through Claude Code. Note which finished cleaner, which felt faster, and how much of your 5-hour window it ate.

30 mins: If your stack is Python, throw a deliberately lint-broken file at both CLI agents and watch how they handle ruff. Then open it in your editor. That gap is the thing this whole comparison turns on.