Theory · 30 min

• How AI, machine learning, deep learning and generative AI relate to each other
• What makes a system agentic: LLM + tools + a loop, and the role of LLMs as reasoning engines
• How LLMs work: tokens, embeddings, transformers and attention in plain terms
• How LLMs are trained (pre-training, instruction tuning, RLHF), temperature, context windows and hallucinations

Lab · 60 min

• Set up Python and store an LLM API key securely
• Train a scikit-learn sentiment classifier, then solve the same task with a zero-shot LLM prompt and compare the results
• Tokenise English and Indian-language text and compare token counts and cost
• Run a small open model with Hugging Face Transformers, inspect next-token probabilities and test temperature settings
• Trigger and document two hallucinations, and explain why they happened

Homework · 1 hour

Write a one-page explanation of how an LLM generates a response and ask Claude to critique it for accuracy; classify five everyday AI products as traditional ML, GenAI or agentic AI.

Theory · 30 min

• What agentic coding tools are and how Claude Code works in the terminal and IDE
• Project memory with CLAUDE.md, permission modes and managing the context window
• The recommended workflow: explore, plan, implement with tests, commit; give Claude a way to verify its work
• Extending Claude Code with skills, subagents, hooks and MCP servers, plus security and code-review practices

Lab · 60 min

• Install Claude Code, connect it to VS Code and configure permissions
• Create the course repository: Python environment, Git, .env handling and folder structure
• Generate a CLAUDE.md with /init, then refine it with test commands and rules such as never committing secrets
• Use plan mode to build a small LLM helper module with tests, reviewing every change before accepting it
• Add a hook that runs the formatter and tests after edits, and a subagent that reviews code for security issues

Homework · 1 hour

Use Claude Code to add logging and unit tests to the Day 2 helper module, and add two new project rules to CLAUDE.md.

Theory · 30 min

• Closed versus open-weight models and the major model families
• Choosing a model: quality, cost, speed, context window, privacy and licensing
• Anatomy of an LLM API call: messages, roles, parameters, streaming and token usage
• Running models locally with Ollama and using the Hugging Face Hub

Lab · 60 min

• Call a hosted LLM API with system and user messages and streamed responses
• Run an open-weight model locally with Ollama and call it from Python
• Build a command-line chatbot that keeps conversation history and can switch models
• Compare the models on five prompts for quality, latency and cost
• Handle timeouts, rate limits and invalid API keys gracefully

Homework · 1 hour

Add a third model through OpenRouter to the chatbot and record quality, latency and cost on ten new prompts.

Theory · 30 min

• Prompt structure: role, instructions, context, examples and output format
• Zero-shot, few-shot and chain-of-thought prompting
• Advanced techniques: prompt chaining, self-consistency and prompting reasoning models
• Prompt injection basics and testing prompts against a dataset

Lab · 60 min

• Solve five tasks (summarise, classify, extract, reason, rewrite) with a basic prompt, then improve each one
• Measure accuracy on a small labelled set for every prompt version
• Build a three-step prompt chain that turns a meeting transcript into action items and a follow-up email
• Attack your prompts with prompt injection and add defences

Homework · 1 hour

Build a personal library of five reusable, tested prompts for tasks from your own work.

Theory · 30 min

• Why applications need structured output instead of free text
• JSON mode, schema-based outputs and Pydantic validation
• Anatomy of a GenAI app: user interface, backend, prompts and model calls
• Building the app with Claude Code and reviewing what it generates

Lab · 60 min

• Define a Pydantic schema for invoices or résumés
• Extract structured data from 10 sample documents and validate the results
• Handle missing fields and invalid output with a single retry
• Build a Streamlit app to upload a document, view extracted fields and download JSON

Homework · 1 hour

Extend the document extractor to a second document type and add three unit tests for validation failures.

Theory · 30 min

• What embeddings are, how they capture meaning, and cosine similarity
• Vector databases, and semantic versus keyword search
• Why LLMs need external knowledge, and the RAG pipeline: load, chunk, embed, store, retrieve, generate
• Chunking strategies, grounded prompts and citations

Lab · 60 min

