Free CCDV-F Exam Flashcards

A workflow orchestrates Claude and tools through predefined code paths you write. An agent lets Claude direct its own steps and tool use at runtime. Workflows stay predictable and testable; agents give that up to handle tasks you cannot script in advance.

The simplest design that meets the need, often a single optimized call with retrieval and examples. Add agentic complexity only when the simpler approach demonstrably falls short, because every added loop costs latency, money, and debuggability.

When the task decomposes cleanly into fixed subtasks. Each call works on the previous call's output, and you can put a programmatic check between steps. It trades latency for accuracy, so it suits ordered work like outline-then-draft.

It classifies an input, then sends it to a handler built for that category. Separating categories lets you tune each path, or send easy cases to a cheaper model, without one prompt having to serve every case badly.

Sectioning splits a task into independent subtasks that run at the same time and are merged. Voting runs the same task several times and compares outputs. Sectioning buys speed; voting buys confidence.

In orchestrator-workers, a lead model decides at runtime what the subtasks are, delegates them, and synthesizes results. In evaluator-optimizer, one model drafts and another critiques in a loop. Use the first when subtasks are unpredictable, the second when grading criteria are clear.

It runs the Claude Code agent loop inside your own process, with built-in file, command, and search tools plus subagents, hooks, permissions, sessions, and MCP. With the Messages API you write the loop and supply every tool. Both still run on infrastructure you host.

The Message Batches API. Requests are processed asynchronously, results arrive when the batch finishes or within 24 hours, and usage is billed at 50 percent of standard API prices. Running the same calls synchronously in parallel finishes sooner but pays full price per token.

Long or slow generations. A non-streaming request can hit network idle timeouts and return nothing, and the SDKs guard against a ten-minute limit. Streaming also lets a user-facing app show text as it arrives.

An eval run on the new configuration, compared against the current one. Model and prompt changes are behavior changes with no compiler to catch them, so the regression gate has to be an eval rather than a code review.

Nowhere on Anthropic's side. The Messages API is stateless, so your application resends the full message history on every request. Anything you leave out of that array has disappeared from Claude's view of the conversation.

A user-role message holding a tool_result block whose tool_use_id matches the id on the tool_use block. Results ride in the user turn, not the assistant turn, and an unmatched or missing id breaks the round trip.

Because results can come back in any order. Index-based matching silently pairs the wrong response with the wrong request, and the custom_id you set on each request is the only reliable key.

message_start, then per content block a content_block_start, one or more content_block_delta events, and a content_block_stop, then one or more message_delta events, then message_stop. Token counts carried on message_delta are cumulative, not per-event.

Retry 429 rate limits, 500-class errors, and 529 overloaded, using exponential backoff and the retry-after header when present. Do not retry 400, 401, 403, or 404: those describe the request itself and will fail the same way again.

The request exceeded the size limit for that endpoint; the Messages API cap is 32 MB. The fix is to move bulk content to the Files API or chunk the input. Resending the same payload cannot succeed.

All three tool_result blocks inside a single user message. Splitting them across separate messages breaks the pairing and teaches the model to stop issuing parallel calls.

The request-id returned in every response header, echoed as request_id in error bodies. Log it next to your own trace id, or a production failure cannot be tied back to a particular server-side request.

Structured outputs constrain Claude's response to a JSON schema you supply. Strict tool use constrains the arguments Claude passes to a tool. One shapes what Claude says, the other shapes how it calls your functions, and they can be combined.

The output was cut off at your ceiling, mid-thought. It is a truncation signal, not a finished answer, so treat it as something to retry or resume rather than parsing the partial text as final.

Pass them back unchanged in the assistant turn. Editing, reordering, filtering, or rebuilding them makes the next request fail with a 400. Filtering content blocks by type is the usual way applications break this rule by accident.

It draws a boundary between what Claude must obey and what it should only read. Mixed together, any sentence inside the document reads like an instruction, which is exactly the opening a prompt injection needs.

Model releases change behavior, and a prompt tuned on one model can regress on the next. Pinning turns the upgrade into a deliberate, testable change instead of something that happens under you between deploys.

System prompts, tool schemas, and the model ID, together with the eval results they were accepted against. Without that, you cannot say which prompt produced a past output or roll back a quality regression.

Managed policy first, then user, then project, then local. The files are concatenated rather than overriding each other, and files nearer your working directory are read last. A managed policy file cannot be excluded by user settings.

