Claude Certified Architect - Foundations cheat sheet

Model tiers trade capability against latency and cost: larger models favor complex reasoning, smaller models favor throughput and low-latency tasks.

The context window bounds the total tokens of system prompt, conversation history, tool definitions, retrieved documents, and the response combined.

Output tokens are generated one at a time and each token conditions on all prior tokens, so response cost scales with output length, not input length alone.

Temperature near 0 yields near-deterministic sampling; higher values widen the sampling distribution and increase output variance.

Extended thinking allocates additional reasoning tokens before the final answer and is appropriate when correctness on multi-step problems outweighs added latency.

Multimodal input lets a single request carry text plus images or documents; token cost of an image depends on its resolution and dimensions.

A model's training cutoff bounds what it knows natively; anything after that cutoff requires retrieval or inclusion in the prompt.

Stop sequences and max output tokens are hard controls on generation length; they truncate rather than summarize.

The system prompt sets persistent role, constraints, and output format; user turns carry task-specific input and should not be relied on to override system rules.

Few-shot examples steer format and reasoning style more reliably than adjectives; place examples before the target input.

Instruction-following degrades when a prompt contains contradictory rules; resolve conflicts explicitly rather than stacking both.

Chain-of-thought prompting improves multi-step accuracy by eliciting intermediate reasoning before the final answer.

Structured output is more reliable when the prompt states the exact schema and includes a filled example of that schema.

Prefilling the assistant turn forces the response to begin with a chosen prefix, which constrains format without extra instructions.

Delimiters (XML-style tags, triple quotes) separate untrusted content from instructions and reduce prompt-injection spillover.

Positive, concrete instructions ('respond in under 100 words') outperform negative abstractions ('do not be verbose').

Tool use is a loop: the model emits a tool_use block, the client executes it and returns a tool_result block, and the model continues until it stops requesting tools.

Tool descriptions are part of the prompt; ambiguous or overlapping descriptions cause wrong tool selection and wrong arguments.

Input schemas constrain arguments via JSON Schema; validation failures should be returned to the model as error results so it can correct.

Set a maximum iteration or turn budget per agent run to bound cost and prevent runaway loops.

Parallel tool calls are appropriate only for independent operations; dependent calls must be sequenced because later arguments depend on earlier results.

Tool errors should be surfaced verbatim to the model rather than silently swallowed, since the model can often recover from a descriptive error.

Agentic workflows should be idempotent at the tool layer, because retries after transient failures may re-execute a call.

Human-in-the-loop approval gates belong on irreversible or high-blast-radius tools (writes, payments, deletions), not on read-only lookups.

RAG pipeline stages: chunk, embed, index, retrieve top-k by similarity, rerank, then assemble retrieved passages into the prompt.

Retrieval quality is bounded by chunking: chunks too large dilute the embedding, chunks too small lose the surrounding context needed to answer.

Hybrid retrieval combines dense vector similarity with lexical (BM25-style) matching to cover both semantic and exact-term queries.

Reranking a larger candidate set down to a small top-k improves precision before tokens are spent on the prompt.

Lost-in-the-middle behavior means models attend less reliably to content buried mid-context; place the most relevant passages near the start or end.

Summarization or truncation of older turns is the standard remedy when conversation history approaches the context limit.

Citations should be grounded in retrieved chunk identifiers so answers can be traced and hallucinated references detected.

Retrieved content is untrusted input; instructions embedded inside documents must not be treated as system-level commands.

Defense in depth: input filtering, system-prompt constraints, output validation, and monitoring each catch different failure classes.

Prompt injection is mitigated by separating instructions from data and by never granting untrusted content authority over tool calls.

Constitutional or policy-based self-critique passes let the model check its draft against stated rules before returning it.

Guardrail classifiers on both input and output catch policy violations that prompt instructions alone may miss.

Least-privilege tool scoping limits blast radius: an agent should hold only the credentials and permissions its task requires.

PII redaction belongs before logging and before sending content to third-party services, not only at display time.

Refusals should be specific about the boundary crossed; over-broad refusals are a quality defect measured like any other error.

High-stakes outputs (medical, legal, financial) require human review and explicit uncertainty signaling rather than silent confidence.

Build a labeled golden set with representative and adversarial cases; measure accuracy per category rather than as one aggregate number.

LLM-as-judge scoring requires a rubric and calibration against human labels; uncalibrated judges drift and inflate scores.

Regression suites should run on every prompt or model change, since prompt edits are code changes with unbounded blast radius.

Track latency percentiles (p50/p95/p99), token counts, cost per request, and tool-call error rates as first-class production metrics.

Trace each request end to end: prompt version, retrieved chunk IDs, tool calls, and final output, so failures are reproducible.

A/B or canary comparison against a baseline is the reliable way to attribute quality changes to a specific modification.

Deterministic assertions (schema validity, required fields, forbidden strings) complement subjective quality scoring.

Online evaluation on sampled production traffic catches distribution shift that a static offline set cannot.

Retries should use exponential backoff with jitter and apply only to retryable errors (rate limits, 5xx, timeouts), never to validation errors.

Rate limits are enforced on requests per minute and tokens per minute; batch or queue work rather than retrying immediately.

Streaming reduces perceived latency and enables early termination but complicates downstream validation, which must buffer before checking.

Pin model versions in production and roll forward deliberately; unpinned aliases can change behavior without a code deploy.

Prompt and configuration changes belong in version control with the same review and rollback path as application code.

Idempotency keys and request timeouts prevent duplicate side effects when a client retries after an ambiguous failure.

Caching stable prefixes (system prompt, tool definitions) reduces cost and latency where prompt caching is supported.

Health checks, circuit breakers, and graceful degradation (fallback model or cached answer) keep the integration available during upstream incidents.