Claude

What it is

Claude is Anthropic's family of large language models, sold through a consumer chat product at claude.ai and through a developer API. The lineup follows a three-tier shape that's stayed consistent across major versions: Haiku at the small/fast end, Sonnet as the workhorse tier, and Opus as the frontier tier for the hardest reasoning tasks. As of 2026-04, that means Haiku 4.5, Sonnet 4.6, and Opus 4.7, with older variants still available on the API for teams that haven't migrated yet.

Anthropic also ships Claude Code, a command-line coding agent that runs locally on your machine and uses Claude as its backing model. Claude Code meaningfully changes the calculus for developer teams — we'll get to that in a minute — because it turns the model from "smart chat box" into "autonomous collaborator that can actually edit your repo."

Positioning-wise, Claude competes head-on with OpenAI's GPT-class models and Google's Gemini. The three are close enough on raw intelligence that the practical choice usually comes down to taste: Claude is more willing to admit uncertainty, follows long instructions carefully, and produces structured output without going off-script. GPT has the biggest ecosystem and the broadest feature set. Gemini has enormous context windows and deep Google integration.

What makes Claude unusual inside that competitive set is how reliable it is at doing what you asked. In production workloads — where you care less about max IQ and more about the model doing the same thing twice in a row — Claude wins more often than either competitor. That quietly matters more than the marketing suggests.

The API itself is clean, well-documented, and stable. Anthropic publishes deprecation schedules, a clear versioning scheme, and predictable pricing that doesn't shift every two months. For a developer trying to build something real on top of a model, that stability is a feature.

What we tested

In our testing across client work, we've leaned on Claude for three primary use cases: code generation and refactoring inside agentic coding tools, structured document extraction against messy real-world inputs (contracts, PDFs, inconsistent CSVs, forms, screenshots), and long-context summarization on inputs in the 100k–200k token range. We've used Sonnet for the overwhelming majority of that work, with Opus reserved for the occasional gnarly reasoning task and Haiku for anything that smells like classification or routing.

On the infrastructure side, we've exercised the API through direct Anthropic endpoints, through AWS Bedrock, and through Google Vertex AI. We've built prompt-cached pipelines against long system prompts, batch-processed workloads via the Batch API to verify the 50% discount lands where promised, and stress-tested tool-use schemas through hundreds of thousands of function calls.

On the consumer side, we've used claude.ai daily for two years — through Projects, Artifacts, Computer Use, and the file-upload flow — which gives us a feel for how Claude behaves when the end user is a non-technical operator rather than a developer holding the API.

None of what follows is a formal benchmark. Every benchmark-focused review already exists. What we can offer is the texture of running Claude in client production for sustained periods and living with the results: where it earns its keep, where it surprises, where the edges still need working around.

What's good

The most consistent thing we can say about Claude is that it follows instructions. If you tell it to return JSON with these five keys and no prose, it does. If you tell it to keep its answer under two sentences, it does. If you tell it to wait for user confirmation before calling a destructive tool, it waits. For anyone who has spent time wrangling a lesser model into shape with retries and schema validation, this single property is worth the price premium alone — the cost of "did the model do what I asked" failures compounds fast in production, and Claude has fewer of them than any competitor we've measured.

Coding performance is the second clear strength. Across the industry benchmarks we trust — SWE-bench Verified, HumanEval-plus, and real-world "fix this repo" harnesses — Sonnet and Opus both land at or near the top of the pack. More importantly, the generated code compiles more often and the diffs read more like something a senior engineer would ship. Claude doesn't just produce plausible code; it produces code that holds up to review.

Claude Code, the CLI agent, amplifies this advantage. Users report that pairing with the CLI on well-scoped tasks feels less like prompting a model and more like driving a capable junior developer. It reads files, runs tests, asks before destructive operations, iterates on feedback, and produces PRs that real engineers can land without heavy rewriting. No competitor has a first-party agent at this level of integration, and the benefit compounds the more your team gets comfortable with it.

Long-context behavior is genuinely good, not just "large." Models with large advertised context windows often degrade dramatically once you push past a certain depth — forgetting earlier content, confusing sections, losing the plot on multi-document reasoning. Claude holds up. In our testing, Sonnet 4.6 is usable at 150k+ tokens for real document analysis, not just as a demo.

Where Claude shines in production

• Long-context work: 200k+ token windows without the usual "lost in the middle" collapse.
• Structured output and tool use: consistent JSON, reliable function calling, minimal schema drift.
• Agentic loops: the model is willing to pause, ask, or stop when uncertain, which is exactly what you want in an agent.
• Prose quality: tone is measured and editorial, not the florid default of other models.
• Sonnet's price/performance is the best production default in the market right now.
• Prompt caching pays off after a single re-hit — no complex cache strategy required.

If OpenAI optimizes for breadth and Google optimizes for integration, Anthropic optimizes for being the model you can trust to actually do what you said. In production code, that matters more than the marketing suggests.

Tool use is the quiet star of the kit. Claude's function-calling is unusually reliable — the model sticks to declared schemas, chooses the right tool more consistently than peers, and doesn't hallucinate parameters. For anyone building agents that call real APIs in production, this translates directly to fewer retries, fewer validation layers, and fewer late-night pages for schema drift.

Common pitfalls

A few recurring failure modes show up in the Claude projects we've seen go wrong — none of them fatal, all of them worth naming.