Precedence runs managed settings, then a command-line settings file, then project local, then shared project, then user. In a committed project file, deny and ask permission rules apply right away, while allow rules wait until each teammate trusts the folder.

Read the trace. If the tool arguments were correct and your handler returned bad data or an error, the fault is in the integration layer. If the arguments or the final wording were wrong given correct results, the fault is in the prompt or the model output.

The system prompt, tool definitions, the whole message history, and the generated output all draw on one budget. Growing tool schemas or an unpruned history quietly shrinks the room left for the answer.

Generation is token by token and not deterministic. Quality has to be judged across a sample of runs rather than one, and any test asserting an exact output string will flake.

How much reasoning and token spend goes into a response, from low up to max, without changing which model runs. It is the first quality-versus-cost lever to tune inside one model, before you consider switching models.

A long non-streaming generation can outlast HTTP and network idle timeouts and fail with nothing returned. Streaming keeps events flowing, so long outputs complete instead of dying on a dropped connection.

It retries connection errors, rate limits, and 5xx responses with exponential backoff, twice by default, honoring retry-after. Wrapping your own retry loop on top usually multiplies the wait rather than improving reliability.

Call the token counting endpoint with the same model, system prompt, tools, and messages. Tokenizers built for other model families return the wrong number, because tokenization differs by model.

Opus is the high-capability tier for complex agentic and enterprise work, Sonnet the best balance of speed and intelligence, and Haiku the fastest and cheapest; Anthropic's current lineup also places Fable above Opus for the most demanding reasoning. Choose per route and judge cost per completed task, since a cheaper model that needs more retries is not actually cheaper.

The cached prefix must match exactly, and caching is applied in the order tools, then system, then messages. A change anywhere in the prefix, such as a timestamp in the system prompt, invalidates everything after it.

Near the top, above the query, instructions, and examples. Anthropic's guidance is that putting long documents and inputs first improves performance across all models, and wrapping each document in its own tags with source metadata keeps multiple documents distinct.

Clearing drops old tool results outright and leaves a placeholder. Compaction summarizes earlier history and replaces it. Clearing is cheaper and more predictable; compaction preserves a trace of what happened but costs a summarization pass.

The durable frame: role, standing rules, output format, and tone. The user turn carries the task and its data. Rules that drift into the user turn get resent every time and end up sitting next to untrusted content.

Examples that mirror the real use case, cover edge cases, and vary enough that Claude does not latch onto an accidental pattern, each wrapped in its own tag so it reads as an example. Anthropic suggests three to five.

A long prompt mixes instructions, context, examples, and variable input, and unlabeled text blurs together. Consistent, descriptive tags make the boundaries unambiguous and cut down on misread instructions.

That it still needs validation. Parse defensively, check required fields and value ranges, and keep a fallback path. Confident phrasing is not evidence that the content is correct or well formed.

Isolation plus enforcement: keep fetched content in its own untrusted block apart from trusted instructions, and use least-privilege guardrails or hooks so that injected text cannot trigger sensitive tools. A system-prompt line asking the model to ignore malicious instructions is not an enforceable control.

Not putting the data in the prompt. Redact or tokenize personal data before the request, scope retrieval to what the current user is allowed to see, and filter responses before display. Prompt rules cannot unsend what you already sent.

Prompt instructions shape behavior but do not enforce it. A hook or policy check runs at a fixed point regardless of what the model decides, which is what destructive actions such as deletes, payments, and production writes require.

In a secrets manager or server environment you control, with requests made from your backend. Keys must never ship in client-side code or a repository. Set an expiration, rotate on a schedule, and disable any key you suspect has leaked.

The tool description and the parameter descriptions. They are the only evidence the model has, so state what the tool does, when to use it, and what each parameter means. Vague descriptions surface as missed or wrong calls.

A tool_result block for that tool_use_id with is_error set true and a short description of what failed. Dropping the block leaves an unanswered tool call and breaks the conversation; reporting the error lets Claude retry or explain.

Three primitives: tools for callable actions, resources for context data, and prompts for reusable templates. Messages are JSON-RPC 2.0, carried over stdio for a local server or streamable HTTP for a remote one.

When you are adding procedure rather than capability. A Skill is instructions Claude reads on demand to orchestrate tools it already has. An MCP server exposes new callable functions backed by an external system. Instructions do not need a server.

Server-side tools such as web search and code execution run on Anthropic's infrastructure with no handler, loop code, or sandbox for you to maintain. Write a custom tool when you need your own system, data, or authentication.