• Embed a set of FAQ entries and run a similarity search from scratch with numpy
• Load PDF policy documents, chunk them and index them in Chroma with metadata
• Build a question-answering pipeline with LangChain or LlamaIndex that cites its sources
• Add a Streamlit chat interface
• Test with questions the documents cannot answer and make the bot decline instead of guessing

Homework · 1 hour

Index 20 documents of your choice and write 10 test questions with expected answers.

Theory · 30 min

• Why basic RAG fails: poor chunks, missing context and wrong ranking
• Hybrid search, reranking and metadata filtering
• Query rewriting, multi-query retrieval and HyDE
• Parent-document retrieval, GraphRAG and agentic RAG

Lab · 60 min

• Create a test set of 20 questions with expected answers
• Measure the Day 6 chatbot as a baseline
• Add hybrid search and a reranker, then measure again
• Add query rewriting and parent-document retrieval, then measure again
• Record which technique helped most and what it cost in latency and tokens

Homework · 1 hour

Try one advanced RAG technique not used in the lab and record its effect on your test set.

Theory · 30 min

• Why GenAI apps are hard to test: non-deterministic, open-ended outputs
• Evaluation basics: golden datasets, RAG metrics (faithfulness, relevance, context precision) and LLM-as-a-judge
• End-to-end testing of GenAI interfaces with Playwright: handling streamed responses and flexible assertions
• Playwright Test Agents (planner, generator, healer) with Claude Code, and running test suites in CI

Lab · 60 min

• Build a 30-case test set, including tricky and unanswerable questions, and evaluate the RAG chatbot with Ragas or DeepEval
• Use Playwright Test Agents with Claude Code to draft a test plan and tests for the chat interface, then review them
• Write Playwright tests that ask questions, wait for streamed answers and check citations and refusal messages
• Add an LLM-as-a-judge check inside a Playwright test for open-ended answers
• Run the full suite in GitHub Actions so the build fails when quality drops

Homework · 1 hour

Add five Playwright tests for edge cases (empty input, very long question, unanswerable question) and run them in CI.

Theory · 30 min

• Vision-language models: understanding images, charts and documents
• How image generation works: diffusion models in plain terms
• Speech AI: speech-to-text and text-to-speech
• Multimodal use cases and their limitations

Lab · 60 min

• Extract data from receipt and chart images with a vision-language model
• Transcribe a voice note with a speech-to-text model (for example Whisper) and summarise it
• Generate images from text prompts and compare prompt styles
• Chain the steps together: voice note in, written summary and illustration out

Homework · 1 hour

Build an image-to-data extractor for a document type of your choice, such as product labels or restaurant menus.

Theory · 30 min

• Prompting versus RAG versus fine-tuning: when to use each
• Supervised fine-tuning, LoRA and QLoRA (parameter-efficient fine-tuning)
• Preparing training data and avoiding common mistakes
• Preference tuning (DPO), distillation and quantisation basics

Lab · 60 min

• Prepare 500 labelled examples in chat format
• Fine-tune a small open-weight model (under 2B parameters) with LoRA using Hugging Face PEFT on a cloud GPU notebook
• Compare the base and fine-tuned models on a held-out test set
• Save the LoRA adapter and run the fine-tuned model for inference

Homework · 1 hour

Form your capstone team and submit a one-page proposal: problem, users, data, architecture and success criteria.

Theory · 30 min

• How function or tool calling works: the model requests, your code executes
• Designing clear tool schemas and descriptions
• The tool-calling loop, parallel calls and error handling
• Safety: argument validation, permissions and human approval for actions

Lab · 60 min

• Define three tools: a calculator, a weather lookup and a customer-orders database query
• Implement the tool-calling loop with a hosted LLM
• Validate tool arguments and handle tool errors gracefully
• Require user confirmation before any action that changes data
• Test with requests that need zero, one and several tool calls

Homework · 1 hour

Add two tools to the assistant, including one that changes data behind a confirmation step, with tests.

Theory · 30 min