Treating consumer Claude and API Claude as the same product. They're not. claude.ai has a specific system prompt, a safety filter stack, and default behaviors tuned for a broad consumer audience. The API has none of that — it applies what you put in the system prompt. Teams that build a prototype on claude.ai and then port it to the API sometimes hit unexpected behavior changes, especially around refusal patterns. Build on the API from the start if you're heading toward production.

Under-using prompt caching. Any app with a stable system prompt or a long reference document should be caching. We routinely see production Claude bills drop 60–80% when caching is added to an existing workload. The common mistake is assuming "my prompt is too short to bother" — but on repeat requests, even a few-hundred-token prefix pays off almost immediately.

Defaulting to Opus. Teams new to Claude often pick Opus because it's the flagship. For 80% of production tasks, Sonnet is indistinguishable from Opus in quality and one-third the price. Start on Sonnet; move to Opus only when you can point at a specific task where Sonnet demonstrably hits a ceiling.

Ignoring the Batch API on async workloads. If your workload doesn't need a real-time response, batching gets you 50% off, stacked on top of prompt caching. The engineering investment is modest — a few hours to rewrite the call pattern — and the savings are immediate.

Using one model for everything. The trick to controlling a Claude-powered system is routing: Haiku for classification and triage, Sonnet for the reasoning, Opus only for the hardest final step. Most apps that land on "we're spending too much on Claude" aren't using the right model for each step.

What's not

The most common complaint is over-caution. Claude will occasionally refuse or hedge on requests that a reasonable reader would consider entirely benign — security research, legal analysis, some kinds of creative fiction. The frequency has improved significantly over successive model versions, but it hasn't disappeared. Users report that framing and system prompts mitigate most of it, and that the API (with an explicit developer-side system prompt) is noticeably less cautious than the default consumer product.

Rate limits are the second honest gripe. During peak hours, Anthropic's capacity for the top tiers has historically tightened — this is a reality of any foundation model at the frontier, but it's worth budgeting for in production. Prompt caching and batch endpoints help smooth costs, and AWS Bedrock / Google Vertex AI give you independent capacity pools, but if your app is spiky you'll want a secondary provider to fall back to.

Price is not exactly a weakness, but worth naming: Claude is not the cheapest LLM per token by a significant margin. If your workload can tolerate lower quality, open-weights models on RunPod or a mid-tier OpenAI model will be cheaper. The case for Claude is always that the quality gap justifies the price gap — and once you factor in the cost of retries, validation, and failed outputs on a lesser model, Claude usually still wins. But if quality really doesn't matter for your workload, use something else.

No native image generation. Claude understands images on input but doesn't generate them. For multimodal apps, pair Claude with an image model like Flux, Ideogram, or DALL-E via the appropriate provider. This is a product decision Anthropic seems firm on — don't expect image-gen to land in Claude anytime soon.

No built-in web browsing on the API by default. Claude has a web-search tool available, but it's a separate paid capability ($10 per 1,000 searches) rather than automatic browsing. For apps that need live web context, you have to wire it in explicitly. For research-heavy workflows, Perplexity's Sonar API is sometimes a better integration point.

The consumer product evolves less predictably than the API. Features in claude.ai ship and get reworked on a cadence that's harder to plan around than the API versioning. This isn't a problem if you're using Claude for work — but if you're building an internal tool that depends on a specific claude.ai feature behaving a specific way, be ready for it to shift.

Who should use it

If you're building anything that involves code, long documents, or an agent doing multi-step work, Claude should be your default. The same goes for any application where reliability of output shape matters more than the absolute cheapest token price — which, once you factor in the cost of retries and validation, is most production applications we see.

Claude Code is a distinct reason to pick this ecosystem even before you consider the base model. No competitor has a first-party coding agent at the same level, and the benefit compounds as your team gets comfortable with it. For a small dev team looking for force multiplication, the combination of Claude Code CLI and Sonnet's pricing is genuinely hard to beat.

Enterprise teams should use Claude through AWS Bedrock or Google Vertex AI. It gives you the cloud provider's compliance posture on top of Anthropic's model, simplifies procurement, and usually fits into an existing cloud contract. The latency is slightly higher than direct Anthropic endpoints, but the procurement story is much cleaner.

If you're shipping a consumer product where volume is massive and the per-query quality bar is low, a cheaper model will serve you better. ChatGPT or Gemini's smaller tiers are closer to the right price-performance curve for those shapes. And if you're building on open weights for sovereignty, data-residency, or self-hosting reasons, Claude isn't on the table — pick a Llama- or Qwen-class model and run it yourself on RunPod or similar.

For research, Claude is one of the better tools for reading through long academic papers or pulling structured findings from a messy corpus of documents. Paired with Perplexity for citation-grounded web search and a scratchpad workflow, a solo researcher can cover ground that would have taken a team a decade ago.

Verdict

Claude is the LLM we reach for first. It's the one we'd recommend without hesitation to a team shipping code, working with long documents, or running agentic workflows in production. The over-caution and pricing are real but manageable, and the trajectory has been consistently forward: every major version in the last two years has improved on the previous in the ways that matter for real work — better instruction-following, better code, better long-context behavior, lower prices (Opus 4.7 at $5/$25 is a meaningful step down from the Opus 4 line at $15/$75).

We rate it 9.1 / 10. It loses a half-point for occasional refusals and a half-point for the price floor. Almost everything else is better than the competition, and the things that aren't (ecosystem, multimodal features, free-tier reach) are features of the competition, not failures of Claude.

If you're on the fence, spend a week using Claude Code on your current work. You'll know within three days whether the combination of model + agent fits how you build.