AI Engineering · Workspace
Overview
168 lessons in 15 modules, 27 free.
Part 1Foundations
01AI engineering fundamentals13 lessons
- Introduction to AI engineering
- The AI application stack: from model to product
- Calling a model API: request, response and cost
- Tokens: how models read text and charge for it
- Choosing a model: capability, cost and speed
- Hosted and open-weight models: the tradeoffs
- Sampling and temperature: controlling randomness
- Context windows: what fits and what gets lost
- Streaming responses: showing output as it arrives
- Model API errors, rate limits and retries
- Estimating the cost and latency of a feature
- Design: a ticket summary feature
- Lab: a command-line chat with streaming
02How LLMs work: what builders need to know12 lessons
- Next-token prediction: how an LLM writes text
- Embeddings: turning words into numbers with meaning
- Attention: how the model decides what to focus on
- Transformers: the architecture in one picture
- Training stages: pretraining, tuning and feedback
- KV cache and prompt caching: reusing earlier work
- Quantization: running models in less memory
- Mixture of experts: large models that run fast
- Reasoning effort: paying for extra thinking
- Hallucinations: why models state false things
- Under the hood: queries, keys and values
- Under the hood: how decoding picks each token
03Prompting and structured outputs12 lessons
- Prompt anatomy: instructions, context, examples, format
- System prompts: setting the role and the rules
- Few-shot prompting: teaching by example
- Step-by-step prompting: asking for the reasoning
- Structured outputs: getting reliable JSON
- Validating model output with Pydantic
- Prompt templates and version control
- Long inputs: splitting work across many calls
- Multimodal inputs: images, PDFs and audio
- Prompt pitfalls: ambiguity, drift and leakage
- Design: an invoice data extractor
- Lab: turning messy emails into clean records
Part 2Retrieval and knowledge
04Embeddings and vector search10 lessons
- Semantic search: finding by meaning, not keywords
- Embedding models: choosing and comparing them
- Similarity measures: cosine, dot product, distance
- Vector databases: what they add to search
- pgvector: vector search inside PostgreSQL
- Approximate nearest neighbours: speed vs recall
- Vector indexes: HNSW, IVF and quantization
- Filtering vector search by metadata
- Choosing a vector store for your workload
- Lab: semantic search over 10,000 documents
05RAG: answering from your own data16 lessons
- RAG: grounding answers in your own documents
- Long context or RAG: when to send the whole document
- Document ingestion: parsing PDFs, pages and tables
- Chunking: splitting documents for retrieval
- Contextual retrieval: giving each chunk its context
- Hybrid search: combining keywords and vectors
- Reranking: putting the best passages first
- Query rewriting: improving what gets searched
- Citations: showing where each answer came from
- Keeping a RAG index fresh: updates and deletes
- Access control in RAG: who may see what
- Debugging RAG: the common failure modes
- Text-to-SQL: answering questions from databases
- Advanced retrieval: multi-step, graph and agentic
- Case: Intercom’s custom reranker for support RAG
- Design: a support assistant over company docs
Part 3Tools and agents
06Tool use and the Model Context Protocol10 lessons
- Function calling: letting models use tools
- Designing tools a model can use well
- Handling tool results and tool errors
- Parallel and sequential tool calls
- Model Context Protocol: one standard for tools
- Building an MCP server in Python
- Code execution: running model-written code safely
- Computer use: models operating browsers and apps
- Design: a meeting booking assistant
- Lab: give a model a weather and maps tool
07Agents: models that plan and act15 lessons
- Agents: models that act until a goal is met
- Workflows vs agents: when you need autonomy
- ReAct: reasoning, acting and observing in turns
- Planning: breaking a goal into steps
- Agent memory: short-term context, long-term stores
- Context engineering: choosing what the model sees
- Multi-agent systems: orchestrators and subagents
- Agent2Agent protocol: agents calling other agents
- Human in the loop: approvals and handoffs
- Agent reliability: loops, limits and budgets
- Agent frameworks: when to use one
- Lab: an agent loop from scratch in Python
- Lab: rebuilding your agent with LangGraph
- Case: Swiggy’s text-to-SQL analyst agent
- Design: a research agent that writes reports
Part 4Quality and safety
08Evaluating AI applications15 lessons
- Evals: testing systems that never answer the same way
- Building an eval set from real examples
- Code-based checks: exact match, rules and schemas
- Testing code that calls a model: fakes and recordings
- LLM-as-judge: grading outputs with a model
- Judge calibration: checking LLM judges against people
- Human review and labeling
- Evaluating RAG: retrieval and answer quality
- Evaluating agents: task success and trajectories
- Simulated users: testing agents before launch
- Regression testing for prompts and models
- Online evaluation: A/B tests and user feedback
- Error analysis: finding what to fix first
- Case: how Shopify evaluates its merchant agent
- Lab: an eval harness for a support assistant
09Guardrails and security12 lessons
- Risks in LLM applications: an overview
- Prompt injection: when input becomes instructions
- Indirect prompt injection through documents and tools
- Data leakage: protecting secrets and personal data
- Input and output guardrails
- Refusals and fallbacks: when the model declines
- Content moderation: filtering harmful output
- Least privilege for agents and tools
- MCP security: servers, tokens and tool poisoning
- Red-teaming an AI application
- AI regulation: EU AI Act, DPDP and content labels
- Design: a safe customer-facing assistant
Part 5Production
10Cost, latency and scaling11 lessons
- Where the time goes in an LLM request
- Caching for LLM apps: exact, semantic and prompt
- Token economics: caching, batch and effort together
- Model routing: small models first, large when needed
- Batch and background processing for LLM jobs
- Provider rate limits, queues and fallbacks
- Cost control: budgets, quotas and alerts
- Charging for AI features: metering and quotas per customer
- Self-hosting open models: when and how
- Case: Instacart’s batch platform for LLM jobs
- Design: scaling a chat assistant to a million users
11Observability and operations9 lessons
- Deploying an AI service: containers and the cloud
- Tracing LLM calls: seeing every step
- Monitoring quality in production
- Prompt and model versioning in production
- AI user experience: waiting, uncertainty and corrections
- User feedback loops: learning from real usage
- Model upgrades: switching without regressions
- Incident response for AI features
- Lab: adding tracing to an agent
Part 6Customization and multimodal
12Fine-tuning and model customization9 lessons
- Prompting, RAG or fine-tuning: choosing the right fix
- Fine-tuning basics: what changes in the model
- Preparing data for fine-tuning
- LoRA: fine-tuning with small add-on weights
- Distillation: training a small model from a large one
- Preference tuning: RLHF and DPO in plain terms
- Synthetic data: generating training examples
- Evaluating a fine-tuned model
- Lab: fine-tuning a small open model with LoRA
13Multimodal and voice applications7 lessons
Part 7Design practice and interviews
14End-to-end AI system design8 lessons
- Design: a shopping assistant for an online store
- Design: a meeting notes summarizer
- Design: a writing assistant inside an editor
- Design: an AI search engine with citations
- Design: a coding assistant
- Design: an enterprise document Q&A product
- Design: an AI customer support platform
- Design: a data analysis agent
15AI engineering interviews9 lessons
- AI engineering interviews: what companies test
- Explaining LLM concepts clearly in interviews
- AI system design interviews: a framework
- Live coding with model APIs
- Take-home tasks: shipping an AI feature to review
- Discussing evals and tradeoffs under pressure
- Common mistakes in AI engineering interviews
- Mock interview: a RAG assistant
- Mock interview: an agent for internal tools