• What an agent is: the observe–think–act loop and the ReAct pattern
• Agents versus workflows, and when to use each
• Agent memory: short-term, long-term and state
• Agent frameworks (LangGraph, OpenAI Agents SDK, CrewAI and others) and safeguards such as step limits

Lab · 60 min

• Build a simple ReAct agent loop from scratch in Python
• Rebuild it with LangGraph using web search and note-taking tools
• Add memory so the agent remembers earlier findings in the session
• Add step limits and a stop condition, and trace every step the agent takes
• Run three research questions and review where the agent went wrong

Homework · 1 hour

Give the research agent a new tool, test it on five new questions and document where it fails.

Theory · 30 min

• Why AI needs a standard way to connect to tools and data
• MCP architecture: hosts, clients, servers, tools, resources and prompts
• Connecting AI to enterprise systems: APIs, databases and documents
• Authentication, access control and MCP security risks

Lab · 60 min

• Build an MCP server in Python that exposes a SQLite database as tools and resources
• Test the server with MCP Inspector
• Connect the server to Claude Code or another MCP client and query the data in natural language
• Hide sensitive columns and make read-only access the default

Homework · 1 hour

Add a second resource and a prompt template to the MCP server, and connect it to Claude Code.

Theory · 30 min

• When one agent is not enough: specialised agents working together
• Multi-agent patterns: supervisor, sequential handoff and reviewer
• Agent-to-agent communication and the A2A protocol (overview)
• Human-in-the-loop: approvals, interrupts and checkpoints

Lab · 60 min

• Build a supervisor agent with three specialists: researcher, writer and reviewer
• Pass work between agents using structured handoffs
• Add a human approval step before the final output is released
• Compare cost, time and quality against a single-agent version

Homework · 1 hour

Add a fact-checker agent to the content team and measure its effect on quality and cost.

Theory · 30 min

• From prototype to production: the LLMOps lifecycle
• Packaging GenAI apps as APIs with FastAPI and Docker
• Observability: logging, tracing and monitoring (Langfuse, Arize Phoenix, OpenTelemetry)
• Prompt versioning, CI/CD, retries and fallbacks

Lab · 60 min

• Wrap the RAG chatbot in a FastAPI service with streaming responses and package it with Docker
• Add tracing to see every retrieval, prompt and model call
• Add retries, timeouts and a fallback model, then simulate an outage
• Run the Day 8 Playwright and evaluation suite against the deployed container in the CI pipeline
• Build a simple dashboard of latency, cost and errors

Homework · 1 hour

Add an alert rule to the monitoring dashboard and write a one-page runbook for the chatbot.

Theory · 30 min

• Where cost and latency come from: tokens, model size and architecture
• Optimisation: response caching, prompt caching, model routing and shorter context
• Quantisation and serving open models efficiently (vLLM, Ollama)
• Balancing cost, speed and quality

Lab · 60 min

• Load test the chatbot and record baseline latency and cost
• Add response caching and route simple questions to a smaller model
• Serve a quantised open model and compare its speed and quality with the hosted model
• Re-run the Day 8 test suite to confirm quality has not dropped

Homework · 1 hour

Calculate the chatbot's monthly cost at 10,000 queries a day, before and after your optimisations.

Theory · 30 min

• Threats: prompt injection (direct and indirect), jailbreaks, data leakage and excessive agency
• OWASP Top 10 for LLM Applications and OWASP Top 10 for Agentic Applications
• Guardrails: input and output filtering, PII redaction and content moderation
• Red teaming GenAI applications

Lab · 60 min

• Attack the RAG chatbot and agent with 15 attempts, including an instruction hidden inside a document
• Add input and output guardrails, and redact personal data with Microsoft Presidio
• Restrict agent tool permissions to the minimum needed
• Re-run the attacks and compare results before and after
• Add the attacks to the Playwright suite as automated security regression tests

Homework · 1 hour

Run five attacks from the OWASP Top 10 for LLM Applications against your capstone and add defences for any that succeed.

Theory · 30 min

• Why AI governance matters: risk, accountability and trust
• Responsible AI principles: fairness, transparency, privacy, safety and human oversight
• Key frameworks and regulations: EU AI Act risk categories, NIST AI RMF, ISO/IEC 42001 and OECD AI Principles
• Governance in practice: AI use-case inventory, risk assessment, model cards, monitoring and audit

