Subjects

Git Workflows with Claude Code

Learn how Claude Code reads git state for context, generates commits and PRs with proper attribution, reviews diffs with /code-review, resolves conflicts and rebases, and isolates parallel work with git worktrees — plus the safe-habits checklist that keeps an agent with git access from doing something you can't undo.

Plan Mode and Autonomous Workflows

Understand the concrete mechanisms Claude Code exposes for trading oversight against speed — plan mode's research-then-approve flow, including how to review, edit, and iterate on a plan before anything executes, plus self-pacing loops and goal conditions for unattended work. By the end you'll know when each mode earns its cost, how to steer a plan instead of just accepting or rejecting it, and where to go next when a task outgrows a single conversation entirely.

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.

Skills, Slash Commands & Plugins

Learn how Claude Code's built-in commands, custom skills (which have absorbed custom slash commands), and plugins let you turn a one-off prompt into a reusable, shareable capability — and how to decide which of the four extension mechanisms fits a given piece of team knowledge.

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.

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.

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.

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.

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.

Settings, Permissions & Hooks

Master Claude Code's settings hierarchy, the full permission-rule syntax and mode set, and the hooks system's lifecycle events, JSON contract, and exit-code semantics — the three mechanisms that turn an agent you supervise into one your whole team can trust unattended.

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.

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.

Frameworks Landscape: LangChain, LlamaIndex, CrewAI, AutoGen, Semantic Kernel, Assistants API

A trade-off-first tour of the LLM application framework landscape — LangChain, LlamaIndex, CrewAI, AutoGen, Semantic Kernel and hosted Assistants-API-style platforms — organised around what each abstraction gives you, what it hides, and when the honest answer is to roll your own thin orchestration instead.

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.