Choosing your model and the effort dial

What you’ll learn

Closes Phase 1 of Track 22. Lessons 1 and 2 established the smallest primitive and the production patterns around it; this lesson is the model-selection conversation on top. The single capability this lesson builds: pick the right Claude model, model-ID form, and effort level for a given workload, and reason about the cost arithmetic concretely.

Concretely, you will know the three current families (Opus 4.8 at $5 input / $25 output per million tokens as the current flagship; Sonnet 4.6 at $3/$15; Haiku 4.5 at $1/$5; with Opus 4.7 as a legacy 4.7 deployment carrying the same pricing and posture as 4.8) and the default-pick rule (Sonnet for production, Opus for genuinely hard tasks, Haiku for volume-and-light), the model-ID convention (dateless IDs on the 4.6 generation and later are already pinned snapshots; pre-4.6 models have a date-suffixed canonical and a dateless alias, and production should pin the date-suffixed form), the effort parameter (output_config: {effort: "low" | "medium" | "high" | "xhigh" | "max"}, supported on Opus 4.8 / Mythos / Opus 4.7 / Opus 4.6 / Sonnet 4.6 / Opus 4.5 but NOT Haiku 4.5; xhigh on Opus 4.8 and Opus 4.7) and its production starting points per model, and the two thinking modes (adaptive on Opus 4.8 / Opus 4.7 / Sonnet 4.6 / Opus 4.6, manual extended thinking still on Haiku 4.5 and deprecated on the others). A worked example fixes the cost arithmetic across a 2-call classifier+answer feature: 100k-daily-calls shift from $1,000/day all-Opus ($300 classifier + $700 answer) to $480/day with a Haiku classifier plus Sonnet answer, about 52 percent cheaper.

Every substantive claim verifies against the public Anthropic Claude documentation at platform.claude.com/docs/ (Models overview, Effort, Adaptive thinking, Extended thinking pages).

Where this fits

This is lesson 3 of 12 of Track 22, the third lesson of Phase 1 (foundations), and closes Phase 1. Lesson 1 established the smallest primitive; lesson 2 added the production patterns; this lesson is the model-and-parameter decisions on top. Together the three are everything later phases extend: Phase 2 (lessons 4-7) augments what one call can do (tools, MCP, caching), Phase 3 (lessons 8-11) extends to multi-step work (agents), Phase 4 (lesson 12) closes with shipping. The model-selection conversation here threads through every subsequent lesson; lesson 8 (the agent loop) compounds model + effort across steps, lesson 11 (subagents) is the mix-and-match pattern by step, lesson 12 (production) turns usage data into cost-per-feature dashboards.

The cross-track companion is Track 21 (LLM Ops and Production), especially lesson 7 “LLMOps” which is the playbook for the held-out evaluation discipline this lesson recommends as the way to actually pick a model.

Before you start

Prerequisites: lessons 1 and 2 of this track. You should have made working API calls (lesson 1) and seen the usage fields (lesson 2) that the cost arithmetic here builds on. The try-it-yourself exercise extends lesson 1’s environment and adds a 5-prompt Sonnet-vs-Opus eval.

Soft recommended: familiarity with the held-out-evaluation discipline from Track 21 lesson 7 “LLMOps.” This lesson recommends building an eval set as the way to actually pick a model; if Track 21 is not in your background, the recommendation will be conceptual rather than concrete.

About the math

Cost arithmetic only, and the arithmetic is not exotic. Per-call cost is (input_tokens * input_price_per_MTok + output_tokens * output_price_per_MTok) / 1,000,000. The lesson works one example (100k daily calls) and the practice extends it. No model internals, no derivations.

By the end, you’ll be able to

The single capability this lesson builds: pick the right Claude model, model-ID form, and effort level for a given workload, and reason about the cost arithmetic concretely (per the Phase 0 lesson 3 capability mapping). Concretely, you will be able to:

Distinguish the three current Claude families (Opus 4.8 as current flagship, Sonnet 4.6, Haiku 4.5; Opus 4.7 as legacy with same posture as 4.8) by capability, price, context, and use case
Apply the default-pick rule (Sonnet for production, Opus for hard tasks, Haiku for volume-and-light) and mix models within one application
Use the model-ID convention correctly (dateless IS pinned on the 4.6 generation and later, date-suffixed pin on pre-4.6 models for production stability)
Configure the effort parameter (output_config: {effort: "..."}) per workload using the recommended starting points for Sonnet 4.6, Opus 4.8, and Opus 4.7
Distinguish adaptive thinking (new mode, model decides) from manual extended thinking (older mode, you set budget_tokens) and pick the right one per model (adaptive on Opus 4.8, Opus 4.7, Sonnet 4.6, Opus 4.6; manual on Haiku 4.5)

Time and difficulty

Read time: about 14 minutes (slightly above the track average because the lesson combines a comparison table, three parameter discussions, and a worked cost example)
Practice time: about 20 minutes (the try-it-yourself runs an A/B between Sonnet and Opus on a 5-prompt eval set, plus flashcards for retrieval)
Difficulty: standard (no math beyond per-call cost arithmetic; the work is the comparison and the decision-making. Closes Phase 1, so the lesson assumes lessons 1 and 2 are in your head.)