References: Choosing your model and the effort dial

Source material

Source curriculum (structural mirror, cited as further study):
• Anthropic Academy (https://anthropic.skilljar.com/):
    "Building with the Claude API" course (model selection sections)
  License: Anthropic Academy course content is account-gated;
    Clawdemy structurally mirrors the Academy's lesson progression
    as inspiration and cites it as further study. Every substantive
    claim in this lesson is verifiable against the public Anthropic
    documentation.

Primary public-doc anchors (every substantive claim verified against):
• Anthropic, "Models overview" (pricing, IDs, context, capabilities)
  https://platform.claude.com/docs/en/about-claude/models/overview
• Anthropic, "Model IDs and versioning" (alias vs date-pinned convention)
  https://platform.claude.com/docs/en/about-claude/models/model-ids-and-versions
• Anthropic, "Extended thinking" (manual thinking, budget_tokens shape)
  https://platform.claude.com/docs/en/build-with-claude/extended-thinking
• Anthropic, "Adaptive thinking" (the recommended new mode on Opus 4.8 / Opus 4.7 / Opus 4.6 / Sonnet 4.6)
  https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking
• Anthropic, "Effort" (the effort dial, supported models, value list)
  https://platform.claude.com/docs/en/build-with-claude/effort

Verbatim claims sourced from the public docs:
• Pricing per MTok (Opus 4.8 $5/$25 as current flagship; Opus 4.7 $5/$25
   as legacy with same posture as 4.8; Sonnet 4.6 $3/$15; Haiku 4.5 $1/$5)
   from the Models overview "Latest models comparison" table
• Context windows (1M / 1M / 200k) and max output (128k / 64k / 64k)
   from the same table
• Effort values (low, medium, high, xhigh, max) and supported-models list
   from the Effort page "Effort levels" table
• "Starting with the Claude 4.6 generation, model IDs use a dateless
   format that is also a pinned snapshot, not an evergreen pointer"
   from the Models overview model-versioning note (paraphrased into the
   lesson's "dateless IS pinned on 4.6 generation" framing)
• Adaptive vs manual thinking compatibility matrix:
   - Opus 4.8: adaptive only (manual returns 400)
   - Opus 4.7: adaptive only (manual returns 400; same posture as 4.8)
   - Sonnet 4.6: adaptive recommended, manual deprecated-but-functional
   - Opus 4.6: adaptive recommended, manual deprecated-but-functional
   - Haiku 4.5: manual only (no adaptive)
   From the Effort + Extended thinking pages.

Required attribution: "Based on the structure of the Anthropic Academy
  'Building with the Claude API' course
  (https://anthropic.skilljar.com/). This lesson is an independent
  structural mirror in original prose; every substantive claim is
  verified against the public Anthropic Claude documentation at
  https://platform.claude.com/docs/. Anthropic does not endorse it."

This is lesson 3 of 12 in Track 22 (Building with Claude). The previous
lesson is lesson 2 (The Messages API in production); the next is lesson 4
(Tool use, the foundation). This lesson CLOSES Phase 1; lesson 4 opens
Phase 2.

Read this next

• Anthropic, “Models overview”. The canonical model comparison; check it whenever the lineup shifts (prices, context windows, support matrices all live here and update as the model lineup evolves).
• Anthropic, “Model IDs and versioning”. The full convention behind dateless and date-suffixed IDs. Worth a careful read when you ship to production.
• Anthropic, “Effort”. The full effort-parameter doc. Includes per-model recommended-starting-points tables that go deeper than the lesson’s summary.
• Anthropic, “Adaptive thinking”. The new default thinking mode on Opus 4.8 / Opus 4.7 / Opus 4.6 / Sonnet 4.6.
• Anthropic, “Extended thinking”. The older manual thinking mode, still relevant for Haiku 4.5 and as the backward-compatible mode on Sonnet 4.6 / Opus 4.6.
• Anthropic, “Pricing”. Full pricing including Batch API discounts and prompt-caching rates (relevant to lessons 2 and 7 of this track).

Going deeper

A short, durable list. Each link is a specific next step inside Track 22, not a generic pile.

• Lesson 4 of this track, “Tool use, the foundation.” Opens Phase 2. The first place the effort dial’s “affects ALL tokens” property starts to compound, because tool calls are part of total token spend per response.
• Lesson 7 of this track, “Prompt caching and context management.” The third cost lever after model choice (this lesson) and the effort dial. With caching, batches (from lesson 2), and the right model + effort, you have four cost dials.
• Lesson 8 of this track, “From single call to agent loop.” Where model + effort compound across multi-step work; total cost is steps times per-step cost, and effort affects both the step count and the per-step spend.
• Lesson 11 of this track, “Subagents and Claude Managed Agents.” Where the mix-and-match pattern (Sonnet for orchestrator, Haiku for inner subagent) becomes the design.
• Lesson 12 of this track, “Shipping a Claude application.” Cost monitoring at the org level via the Admin / Usage / Cost APIs; turns the usage + request_id logging from lesson 2 into cost-per-feature dashboards.

Adjacent tracks (the natural next destinations)

• Track 21 (LLM Ops and Production): pick this if you want the provider-agnostic view of model selection (lesson 2 there: “LLM foundations” + the three productive limits). The eval-set discipline this lesson recommends is from Track 21 lesson 7 “LLMOps” (held-out evaluation, prompt versioning, regression testing).
• Track 5 (AI Foundations): pick this if you want the broader-than-Claude view of how model capability tiers work in general (lessons on transformer scaling, training, what makes a frontier model “frontier”). The conceptual layer underneath the family table here.

Where this connects inside the track

The decision that compounds, threaded through later lessons:

• Lesson 1 (first call): the model parameter from lesson 1’s request body, now with a proper selection conversation behind it.
• Lesson 2 (production patterns): the usage data lesson 2 logged is what an eval-driven model swap actually saves; the cost arithmetic here is concrete.
• Lesson 4-5 (tool use): the effort dial affects ALL tokens including tool calls; lower effort in inner loop steps compounds.
• Lesson 6 (MCP): MCP tool calls are token spend the effort parameter controls; same trade.
• Lesson 7 (prompt caching): caching reduces the input-token side of the same cost arithmetic this lesson worked out.
• Lesson 8 onward (agent loop): model and effort choices compound across multi-step work. A 6-step agent at Opus default effort can cost significantly more than the same 6 steps at Sonnet + medium effort.
• Lesson 11 (subagents): mix-and-match by step (orchestrator gets Sonnet, leaf subagents get Haiku) is the design.
• Lesson 12 (shipping): the cost-per-feature dashboards the usage + request_id logging supports.