Subjects

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 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.

System Design Basics

Learn the fundamental principles behind building large-scale, reliable systems: scalability, availability, latency, and the key trade-offs that drive real-world architecture decisions.

Consistent Hashing

Understand the hash ring, virtual nodes, and why consistent hashing is the foundation of distributed caches (Redis Cluster, Memcached), distributed databases (Cassandra, DynamoDB), and CDN request routing.

Concurrency vs Parallelism

Untangle four words engineers constantly confuse: concurrency, parallelism, threads, and processes. Learn what runs truly simultaneously versus what merely interleaves, why Python's async model is single-threaded, and how getting this wrong causes real production bugs like sharing one database session across coroutines.

Decision Trees

Learn how decision trees partition feature space using impurity measures, how recursive binary splitting works, which hyperparameters control overfitting, and how feature importance is calculated — the foundation for understanding gradient boosting models like LightGBM and XGBoost.

Load Balancing

Understand how load balancers work, the algorithms they use (round-robin, least-connections, IP hash), Layer 4 vs Layer 7 differences, and how to design systems that stay healthy when servers fail.

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.

The CAP Theorem

Understand why distributed systems can only guarantee two of Consistency, Availability, and Partition Tolerance — and how real-world databases (Cassandra, Zookeeper, DynamoDB, Postgres) navigate this fundamental constraint.

Database Indexing

Learn how B-tree and hash indexes work internally, how the query planner uses them, when to create composite and covering indexes, and how to diagnose slow queries using EXPLAIN ANALYZE.

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.

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.

LightGBM

Understand how LightGBM builds sequential ensembles of trees, why leaf-wise growth outperforms level-wise, what every key hyperparameter controls, why a slow learning rate with more trees generalizes better, and how to diagnose and fix overfitting through regularization.

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 Application System Design

Learn to design LLM-powered systems for interviews and production: prompt vs RAG vs fine-tuning, end-to-end RAG architecture, token and cost budgeting, evaluation, guardrails, agents, caching and routing, with a worked support-assistant design.

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.

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.

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.

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.

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.