Prompt & Context Engineering

Tokenization and Context Windows

A deep, numbers-first look at subword tokenization (BPE), why tokens are not words or characters, the 'lost in the middle' effective-context problem, worked token-budget arithmetic for a real prompt, and why long context windows do not make RAG obsolete. Written as an AI Engineer interview reference with concrete worked examples and comparison tables.

Prompt Engineering

A practitioner's tour of prompt engineering as an AI Engineer interview topic: what belongs in the system prompt vs the user prompt and why, when few-shot examples help and when they stop paying off, what chain-of-thought actually buys you mechanically, structured outputs and schema-constrained decoding, treating prompts like versioned code with regression tests, and the decision framework for when a longer prompt is the wrong answer and RAG or fine-tuning is the right one.

Advanced Prompting Techniques

The technique landscape beyond few-shot and basic chain-of-thought: breaking a task into subtasks, sampling and voting across multiple reasoning chains, interleaving reasoning with tool calls (ReAct), searching over a tree of partial solutions, when a persona measurably helps versus is theater, letting a model or optimizer write the prompt for you (DSPy and friends), and what changes once the model itself does extended, budgeted reasoning at inference time. Each technique is presented the way an interviewer expects: what it costs, what it buys, and the concrete signal that tells you it's the wrong tool for the task in front of you.

Context Engineering Fundamentals

The discipline that succeeds prompt engineering once a system has retrieval, tool calls, and conversation history: treating the entire context window — not just the prompt string — as an assembled, budgeted, ordered artifact. Covers the anatomy of a real app's context window, token-budget allocation across fixed and variable regions, selection and ordering strategies, compaction (summarization, truncation, structured notes), isolation between trust boundaries, the four named context failure modes with repro sketches, and a fully worked, real-numbers example of assembling one turn of a support bot's context.

Memory Systems for LLM Applications

A working taxonomy for one of the most conflated terms in AI engineering: the conversation window (short-term), persistent facts across sessions (long-term), what-happened-last-time (episodic), and externalized scratchpads (working memory). Covers durability criteria for what to persist, eager-load-vs-retrieval-triggered design, the failure modes — staleness, injection, bloat, conflicting facts — and a concrete walkthrough of how CLAUDE.md and context compaction implement exactly this taxonomy in a real product.

Guardrails and Prompt-Injection Defense

A deep dive on the topic every AI Engineer interview probes: guardrails as a pipeline wrapped around the model, not a sentence in the prompt. Covers input filtering (PII redaction, injection classifiers, topic filters), prompt injection as the defining LLM threat and why it has no clean code/data separation, defense-in-depth layers with worked examples, output filtering (schema, groundedness, PII, refusals), the hard limits of any classifier against an adaptive attacker, the latency/cost budget for a guardrail pipeline, and a full worked trace of an attack through every layer.

Prompt Evaluation and Versioning

The full production workflow for treating prompts as code: curating golden sets from real traffic, the scoring ladder from exact match to LLM-as-judge (and the judge biases that quietly wreck it), running evals as CI gates on every prompt diff, why offline evals lie and what online A/B testing catches that they miss, versioning and rollback through a prompt registry, and the tracing/observability layer that tells you a regression shipped before support does.

Prompt Caching and Context Cost Optimization

A mechanism-first look at prompt caching as a cost-engineering discipline: how prefix caching and KV-cache reuse actually work under the hood, why context engineering decisions (prompt layout, history trimming, retrieval top-k) are also cache-hit-rate decisions, when model routing and cascades beat a single big model, and a full worked example combining caching, trimming, and routing to cut an app's token bill roughly 10x. Written as an AI Engineer interview reference with real comparison tables and worked arithmetic.

Context Engineering for Agents

The capstone application of context engineering to the hardest case a practitioner faces: a long-running, tool-using agent instead of a single prompt. Covers why agents break naive context management (monotonic growth, unpredictable tool-output size, compounding cost and error), how to write system prompts that hold up over 100+ turns, why tool names/descriptions/schemas are prompt text with a per-turn cost, compaction and structured handoff between context windows, sub-agents as context isolation, just-in-time retrieval versus pre-loading (the Claude Code model), where steering files like CLAUDE.md fit, and how to evaluate agent context strategies with a worked 50-turn token-budget trace.

CLAUDE.md and Context Configuration

Understand why CLAUDE.md exists and how it composes with auto memory and settings.json, how to write instructions that survive a growing context window instead of bloating it, and how to back a probabilistic agent with deterministic guardrails using permissions and hooks.

Case Study: Design a Long-Context Document Assistant

Model interview answer for designing the context pipeline behind an assistant that answers questions over a large document corpus (legal, policy or technical-docs, ~10M tokens): the arithmetic that rules out stuffing the corpus into a window, the long-context-vs-RAG decision and the hybrid retrieve-then-long-read pattern most candidates miss, structure-aware chunking and citation metadata, per-turn context budgeting and ordering, multi-turn history compaction that preserves the citation trail, quote-then-answer grounding and hallucinated-citation detection, defending against untrusted document content, cost/latency at scale, and evaluation with recall@k and faithfulness.

Case Study: Migrate a Production Prompt Suite Across a Model Deprecation

Model interview answer for the operational case study behind prompt versioning: your provider announces a 60-day deprecation of the model behind 40 production prompts. Walk the full migration — inventorying blast radius before touching anything, mining golden sets retroactively from production traces, categorizing the regressions a first eval run on the new model surfaces, rewriting prompts to drop old-model workarounds and adopt new-model features, re-laying-out prompts for the prefix cache, a staged shadow/canary/interleave rollout with concrete rollback triggers, the long-tail failure modes (judge drift, silent behavior change) that surface weeks after the migration looks done, and turning the fire drill into a standing prompt registry.