Subjects

MCP Servers and Subagent Orchestration

Understand why the Model Context Protocol exists and how an MCP server extends what an agent can see and do, why that access model demands more careful trust and credential design than local file edits, and how subagents let you decompose a task across isolated context windows — sequentially for context hygiene, or in parallel for wall-clock speed — with git worktrees keeping concurrent writers from clobbering each other.

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.

LLM Observability and Evaluation

Interview-ready coverage of running LLM systems in production: what a full request trace must capture, token/cost/latency dashboards as product metrics, the precise line between offline evals and online monitoring, LLM-as-judge as a general technique with its biases and calibration, human review workflows, CI regression suites that treat prompts and models as code, canarying prompt and model changes, and a worked dashboard-diagnosis example.

Case Study: Shipping a Fix with Claude Code, End to End

Follow one bug — CSV exports intermittently missing rows in a TypeScript/Node monorepo — from a ten-minute setup audit through exploration, a wrong hypothesis, a checkpoint recovery, implementation, a workflow that generalizes the fix, a PR with /code-review, CI, and a follow-up routine. Every decision is named, justified, and linked back to the track subject that owns it, so you can see the whole toolkit working together instead of one mechanism at a time.

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.

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.

Case Study: Design a Coding Agent

Model interview answer for designing a terminal coding agent that reads, edits, runs and verifies code in a repository: requirements and threat model, the agentic loop, a minimal tool set with output caps, a permission model that separates read from write from execute, context management for a finite window (truncation, compaction, subagents, cached prefixes), layered memory, cost and step budgets, prompt-injection defence, evaluation on task suites, and observability.

Claude Code Workflows and Agent Teams

Go beyond one conversation delegating a few subagents at a time. Learn dynamic workflows — scripts Claude writes that a runtime executes in the background to coordinate dozens to hundreds of agents — how to start, watch, save, and resume one, and the cost and scale controls that keep a run bounded. Then learn agent teams, an experimental peer-coordination model with a shared task list and direct messaging between teammates, and when reaching for a lead-and-teammates structure beats both a single agent and a scripted workflow.

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.

Evaluating RAG Systems

A deep, interview-ready treatment of RAG evaluation: why retrieval and generation must be measured separately, worked recall@k/MRR/NDCG@k arithmetic, generation metrics including faithfulness and answer relevance, how to build and version a gold evaluation set, LLM-as-judge rubric design and bias calibration, RAGAS-style automated pipelines, hallucination-detection techniques, and a worked diagnostic example that separates a retrieval problem from a generation problem.

Cost and Latency Engineering for LLM Apps

The reusable toolkit behind every 'make it cheaper and faster' interview question: why input tokens dominate cost and output tokens dominate latency, how prompt-prefix caching and semantic caching work and where each breaks, model routing and cascades, streaming and parallel tool calls as latency levers, the TTFT-plus-decode model of p95 latency, and the cost-per-1,000-conversations math that ties every lever to a number leadership will ask for.

Case Study: Design a Customer-Support Assistant

Model interview answer for designing an LLM customer-support assistant: requirements and non-goals, workflow-vs-agent decision, tenant-safe RAG over a help centre, tool calls for account lookups and refunds with confirmation, conversation state, escalation and the 'I don't know' path, layered guardrails, offline and online evaluation, cost and latency numbers with levers, and a rollout plan.

Headless Mode, CI Automation & the Agent SDK

Learn how to run Claude Code non-interactively with -p, parse its structured JSON output, wire it into GitHub Actions and GitLab CI/CD with cost and safety controls, and understand the Agent SDK as the same harness exposed as a Python and TypeScript library — including when to reach for each option.

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.

RAG Architecture End to End

A deep, standalone treatment of RAG architecture: the offline ingestion path and online query path as one diagram, a named failure mode at every stage, why the 'naive RAG' first pass plateaus at mediocre quality, query rewriting and multi-query fan-out, the confidence gate and the 'I don't know' path, citations and grounding checks, advanced patterns (parent-child, HyDE, agentic retrieval) and when they earn their complexity, and a RAG maturity ladder for the 'how would you improve this system' follow-up.

Fine-Tuning: SFT, LoRA/QLoRA, RLHF and DPO

A deep, standalone treatment of fine-tuning for AI engineering interviews: the mechanics of SFT, LoRA/QLoRA, RLHF and DPO; realistic data requirements and where the data comes from; the sharp line between behaviour problems (fine-tune) and knowledge problems (RAG); training and serving cost order-of-magnitude; how to evaluate a fine-tune against catastrophic forgetting and a prompted baseline; and a worked decision scenario for a formatting-adherence bug in a support bot.

Agent Architectures and the Agentic Loop

A precise, vendor-neutral treatment of the agentic loop for AI engineering interviews: the observe-decide-act loop itself, the ReAct pattern and why explicit reasoning traces help tool selection, the plan-act-observe-reflect variant and when its extra LLM calls are worth it, single-agent vs multi-agent at a glance, termination and budget controls, failure modes with mitigations (loops, tool hallucination, runaway cost, context poisoning, analysis paralysis), a worked compounding-error-rate calculation, and a worked workflow-vs-agent decision.

Claude Code Scheduled Tasks and Remote Agents

Claude Code doesn't have to live inside a single terminal you're staring at. It can poll in the background of an open session, fire on a schedule with your laptop closed, run in the cloud while you sleep, react to a chat message from your phone, and let you steer a session running on your desk from the bus. This subject builds the decision framework for all of it — /loop, /goal, desktop scheduled tasks, cloud routines, Remote Control, cross-session messaging, and channels — and the safety habits that make unattended and remote Claude trustworthy rather than terrifying.

Claude Code Sandboxing and Security

Learn to reason about Claude Code as a system with a real attack surface: where prompt injection actually enters a session, how the built-in Bash sandbox and dev containers isolate what a command can reach, how permission rules and hooks compose into layered defense, what MCP servers can do outside the sandbox, and what data actually leaves your machine. By the end you'll be able to design a defensible sandbox-plus-permissions policy for a real team, not just recite the individual settings.

Vector Databases and Hybrid Search

A systems-level treatment of the retrieval layer for RAG: pgvector vs dedicated vector databases (Pinecone, Weaviate, Chroma, Milvus) with a comparison table and a 'when Postgres is enough' decision rule; HNSW vs IVF ANN indexing and their recall/latency trade-offs; pre-filter vs post-filter vs filtered-ANN and why naive post-filtering silently starves results; hybrid dense+BM25 search with reciprocal rank fusion (RRF) worked by hand; and cross-encoder re-ranking with its O(k) cost model.