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.

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.

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.

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.

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.

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.

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.

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.

Chunking and Embedding Strategies

Deep dive on the two decisions that most determine RAG retrieval quality: chunking strategy (fixed-size, structure-aware, semantic, parent-child), overlap, chunk size vs recall, embedding model selection, and embedding drift when you swap models — with worked recall@k examples.