Lab · 60 min

• Classify the RAG chatbot and three sample use cases by EU AI Act risk category
• Run a risk assessment for the chatbot using the NIST AI RMF functions: Govern, Map, Measure and Manage
• Test for biased responses across different user profiles and record the findings
• Write a model card covering purpose, data, limitations, evaluation results and human oversight
• Build a risk register with controls and owners, linked to evidence from earlier labs

Homework · 1 hour

Complete an EU AI Act risk classification and a risk register for your capstone project.

Theory · 30 min

• What a complete capstone looks like: scope, architecture, testing, security and governance
• Production readiness checklist for GenAI solutions
• Reviewing architecture and AI-generated code as a team
• How the capstone demo will be assessed

Lab · 60 min

• Present the capstone architecture to another team for a structured peer review
• Run the full Playwright and evaluation suite and fix the top failures
• Use a Claude Code subagent to review security and code quality, then address the findings
• Complete the production readiness checklist and agree the remaining work

Homework · 1 hour

Fix the remaining issues from the peer review and finalise the capstone README.

Theory · 30 min

• Emerging trends: reasoning models, small language models and on-device AI
• Computer-use agents and AI coding agents
• Building a GenAI career: skills, portfolio and staying current
• How to present a GenAI project with confidence

Lab · 60 min

• Run the final test suite and confirm guardrails and the model card are in place
• Each team gives a 7-minute demo covering architecture, test results and lessons learned
• Answer questions from the panel and peers
• Create a personal 90-day GenAI learning plan

Homework · 1 hour

Finalise your 90-day learning plan and write a short portfolio case study of your capstone project.

Theory · 30 min

• What a Forward Deployed Engineer does and how the role differs from an AI engineer
• The engagement lifecycle: discover, prototype, pilot, production and handover
• Running discovery: stakeholder interviews, process walk-throughs and pain-point mapping
• Turning conversations into measurable success criteria and a scoped first use case

Lab · 60 min

• Form teams and receive a fictional client case (retail returns, manufacturing maintenance, insurance claims, hospital discharge summaries or bank KYC review) to carry through Phase 2
• Run a 20-minute discovery interview with the trainer playing the client
• Use Claude to turn the transcript into a draft requirements document, then correct it against your notes
• Agree 3–5 measurable success criteria and the first use case to build

Homework · 1 hour

Research the client's industry and list its top five process pain points and the regulations that apply.

Theory · 30 min

• Assessing client data: quality, formats, access, PII and compliance constraints
• Choosing the pattern: prompting, RAG, agents, fine-tuning or an existing product
• Non-functional requirements (security, latency, cost, data residency) recorded in architecture decision records (ADRs)
• Phased delivery (proof of concept, pilot, production) with effort and run-cost estimates

Lab · 60 min

• Profile the client's sample data and flag quality, access and privacy issues
• Design two candidate architectures and compare them on cost, risk and time to value
• Write an ADR for the chosen architecture
• Produce a phased delivery plan with effort and monthly run-cost estimates

Homework · 1 hour

Turn the discovery findings into a user journey map and a prioritised backlog of use cases.

Theory · 30 min

• Prototyping to test the riskiest assumption, with a strict cut list
• Advanced Claude Code for delivery speed: specs, subagents, skills and parallel sessions with git worktrees
• Headless Claude Code (claude -p) for scripted and CI tasks
• Reusing Phase 1 components: RAG, tool calling, evaluation and UI templates

Lab · 60 min

• Write a one-page spec and cut list for the client use case
• Build a working prototype with Claude Code, running parallel sessions for UI, backend and tests
• Add a headless Claude Code step to CI that reviews every pull request
• Demo the prototype against the success criteria agreed in discovery

Homework · 1 hour

Build one feature from the prototype's cut list and write three acceptance tests for it.

Theory · 30 min

• Why generic metrics fail in client domains
• Error analysis: reviewing real outputs, building a failure taxonomy and prioritising fixes
• Working with subject-matter experts: annotation guidelines, labelling and inter-rater agreement
• Calibrating LLM judges against expert labels, and generating synthetic edge cases

