Practice & Reference · Glossary
Glossary
Every term this course leans on, gathered into one page — model basics, the Messages API, tools and structured output, agent patterns, MCP, safety, and production vocabulary. Skim it top to bottom, or jump to the group you need.
☺ Explain it like I'm 10
Think of this page as Nutty's giant filing cabinet. Every drawer holds one word from the course, cracked open so you can peek at what's inside without digging back through ten lessons. Forgot what "temperature" or "prompt caching" means? Pull the drawer, read the card, move on.
🐿️Your host for this topic: Nutty the Squirrel (gathers and files every term so you don't have to hunt for it).
Models & the platform
☺ Like you're 10: This is the vocabulary for Claude itself — the model, the knobs you can turn, and the account stuff around it.
| Term | Definition |
|---|
| Claude | Anthropic's family of large language models, offered in different capability/speed tiers and accessed mainly through the Messages API. |
| Anthropic | The company that researches and builds Claude, with a mission centered on AI safety. |
| Model tier (Opus, Sonnet, Haiku) | Anthropic's naming scheme for trading off capability, speed, and cost — Opus is the most capable, Haiku the fastest, Sonnet balances the two. |
| Context window | The maximum number of tokens (input plus output) a model can hold in view during a single request. |
| Token | The basic unit of text Claude reads and generates — roughly a chunk of a few characters, not exactly a word or a character. |
| Tokenization | The process of splitting text into tokens before it's sent to, or generated by, the model. |
| Knowledge cutoff | The date after which a model's training data ends, meaning it has no built-in awareness of events past that point. |
| System prompt | Instructions passed via the system parameter that set Claude's role, tone, and constraints for the whole conversation, kept separate from user turns. |
| Temperature | A sampling parameter controlling randomness in output — lower values give more focused, deterministic answers; higher values give more varied ones. |
| top_p / top_k | Additional sampling controls that narrow the pool of candidate next-tokens, used alongside or instead of temperature. |
| max_tokens | A request parameter capping how many tokens Claude is allowed to generate in its response. |
| stop_sequence | A string that, if generated, tells Claude to stop producing further output immediately. |
| API key | The credential used to authenticate requests to the Anthropic API — kept secret and never hardcoded into shared or client-side code. |
| Rate limit | A cap on requests or tokens per minute for an account, used to keep the API stable and fairly shared across users. |
The Messages API
☺ Like you're 10: This is the actual shape of a conversation with Claude — who says what, and how the reply comes back.
| Term | Definition |
|---|
| Messages API | Anthropic's primary API for sending a conversation to Claude and getting a response — the foundation nearly every other feature builds on. |
| messages array | The list of turns in a conversation, each with a role and content, sent with every Messages API request. |
| role | Marks each message as either "user" or "assistant"; messages must alternate between the two. |
| Content block | A structured unit inside a message's content — text, image, document, tool_use, or tool_result are the common kinds. |
| Message object (response) | What the API returns: an assistant-authored message containing one or more content blocks, plus metadata like stop_reason and usage. |
| stop_reason | A field on the response explaining why Claude stopped generating — it finished naturally, hit max_tokens, or hit a stop sequence. |
| usage | A field on the response reporting how many input and output tokens the request consumed. |
| Streaming | Receiving Claude's response incrementally as it's generated, instead of waiting for the full message to complete. |
| Server-Sent Events (SSE) | The streaming protocol the Messages API uses to push incremental events, like content_block_delta, to the client. |
| Multi-turn conversation | A back-and-forth exchange built by appending each new user and assistant message to the messages array and resending the whole history. |
Prompting techniques
| Term | Definition |
|---|
| Prompt engineering | The practice of crafting instructions, examples, and structure to reliably get the output you want from Claude. |
| Zero-shot prompting | Asking Claude to perform a task with instructions alone, no worked examples. |
| Few-shot prompting | Including a handful of example input/output pairs in the prompt so Claude can follow the pattern. |
| Chain of thought (CoT) | Prompting Claude to reason step by step before giving a final answer, which tends to improve accuracy on harder tasks. |
| XML tags (in prompts) | Tags like <example> or <document> used to clearly delimit parts of a prompt, which Claude is trained to parse reliably. |
| Prefilling | Starting Claude's own response for it, to steer format or skip preamble — Claude continues from wherever the prefill leaves off. |
| Role prompting / persona | Asking Claude to answer "as" a particular role or perspective to shape tone and framing. |
| Prompt template | A reusable prompt structure with placeholders swapped in per request, useful for consistent production prompts. |
Tools, structured output & context
☺ Like you're 10: This is how Claude reaches beyond just talking — calling tools, reading images, remembering long documents cheaply, and showing its work.
| Term | Definition |
|---|
| Tool use (function calling) | Giving Claude a set of defined tools it can request to call mid-conversation, letting it take actions or fetch information beyond its own knowledge. |
| Tool definition | The name, description, and input_schema that tells Claude what a tool does and what parameters it expects. |
| tool_use block | A content block Claude returns when it wants to call a tool, containing the tool's name and the input Claude chose. |
| tool_result block | The content block a caller sends back with a tool's output, continuing the conversation after a tool_use request. |
| tool_choice | A request parameter controlling whether Claude decides freely whether to use a tool, must use some tool, or must use one specific tool. |
| Parallel tool calls | Claude requesting multiple tool_use blocks in a single turn, so several actions can run before it continues. |
| JSON Schema | The schema format used to describe a tool's expected input (or a desired structured output), which Claude uses to produce well-formed arguments. |
| Structured outputs | Getting Claude to return data in a predictable, parseable shape — typically JSON — often by defining a schema via a tool or explicit instructions. |
| Vision / multimodal input | Sending images or PDFs as content blocks alongside text so Claude can reason about visual material. |
| Prompt caching | Marking reusable chunks of a prompt, like a long system prompt or document, with cache_control so repeated requests skip reprocessing that portion. |
| Extended thinking | A mode where Claude produces a visible internal reasoning trace — a thinking block — before its final answer, useful on harder problems. |
Agents, workflows & MCP
☺ Like you're 10: A workflow is a recipe you wrote; an agent is Claude deciding its own recipe as it goes, calling tools until the job's done.
| Term | Definition |
|---|
| Retrieval-augmented generation (RAG) | Retrieving relevant external documents or data and inserting them into the prompt so Claude can answer using up-to-date or private information. |
| Embedding | A numeric vector representation of text used to measure semantic similarity — the basis for retrieval in RAG systems. |
| Vector database | A datastore optimized for storing embeddings and finding the nearest (most similar) ones to a query, commonly used as the retrieval layer in RAG. |
| Chunking | Splitting long documents into smaller pieces before embedding and indexing them, so retrieval returns focused, relevant sections. |
| Agent | A system where Claude runs in a loop, deciding its own next steps and calling tools repeatedly until a task is complete, rather than following a fixed script. |
| Agentic loop | The cycle of Claude receiving context, deciding on an action (often a tool call), observing the result, and deciding again. |
| Workflow vs. agent | A workflow is a predefined sequence of LLM and tool steps; an agent dynamically decides its own path. Building Effective Agents recommends starting with the simplest workflow that works before reaching for a full agent. |
| Prompt chaining | A workflow pattern that breaks a task into sequential steps, each an LLM call, where one step's output feeds the next. |
| Routing | A workflow pattern where an initial step classifies the input and sends it down a specialized path suited to that category. |
| Parallelization | A workflow pattern that runs multiple LLM calls simultaneously, either splitting a task into subtasks or getting several independent takes to combine. |
| Orchestrator-workers | A pattern where a central LLM call breaks a task into subtasks and dispatches them to worker calls, then synthesizes their results. |
| Evaluator-optimizer | A pattern where one LLM call generates a response and a second evaluates and critiques it, looping until the response passes. |
| Model Context Protocol (MCP) | An open protocol for connecting Claude, or any LLM, to external tools, data, and resources through a standardized client-server interface. |
| MCP server | A service that exposes tools, resources, or prompts to an MCP client, following the protocol's spec. |
| Agent SDK | Anthropic's SDK for building agents around Claude, providing scaffolding for the agentic loop, tool orchestration, and MCP integration. |
Claude Code & developer tooling
| Term | Definition |
|---|
| Claude Code | Anthropic's agentic coding tool that runs in the terminal or IDE, giving Claude the ability to read, edit, and run code directly in a project. |
| CLAUDE.md | A project-level file Claude Code reads automatically for persistent context about a codebase's conventions, commands, and structure. |
| Subagent | A separately-scoped Claude Code session spawned to handle a subtask, keeping its context and work isolated from the main session. |
| Slash command | A shorthand, reusable prompt — like /review — that a user or team defines to trigger a common Claude Code workflow. |
| Hook | A configured script that runs automatically at a point in Claude Code's workflow, such as before a tool call or after a session stops. |
| Permission mode | Claude Code's setting for how much it can do without asking, ranging from confirming every action to running autonomously within defined bounds. |
Safety & evaluation
☺ Like you're 10: Before you trust an answer, check it — safety terms are about stopping bad behavior, eval terms are about proving good behavior.
| Term | Definition |
|---|
| Constitutional AI | Anthropic's training approach that shapes model behavior using a set of principles — a "constitution" — rather than relying only on human feedback on individual examples. |
| Red teaming | Deliberately probing a model with adversarial inputs to find ways it can be misused or broken, before those weaknesses reach real users. |
| Jailbreak | A prompting technique designed to bypass a model's safety training and get it to produce disallowed content. |
| Prompt injection | An attack where untrusted content — a document, webpage, or tool output — contains hidden instructions intended to hijack the model's behavior. |
| Hallucination | When a model states something false or fabricated with unwarranted confidence, a key risk to check for in evaluation. |
| Guardrails | Checks and constraints, in prompts, code, or system design, that catch or prevent unsafe or incorrect model behavior before it reaches a user. |
| Responsible Scaling Policy (RSP) | Anthropic's public framework for evaluating catastrophic risk levels in its models and committing to safety measures proportionate to that risk. |
| Eval (evaluation set) | A curated set of test cases with known-good answers or criteria, used to measure how well a prompt or system performs before shipping it. |
| LLM-as-judge | Using a separate Claude call to grade or score another response against a rubric, useful for evaluating outputs at scale where human review would be too slow. |
| Groundedness / faithfulness | A measure of whether a model's answer is actually supported by the provided context, like retrieved documents, rather than invented. |
| Human-in-the-loop | Keeping a human reviewer in the workflow to approve, correct, or override model outputs, especially for high-stakes actions. |
Production & deployment
| Term | Definition |
|---|
| Latency | The time between sending a request and receiving a complete (or first-token) response — a key factor in choosing model tier and whether to stream. |
| Streaming (production use) | Sending output token-by-token to the user as it's generated, reducing perceived latency for long responses. |
| Observability | Logging, tracing, and monitoring requests, tool calls, and outputs in production so issues can be diagnosed and performance tracked over time. |
| Fallback logic | Automatically retrying or switching to a different model or approach when a request fails, times out, or hits a rate limit. |
| Exponential backoff | A retry strategy that waits progressively longer between attempts after a failed request, easing pressure on a rate-limited or failing service. |
| Prompt versioning | Tracking changes to prompts over time, like code, so regressions can be identified and rolled back. |
| Cost optimization | Techniques such as prompt caching, choosing a smaller model tier, or trimming context to reduce the token spend of a production system. |
| Batch processing | Submitting a large set of requests to be processed asynchronously and cost-effectively, rather than one at a time in real time. |
| A/B testing | Comparing two prompt or model configurations against real traffic, or an eval set, to see which performs better before fully rolling it out. |
🐿️ Nutty's checkpoint
You've now got the full vocabulary of this course in one filed, cross-referenced place — from model tiers and Messages API fields through tool use, agent patterns, MCP, safety terms, and production concerns. If a term still feels fuzzy, jump back to the lesson it came from using the links in Reference, or test yourself with Flashcards and the Self-check.
Check your answers
- What's the difference between a workflow and an agent? A workflow is a predefined sequence of steps you design in advance; an agent decides its own steps dynamically, looping and calling tools until it judges the task done. Building Effective Agents recommends reaching for the simplest workflow that works before building a full agent.
- What do a tool_use block and a tool_result block each carry? A tool_use block is Claude's request to call a specific tool with specific input; a tool_result block is what you send back with that tool's actual output, so Claude can continue the conversation with the new information.
- What does prompt caching's cache_control actually save you? It lets you mark a reusable, unchanging chunk of a prompt — like a long system prompt or reference document — so that on repeated requests, Claude doesn't have to reprocess that portion from scratch, saving time and cost on the cached tokens.