Become an AI Engineer

Build the floor. Skipping this hurts you forever — every later stage assumes fluency here.

• Python deep — async/await (critical for AI APIs), typing, generators, context managers, virtual envs.
• Math & stats — linear algebra (vectors, dot products), probability, gradient intuition.
• ML fundamentals — supervised/unsupervised, overfitting, train/val/test, evaluation metrics.
• Deep learning basics — neurons, backprop, transformers from first principles (Attention is All You Need).
• Tools — Jupyter, pip/poetry, Git, Docker basics.

Calling models is the easy part. Engineering reliable systems around them is the hard part.

• Provider APIs — OpenAI, Anthropic Claude, Gemini, Mistral, Groq, NVIDIA NIM. When to use which.
• Prompt patterns — system / user / assistant turns, few-shot, chain-of-thought, structured output (JSON mode, schemas).
• Function / tool calling — tool schemas, multi-turn tool use, error handling, parallel tools.
• Context window mgmt — chunking, summarisation, sliding-window strategies for long docs.
• Cost & latency — token economics, streaming, caching (prompt caching), batching.
• Open-source models — running Llama / Mistral / Qwen locally with Ollama or vLLM.

Retrieval-Augmented Generation gives LLMs access to your data. 80% of real LLM apps are RAG.

• Embeddings — what they are, semantic search vs keyword, choosing a model (OpenAI ada, Cohere, BGE, e5).
• Vector databases — Pinecone, Weaviate, Qdrant, Chroma, pgvector. Hosted vs self-hosted tradeoffs.
• Chunking strategy — fixed-size, recursive, semantic, document-aware. Chunk overlap. Metadata.
• Retrieval strategies — similarity search, MMR, hybrid (BM25 + dense), re-ranking, multi-query, HyDE.
• Vectorless RAG — when full-text search or structured queries beat vectors.
• Evaluation — RAGAS (faithfulness, answer relevance, context precision/recall), LLM-as-judge.

Where most product value will live for the next decade. Single-shot completions don't ship; orchestrated agents do.

• ReAct loop — Reason → Act → Observe, with structured tool calls and a strict iteration cap.
• Multi-agent orchestration — supervisor/worker, parallel fan-out, generator+critic, debate. When NOT to use multi-agent.
• Memory architectures — working, short-term, long-term episodic, semantic, procedural. Memory extraction + the "forget me" button.
• Reliability & guardrails — the 8 failure modes (infinite loop, tool hallucination, premature stop, etc.) and defence-in-depth.
• Frameworks — LangGraph state machines, CrewAI, AutoGen, smolagents. When to hand-roll instead.
• Self-correction patterns — verify-then-answer, critic loops, confidence scoring, test-driven generation.

Demos are easy. Shipping something that survives real traffic without setting money on fire is hard.

• Serving shapes — stateless API, edge functions, job queues, BentoML/Modal. Picking the right one.
• Streaming — SSE, WebSockets, first-token latency budgets, interruptible generation.
• Queue architecture — long-running agents on Redis/SQS + workers + webhooks.
• Rate limiting & quotas — per-IP, per-user daily token budgets, tier-based model routing.
• Tracing — every span carries session, prompt hash, model, tokens, cost, latency, tool calls.
• Online eval sampling — 1–5% of traffic LLM-judge scored; alert on drift.

The things that separate "shipped a demo" from "owns the system at 100K MAU".

• Prompt injection & jailbreaks — privilege separation, sandwich tags, indirect injection from retrieval.
• PII handling — input scrubbing, log redaction, output filtering, BAA/DPA when needed.
• Fine-tuning decision tree — when prompts + RAG aren't enough; LoRA vs QLoRA vs DPO.
• Dataset curation — 500–2000 high-quality examples beats 50k mediocre ones.
• Cost levers — caching, model routing, prompt caching, output truncation, batch APIs, self-host crossover.
• Per-user cost models — tagging every call, building free-tier sustainability math.

You can know the material cold and still flunk. This part is the meta-skill — communicating tradeoffs the way senior interviewers expect.

• The L4 / L5 / L6 bar — what's expected at each level; how to signal correctly.
• The system-design pattern — clarify → estimate → sketch → deepen → defend.
• 5 worked examples — Doc-Q&A RAG, coding agent, multi-agent research, structured extraction at scale, support agent.
• Common questions — RAG eval, hybrid retrieval tradeoffs, fine-tune-or-not, debugging hallucinations.
• Behavioural for senior roles — ownership stories, eval-strategy stories, production-incident stories.
• Red flags interviewers watch for — vague answers, premature complexity, missing eval story.

• Doc-Q&A on your own knowledge base — RAG over a 100+ page PDF set with proper chunking and retrieval evaluation.
• Coding assistant with tool use — read repo, run tests, fix bugs in a loop.
• Multi-agent research assistant — planner + searcher + writer + critic. Topic in, citations-backed report out.
• Production chatbot with eval harness — golden set + LLM-as-judge running on every PR.
• Fine-tuned domain model — QLoRA on a 7B open model for one narrow task; benchmark against GPT-4.

Full chapters — now live

Each topic above has a full deep-dive chapter in the Hirestack style — opinionated, with war stories, failure modes, and interview-style cross-questioning.