Lab · 60 min

• Review 50 prototype outputs and build a failure taxonomy
• Label a sample with the trainer acting as the domain expert and measure agreement
• Build and calibrate an LLM judge for the two most frequent failure types
• Generate synthetic edge cases, fix the biggest failure and show before-and-after scores

Homework · 1 hour

Expand the evaluation set to 100 cases and write the labelling guidelines.

Theory · 30 min

• Why clients standardise on managed platforms: Amazon Bedrock, Microsoft Foundry (formerly Azure AI Foundry) and Google Gemini Enterprise Agent Platform (formerly Vertex AI)
• Platform services: model access, managed knowledge bases, guardrails, evaluation and agent runtimes
• Deploying inside client environments: private networking, IAM roles, secrets and data residency
• Infrastructure as code (Terraform) and cost quotas

Lab · 60 min

• Port the prototype's model calls and knowledge base to one managed platform using a free-tier or trial account
• Deploy the app from a starter Terraform template with a private endpoint, an IAM role and a secrets manager
• Apply the platform's guardrails and re-run the Day 4 evaluation
• Set a spending quota and record the platform decision in an ADR

Homework · 1 hour

Compare the other two cloud AI platforms for the client case on cost and features, and update the ADR.

Theory · 30 min

• Why document-heavy processes (claims, KYC, invoices) are core FDE use cases
• Parsing layouts, tables and scans: OCR, layout-aware parsers (Docling, Unstructured) and vision-language models
• Schema-based extraction with field-level confidence and human validation queues
• Processing thousands of documents: batch APIs, throughput and cost

Lab · 60 min

• Extract structured fields from 200 mixed scanned and digital client documents
• Compare a parser-plus-LLM approach with a vision-language model on accuracy and cost
• Route low-confidence fields to a human validation queue
• Run the full set through a batch API and report field-level accuracy, throughput and cost

Homework · 1 hour

Add a new document type to the extraction pipeline and measure field-level accuracy.

Theory · 30 min

• The enterprise data landscape: warehouses and lakehouses (Snowflake, Databricks) and operational databases
• Text-to-SQL: schema context, semantic layers and example queries
• Safe query execution: validation, read-only access, cost limits and row-level security
• Evaluating analytics agents on real business questions

Lab · 60 min

• Build a text-to-SQL agent over a sample client warehouse (DuckDB locally or a Snowflake trial) with a curated semantic layer
• Validate every query before it runs: read-only, approved tables and row limits
• Enforce row-level security for each user
• Evaluate on 30 business questions and fix the most common failure

Homework · 1 hour

Add 20 harder business questions (joins, time periods, ambiguous terms) and improve the semantic layer.

Theory · 30 min

• Integration patterns: APIs, remote MCP servers and event-driven triggers (webhooks, queues)
• Enterprise identity: single sign-on with OAuth, OpenID Connect and SAML, and acting on behalf of the signed-in user
• Connecting to systems of record (CRM, ticketing, ERP) without bypassing their permissions
• Meeting users where they work: Slack and Microsoft Teams

Lab · 60 min

• Build a remote MCP server over a mock CRM and ticketing system, protected with OAuth
• Pass the user's identity through so every tool call respects that user's permissions
• Trigger the agent from a webhook when a new ticket is created
• Deliver answers and approval requests in Slack or Microsoft Teams

Homework · 1 hour

Connect a second client system to the MCP server and test permissions for three different user roles.

Theory · 30 min

• Building production agents with agent SDKs (Claude Agent SDK, OpenAI Agents SDK)
• Agent skills, subagents, permission controls and hooks
• Sandboxed code execution for data analysis tasks
• Computer-use and browser agents for legacy applications that have no API

Lab · 60 min

• Build an agent with the Claude Agent SDK that uses the Day 8 MCP tools
• Package the client's procedures as agent skills and delegate research to a subagent
• Add permission hooks that block risky actions and log every tool call
• Use a browser agent (Playwright MCP) to complete a task in a legacy web app that has no API

