Skip to content
Clawdemy

References: Your first Claude API call

Source material

Section titled “Source material”
Source curriculum (structural mirror, cited as further study):
• Anthropic Academy (https://anthropic.skilljar.com/):
    "Building with the Claude API" course (opening sections)
  Anthropic Academy is a free training catalog hosted on Skilljar
    (full course content requires a free Anthropic account; the
    course catalog itself is public).
  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, not against the gated course content.


Primary public-doc anchors (every substantive claim verified against):
• Anthropic, "Get started with Claude" (public quickstart)
  https://platform.claude.com/docs/en/get-started
• Anthropic, "Using the Messages API" (public reference)
  https://platform.claude.com/docs/en/build-with-claude/working-with-messages
• Anthropic, "Welcome to Claude" (intro + current canonical model names)
  https://platform.claude.com/docs/en/welcome
  Note: the docs domain migrated from docs.anthropic.com to
    platform.claude.com/docs in late 2025.


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 1 of 12 in Track 22 (Building with Claude). The track
opener; no prior lesson in Track 22. Adjacent recommended prior work:
none required; some prior LLM exposure helps but is not assumed.

Watch / read this next

Section titled “Watch / read this next”

Going deeper

Section titled “Going deeper”

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

  • Lesson 2 of this track, “The Messages API in production.” Streaming responses, error handling, retries, batches. The shape of code that ships, not just runs.
  • Lesson 3 of this track, “Choosing your model and the effort dial.” Opus versus Sonnet versus Haiku; when extended thinking and the effort parameter earn their keep; the cost / latency / quality trade.
  • Lesson 4 of this track, “Tool use, the foundation.” What stop_reason: tool_use actually means; how to define a tool, handle the tool-use / tool-result loop, and use structured outputs to constrain tool arguments.
  • Anthropic, “Welcome to Claude”. The two-paths framing (Messages API for full control, Claude Managed Agents for long-running tasks) that lesson 12 picks up.
  • Anthropic, “Features overview”. The full feature catalog (context windows, adaptive thinking, batches, citations, prompt caching, extended thinking, structured outputs, vision, tool use, MCP, Agent Skills, Files API). Useful as a map of what Track 22 reaches in later lessons.

Adjacent tracks (the natural next destinations)

Section titled “Adjacent tracks (the natural next destinations)”

The tracks the lesson body and cheatsheet name as adjacent destinations, with a one-line “when to pick this one.”

  • Track 21 (LLM Ops and Production): pick this if you want the provider-agnostic view of shipping LLM applications. T21 covers LLMOps (lesson 7 there), prompt engineering, evaluation, UX patterns, and the agent loop without being pegged to one provider’s feature surface. T22 lesson 8 cross-references T21 lesson 10 “Agents” for the loop pattern; T22 lesson 12 cross-references T21 lesson 7 “LLMOps” for the shipping discipline.
  • Track 5 (AI Foundations): pick this if you want the broader-than-Claude view of what LLMs are, what they can and cannot do, and how they fit in the wider AI landscape. The conceptual prerequisite Track 22 does not re-derive.
  • Track 15 (Build an LLM from Scratch): pick this if you want the what-is-inside-the-API view. T15 builds an LLM end to end (architecture, training, scaling, inference). T22 sits on top of the hosted-API surface T15 explains the internals of.

Where this connects inside the track

Section titled “Where this connects inside the track”

The smallest primitive, extended throughout the track:

  • Lesson 2 (Messages API in production): the response side. Streaming, batches, error handling, retries. Same endpoint, same shape, more production patterns.
  • Lesson 3 (model selection): the model field. Opus / Sonnet / Haiku trade-offs; extended thinking and the effort parameter.
  • Lesson 4 (tool use, foundation): the stop_reason: tool_use case. What it means and how to handle the loop.
  • Lesson 5 (server-side tools): tool use again, but the platform runs the tool for you.
  • Lesson 6 (Model Context Protocol): how to define one tool that works across many providers.
  • Lesson 7 (prompt caching + context management): the cost shape this lesson named (“every turn pays for the full prior history”) and how to flatten it.
  • Lesson 8 (single call to agent loop): when one call becomes a loop, and when it should not.
  • Lessons 9-11 (agent patterns, Agent Skills, subagents): the loop, in production.
  • Lesson 12 (shipping a Claude application): cost monitoring, ZDR posture, the Messages-API-versus-Claude-Managed-Agents decision the docs name as the top-level choice for builders.