AI Engineering

Anatomy of a message

System prompts that control behavior

Multi-turn conversations

Streaming responses

Tool use — letting Claude call your functions

The tool-use loop

Token economics: cache it or pay 10×

Structured output — JSON without prompt-hacking

🏆 Capstone — Build a customer-support agent

Streaming responses: SSE + token-by-token UX

Stop sequences and stop_reason

System prompts that actually work

Few-shot prompting

Chain-of-thought and thinking

Structured outputs (JSON mode)

Token counting and cost estimation

Prompt caching

Retry, backoff, and error handling

Vision: images in messages

🎯 Review: AI engineering module 1 recap

PDFs and the Files API

Tool use: function calling basics

Tool use loop and agentic loops

Code execution tool

Built-in web search

MCP servers: extending Claude

Evals: measuring LLM quality

Cost & latency optimization

Safety: prompt injection and jailbreaks

Capstone: production deployment checklist

RAG: why retrieval beats raw prompting

Embeddings: text → vectors

Vector databases

Chunking strategies

Hybrid search: BM25 + vector

Reranking

Metadata filtering

Citations and groundedness

Multi-query / HyDE expansion

Production RAG checklist

🎯 Review: AI engineering module 2 recap

Agents: planner + executor pattern

Agents: ReAct (reason + act) loop

Multi-agent orchestration

Memory in agents

Tool selection: parallel vs sequential

Anthropic Computer Use tool

Anthropic Code Execution tool (deep dive)

MCP (Model Context Protocol) servers

Function calling vs tool use vs structured output

Prompt caching strategies (extended)

Token economics: caching, batching, distillation

Fine-tuning: when (rare), how (LoRA), pitfalls

DPO and RLHF basics

Embedding models comparison

Vector DB at scale: Pinecone vs Qdrant vs pgvector

Hybrid search tuning (BM25 + dense + rerank)

Eval harness: building a golden set

LLM-as-judge evals: pitfalls and best practices

Cost monitoring: per-feature unit economics

Capstone: design a customer-support AI agent end-to-end

🎯 Review: AI engineering module 3 recap

Multi-modal RAG: indexing images alongside text

Cross-encoder rerankers vs ColBERT

RRF math: why rank-fusion beats score-blending

Query rewriting and HyDE

Recursive retrieval: parent-child chunks

ReAct vs Plan-and-Execute agents

Reflection loops that actually help

Memory: episodic vs semantic

Tool schemas the LLM uses correctly

Structured output: JSON mode, grammars, instructor

Guardrails — defense in depth

Semantic caching

Token budget in long contexts

Cost: model routing + eval-driven downgrade

Regression suites and prompt versioning

Fine-tuning vs RAG: decision matrix

LoRA and QLoRA

Vector DB choice

Privacy: PII redaction and on-prem inference

🏆 Capstone — production-grade RAG end-to-end

🎯 Review: AI engineering module 4 recap

Vision inputs: image + text in one call

Vision OCR: extract structured data from a receipt

Vision: chart and graph reasoning

Audio: process transcripts with Claude

Long context: 1M window strategies

Prompt caching: top-level breakpoints

Prompt caching: silent invalidators audit

Streaming: SSE events and final-message helper

Compaction: long-running conversations beyond 200K

Adaptive thinking: replacing budget_tokens

Effort parameter: cost/quality tuning

Files API: persistent document processing

Skills: pre-packaged behavior bundles

Batches API: 50% off for offline workloads

Token counting + cost optimization checklist

Multi-agent orchestration patterns

Voice agent architecture

Self-improving prompt: eval-driven prompt loop

Frontier model selection: Opus vs Sonnet vs Haiku

🏆 Capstone: end-to-end multi-modal agent