Homework · 1 hour

Write two more agent skills for the client's procedures and test them with the agent.

Theory · 30 min

• Automating multi-step business processes that run for hours or days
• Durable execution with workflow engines (Temporal or Prefect): state, retries and idempotency
• Human approval steps, escalation rules and SLA tracking
• Event-driven triggers and running many workflows in parallel

Lab · 60 min

• Model the client process (for example a claim or KYC review) as a durable workflow
• Use the Day 6 extractor, Day 7 data agent and Day 9 agent as workflow steps
• Add retries, idempotent actions and a human approval step for high-risk decisions
• Stop the worker mid-run and show the workflow resumes without duplicate actions

Homework · 1 hour

Add SLA breach escalation to the workflow and a monitoring view of running workflows.

Theory · 30 min

• When prompting is not enough: accuracy, latency and cost targets at client volumes
• Generating synthetic training data from client documents and expert examples
• Distilling a large model into a smaller, cheaper one; managed fine-tuning on cloud platforms
• Choosing between prompt caching, model routing, batching and distillation using unit economics

Lab · 60 min

• Generate a synthetic training set for the client task with a large model and filter it with the Day 4 judge
• Fine-tune a small model using managed fine-tuning or LoRA
• Compare the large model, the tuned small model and a routed combination on quality, latency and cost per 1,000 cases
• Recommend the option that meets the client's targets, backed by the numbers

Homework · 1 hour

Run a second distillation experiment with a different small model or more data, and update the recommendation.

Theory · 30 min

• Production readiness and regulated-industry evidence: model risk documentation, audit trails and data residency
• Rollout strategies: shadow mode, canary releases and feature flags
• Model version upgrades: regression testing, prompt migration and rollback
• Incident response with clients: triage from traces, status updates and post-incident reviews

Lab · 60 min

• Run the pilot in shadow mode on recorded traffic and compare it with the current process
• Upgrade to a newer model version, run the Day 4 evaluation as a regression test and fix prompt regressions
• Live incident drill: the trainer breaks the system; diagnose it from traces, fix it and send client status updates
• Write a post-incident review and an audit evidence pack for a regulated client

Homework · 1 hour

Write an incident runbook for the three most likely failures and a model upgrade checklist.

Theory · 30 min

• Why AI solutions stall after launch: trust, habits and workflow change
• Measuring value (usage, time saved, quality, cost) and reporting it to executives
• Technical storytelling and demos for mixed business and technical audiences
• Handling objections about accuracy, cost, security and impact on jobs

Lab · 60 min

• Build a value dashboard from pilot logs: usage, time saved, quality and cost
• Write a one-page executive update with a clear recommendation
• Deliver a 5-minute demo to a mixed panel
• Role-play five common client objections

Homework · 1 hour

Prepare answers to ten likely executive questions about the solution's risks, cost and value.

Theory · 30 min

• Designing for handover: runbooks, ADRs, operations guides and knowledge transfer
• Turning engagement work into reusable assets: agent skills, plugins, MCP servers and reference architectures
• Giving structured feedback from the field to product and engineering teams
• Identifying the client's next high-value use case

Lab · 60 min

• Use Claude Code to draft the runbook and operations guide from the repository, then review them
• Run a 10-minute knowledge-transfer session for another team acting as the client's engineers
• Package one component as a reusable agent skill or MCP server with documentation
• Write a product feedback note and a proposal for the client's next use case

Homework · 1 hour

Complete the handover pack and publish the reusable asset in the team's shared repository.

Theory · 30 min

• What the panel assesses: business value, technical quality, production readiness and handover
• Habits of effective FDEs: ownership, speed and judgement
• The first 90 days on a client site
• FDE career paths

Lab · 60 min

• Each team gives an 8-minute showcase: problem, live demo, evaluation results, architecture, production plan and value delivered
• Answer 3 minutes of questions from a panel playing business and technical stakeholders
• Receive scored feedback on technical quality, delivery and communication
• Write a personal FDE development plan

Homework · 1 hour

Write an engagement retrospective and a personal 90-day plan for your first FDE client assignment.