AI Engineering

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.

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.

Tool and Function Calling

Deep dive on tool/function calling: the request-execute-return loop that turns a text generator into something that can act, why schema and description quality is the real bottleneck on tool-selection accuracy, tool-choice modes (auto/forced/none), parallel tool calls and their latency payoff, error handling and argument validation, where the permission boundary actually lives, keeping results compact, and a side-by-side of Anthropic tool use and OpenAI function calling.

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.

Claude Code Platforms and Interfaces

Claude Code is one engine with many front doors: a terminal CLI, VS Code and JetBrains plugins, a desktop app, cloud sessions on the web, a mobile client, and integrations with Chrome, Slack, and computer control. This subject maps what each surface actually gives you, where they diverge from the CLI reference experience, and how to choose deliberately instead of by habit — plus the terminal ergonomics (statusline, keybindings, fullscreen, voice) and output styles that shape how any single surface feels day to day.

Claude Code: Models, Cost, and Context

Claude Code gives you real levers over capability, latency, and cost: which model runs, how hard it thinks, whether it runs faster for more money, and how aggressively it manages its own context window. This subject teaches you those levers precisely — model aliases vs. pinned IDs, effort levels, fast mode, the advisor tool, prompt caching mechanics, subagent model routing, and the concrete habits that separate a $3/day session from a $30/day one — so you can make deliberate tradeoffs instead of accepting whatever the defaults hand you.

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.

Multi-Agent Orchestration

A vendor-neutral treatment of multi-agent LLM systems: the supervisor/worker pattern, handoffs versus shared state, pipeline-vs-barrier synchronization for parallel fan-out, a worked cost-multiplication example, and the honest heuristic for when a single stronger model beats a fleet of coordinating agents. Cross-links `mcp-and-subagents` as the concrete Claude Code implementation and `plan-and-loop-modes` for the pipeline and adversarial-verification mechanics.

MCP and Tool Integration Protocols

The concept and design-interview layer above MCP: why a standard client-server protocol replaced bespoke per-app tool integrations, the server/client/resource/tool abstractions at an architectural level, what MCP adds on top of plain function calling (and when bespoke calling is still the right answer), the trust boundary a third-party server introduces, and how to frame the 'build a server vs write a function' decision when an interviewer asks.