AI Engineering

Claude Code Fundamentals

Learn what makes Claude Code an agentic tool rather than an autocomplete engine: the read-act-observe loop, the built-in tools it uses to explore and change your codebase, the permission modes that govern its autonomy, and where its configuration lives. By the end you'll be able to trace exactly what happens, tool call by tool call, when you ask it to fix a bug.

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.

Claude Code Best Practices: Reliable, Cheap, High-Leverage Sessions

Synthesise the whole Claude Code track into working habits: manage the context window deliberately, always give Claude a check it can run, plan before touching code, prompt with acceptance criteria, scope permissions narrowly, control cost, and know how to recover when a session goes wrong.

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.

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.

Transformers for AI Engineers

Covers what an AI Engineer interview actually probes about transformer internals: scaled dot-product and multi-head attention, why decoder-only architectures won, why the KV cache exists and how its memory footprint is computed, what parameter count does and doesn't predict, and positional encoding — with worked numbers for KV cache memory and prefill-vs-decode cost.

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.