Model Selection Guide

Understand the characteristics and applicable scenarios of different AI models to make the best choice.

Model Selection Guide¶

Claude Code supports multiple AI models, each with different capabilities, speed, and pricing. Picking the right model gets you the best results while keeping costs under control. This guide helps you make the optimal choice for each scenario.

💰 This page only covers how to choose; for live per-token pricing, always refer to qcode.cc/models. All costs below are expressed as relative ratios.

Claude Model Family Overview¶

The Claude models currently available through QCode.cc form a capability ladder:

Claude Fable 5 — Top-Tier Flagship¶

Fable 5 is the most capable tier available today, and also the priciest (input pricing is roughly 10x Haiku's):

• Strongest reasoning: built for the hardest problems — cross-system architecture, tricky concurrency/distributed bugs, one-off critical decisions
• 1M context / 128K output: whole-codebase understanding for large projects
• Save it for when it counts: using it for routine tasks is overkill, and the cost doesn't pay off

Best for: critical technical decisions, stubborn bugs that have resisted debugging, one-off tasks where output quality matters most.

Claude Opus 4.8 / 4.7 — Flagship Workhorse¶

Opus is the battle-tested flagship workhorse:

• Deep reasoning: long-chain logical reasoning, well suited to complex architecture design
• Code quality: generated code is more thorough, with better edge-case handling
• 1M context: strong at understanding large codebases
• Extended Thinking: reasons internally before answering complex questions

Best for: architecture design, large-scale refactoring, technical proposal evaluation, complex bug hunting.

Claude Sonnet 5 / Sonnet 4.6 — Best Balance¶

Sonnet is the daily driver for most developers, striking the best balance between capability and cost:

• Sonnet 5: the new-generation balanced tier, 1M context / 128K output, same price as Sonnet 4.6 — the recommended default for new projects
• Sonnet 4.6: mature and stable, 1M context (optional toggle), fully sufficient for everyday coding
• Great value: input pricing is about 60% of Opus, with output quality that comes close
• Faster: quicker than Opus, well suited to frequent back-and-forth

Best for: everyday coding, bug fixes, code review, documentation, writing tests.

Claude Haiku 4.5 — Light and Fast¶

Haiku is the smallest, fastest tier, and the cheapest:

• Fastest speed, lowest price (input pricing is about 1/3 of Sonnet's)
• Solid basics: fully capable on simple tasks, limited on complex reasoning
• 200K context

Best for: simple Q&A, code formatting, boilerplate generation, quick translations.

Detailed Model Comparison¶

Relative cost uses Haiku 4.5 input pricing as 1×; see qcode.cc/models for exact per-token and cache pricing.

Relative Cost for the Same Task¶

Say you complete a moderately complex coding task (15K input tokens, 5K output tokens), with Haiku's cost as the baseline:

The capability gap is just as significant — running a complex task on a cheap model can mean repeated retries, and you may end up spending more overall.

Scenario-Based Selection Guide¶

Everyday Coding → Sonnet 5 / Sonnet 4.6¶

For day-to-day functions, components, APIs, and the like, Sonnet is more than enough:

/model claude-sonnet-5

> "Add a deleteUser method to @src/services/user-service.ts"
> "Create a Pagination component with previous/next buttons and jump-to-page support"
> "Add pagination parameter support to @src/app/api/orders/route.ts"

Architecture Design / Large-Scale Refactoring → Opus 4.8¶

When system design and global decisions are involved, Opus's deep reasoning is well worth the price:

/model opus

> "Analyze the overall architecture under @src/. I plan to split this monolith into microservices.
Evaluate which modules are good candidates for extraction and propose a split plan."

Critical Decisions / Stubborn Bugs → Fable 5¶

For bugs you have been chasing for ages without a lead, or far-reaching one-off technical decisions, going top-tier is worth it:

/model claude-fable-5

> "I've spent three days on this intermittent data inconsistency issue. Symptoms, logs, and repro steps below...
Systematically analyze all possible root causes and propose a verification plan."

Code Formatting / Simple Q&A → Haiku 4.5¶

For mechanical work that needs no deep thinking, Haiku is the most economical choice:

/model haiku

> "Add JSDoc comments to all interfaces in @src/types/index.ts"
> "What does this ESLint error mean: no-unused-vars"

Large PR Reviews → Opus 4.8¶

When reviewing large changes spanning many files, Opus catches deeper issues.

Bug Fixes → Sonnet 5 / 4.6¶

Sonnet handles most bug fixes just fine; for especially complex bugs involving concurrency or distributed systems, switch up to Opus or Fable.

Quick Reference by Scenario¶

How to Switch Models¶

Method 1: The /model Command (Recommended)¶

Switch anytime inside Claude Code; it takes effect immediately:

/model                    # Show the current model and available options
/model sonnet             # Switch to Sonnet
/model opus               # Switch to Opus
/model haiku              # Switch to Haiku
/model claude-sonnet-5    # Switch by full model name
/model claude-fable-5

Method 2: Environment Variable¶

Set a default model in your shell profile (e.g. ~/.bashrc or ~/.zshrc):

export ANTHROPIC_MODEL=claude-sonnet-5

# Or specify it one-off at launch
ANTHROPIC_MODEL=claude-opus-4-8 claude

Method 3: Configure in CLAUDE.md¶

Give Claude some model-usage guidance in your project's CLAUDE.md (note these are suggestions, not hard configuration):

## Model Usage Suggestions

- Use Sonnet for everyday development
- Switch to Opus to evaluate the design before architecture changes
- Use Haiku for bulk comment additions to save cost

Method 4: Launch Flags¶

claude --model claude-fable-5
claude --model claude-sonnet-5
claude --model claude-haiku-4-5

GPT and Codex Models (via QCode.cc)¶

Through QCode.cc's relay service, the same API key also gives you access to GPT-series models.

Available Models¶

See qcode.cc/models for pricing; query the live model list with an authenticated GET to https://api.qcode.cc/v1/models.

GPT Series Highlights¶

• gpt-5.6-terra is the current flagship workhorse and the default recommendation for Codex CLI scenarios
• gpt-5.6-sol / luna are same-tier flagship variants with comparable capability
• gpt-5.5 / gpt-5.4 are the previous-generation flagship and stable tiers — sufficient for everyday tasks and cheaper
• gpt-5.6-mini / nano are light and fast, economical for bulk or simple tasks

When to Consider Non-Claude Models¶

In most cases, Claude models are the best choice for Claude Code (native fit). The GPT series is worth trying when:

• You want comparison testing: run the same task through different models and see which produces better results
• Codex workflows: Codex CLI users naturally use the GPT series
• Budget considerations: lightweight GPT models are cheaper for simple tasks

/model gpt-5.6-terra

Note: non-Claude models may not support certain features in Claude Code (such as parts of Extended Thinking). We recommend Claude models as your primary choice, with other models as a supplement.

Cost-Benefit Analysis¶

A Mixed-Usage Strategy¶

The most cost-effective strategy is "Sonnet for the bulk of the work, Opus for the finishing touches, Fable for the hard nuts, Haiku for the grunt work":

Task allocation (reference):
├── Sonnet 5 / 4.6 (~70%) — everyday development, bug fixes, writing tests, reviews
├── Opus 4.8       (~13%) — architecture decisions, complex problems, large refactors
├── Fable 5        (~2%)  — critical decisions, long-unresolved stubborn bugs
└── Haiku 4.5      (~15%) — formatting, simple Q&A, bulk operations

Compared with running a flagship model the whole way through, the mixed strategy costs about the same as all-Sonnet — while keeping top-tier reasoning on call for the moments that matter.

When Upgrading Is Worth It¶

Switching to Opus or even Fable pays off when a task meets any of the following:

1. Wide blast radius: the change touches multiple modules, systems, or teams
2. One-off decisions: architecture selection, tech-stack migration, and other decisions that are hard to walk back
3. High debugging cost: the bug has resisted investigation for a long time and needs deeper analysis
4. Code quality is critical: the code will be called from many places and needs to be robust

Conversely, for internal tooling, style tweaks, or adding comments, Sonnet or even Haiku is plenty.

Practical Tips¶

Switch Models Mid-Conversation¶

You can switch models partway through a conversation: draft the plan with Opus/Fable first, then switch to Sonnet to execute once it's confirmed — top-tier reasoning for the critical decisions, cost control during execution.

/model opus
> "Analyze the existing code architecture and draft an implementation plan for the permissions system"

/model claude-sonnet-5
> "Following the plan above, start on step one: create the permission model"

Compare Model Spend with /cost¶

After finishing a task, check what it cost with /cost. Next time you tackle a similar task, try a different model and compare the results and the cost. After a few comparisons, you'll develop an intuition for which model fits which kind of task.

Model Capabilities Keep Evolving¶

The capability descriptions on this page reflect the relative standing of current versions. New model launches and retirements are always reflected at qcode.cc/models; when in doubt, let real-world testing be the judge.