AI Engineer
From GenAI foundations to secure, production-ready agents in 20 days.
A beginner-to-advanced pathway covering LLMs, prompt engineering, RAG, evaluation, multimodal AI, fine-tuning, agents, MCP, LLMOps, security and governance — finished with a team capstone and demo day.
- Duration
- 20 days
- Live sessions
- 30 hours
- Total learning
- 90 hours
- Capstone
- 40 hours
- Format
- Live, online, lab-first
Built for
Junior software developers with some exposure to generative AI. No prior AI engineering experience is assumed.
Entry requirements
Python, plus the subscriptions below.
By the end you can
- Explain how generative AI, LLMs and agentic AI work and where they fit in the wider AI landscape
- Set up professional GenAI projects and develop productively and safely with Claude Code
- Build GenAI applications using prompt engineering, structured outputs and hosted or open-source models
- Build and improve RAG systems, and test them end to end with Playwright and automated evaluations
- Work with multimodal models and fine-tune small open models
- Build AI agents, tool integrations, MCP servers and multi-agent systems with human oversight
- Deploy, monitor, optimise and secure GenAI applications, and govern them responsibly
How every session runs
Concepts with real examples and a short live demonstration
Hands-on build that applies the day’s concepts
Practical, job-relevant task that extends the lab
2.5 hours of learning a day: one 90-minute live session plus homework. Each stage also includes a 40-hour team capstone completed outside the live sessions.
Day by day
Open any day to see the theory, the lab, the homework and the outcome.
GenAI Foundations and Developer Setup
Day 1Generative AI Foundations and How LLMs WorkLab: GenAI versus Traditional ML, and a Look Inside an LLM
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 — GenAI versus Traditional ML, and a Look Inside an LLM
- 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 · 60 min
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.
Outcome Students can explain what GenAI and Agentic AI are, how they differ from traditional ML and DL, and how LLMs generate their responses.
Day 2Developer Setup with Claude Code and Best PracticesLab: Set Up the Course Project with Claude Code
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 — Set Up the Course Project with Claude Code
- 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 · 60 min
Use Claude Code to add logging and unit tests to the Day 2 helper module, and add two new project rules to CLAUDE.md.
Outcome Students can set up a professional GenAI development environment and use Claude Code productively and safely.
Day 3The LLM Landscape: Models, APIs and Open-SourceLab: Build a Multi-Model Chatbot
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 — Build a Multi-Model Chatbot
- 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 · 60 min
Add a third model through OpenRouter to the chatbot and record quality, latency and cost on ten new prompts.
Outcome Students can call hosted and local LLMs from code and choose a suitable model for a given task.
Day 4Prompt Engineering: From Basics to Advanced TechniquesLab: Prompt Engineering Workshop
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 — Prompt Engineering Workshop
- 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 · 60 min
Build a personal library of five reusable, tested prompts for tasks from your own work.
Outcome Students can write, improve and test prompts that give reliable results for common business tasks.
Day 5Structured Outputs and Your First GenAI ApplicationLab: Smart Document Extractor App
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 — Smart Document Extractor App
- 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 · 60 min
Extend the document extractor to a second document type and add three unit tests for validation failures.
Outcome Students can build a simple GenAI web app that turns unstructured text into validated structured data.
Knowledge, Quality and Customisation
Day 6Embeddings, Vector Databases and RAG FundamentalsLab: Chat with Your Documents
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 — Chat with Your Documents
- 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 · 60 min
Index 20 documents of your choice and write 10 test questions with expected answers.
Outcome Students can explain how embeddings power semantic search and build a RAG chatbot that answers from private documents with citations.
Day 7Advanced RAG TechniquesLab: Upgrade the RAG Chatbot
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 — Upgrade the RAG Chatbot
- 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 · 60 min
Try one advanced RAG technique not used in the lab and record its effect on your test set.
Outcome Students can diagnose weak RAG results and apply advanced techniques to measurably improve answer quality.
Day 8GenAI Testing and Evaluation with PlaywrightLab: Build a GenAI Test Suite
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 GenAI Test Suite
- 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 · 60 min
Add five Playwright tests for edge cases (empty input, very long question, unanswerable question) and run them in CI.
Outcome Students can test GenAI applications end to end with Playwright and automated evaluations, and catch quality regressions before users do.
Day 9Multimodal Generative AILab: Multimodal Assistant
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 — Multimodal Assistant
- 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 · 60 min
Build an image-to-data extractor for a document type of your choice, such as product labels or restaurant menus.
Outcome Students can build applications that understand and generate text, images and audio.
Day 10Fine-Tuning and Customising ModelsLab: Fine-Tune a Small Open Model
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 — Fine-Tune a Small Open Model
- 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 · 60 min
Form your capstone team and submit a one-page proposal: problem, users, data, architecture and success criteria.
Outcome Students can decide when fine-tuning is worthwhile and fine-tune a small open model with LoRA.
Agents, Integration and LLMOps
Day 11Tool Calling: Letting LLMs Take ActionLab: Build a Tool-Using Assistant
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 — Build a Tool-Using Assistant
- 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 · 60 min
Add two tools to the assistant, including one that changes data behind a confirmation step, with tests.
Outcome Students can give an LLM safe access to tools and data through function calling.
Day 12AI Agents: Planning, Memory and FrameworksLab: Build a Research Agent
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 Research Agent
- 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 · 60 min
Give the research agent a new tool, test it on five new questions and document where it fails.
Outcome Students can build an AI agent that plans, uses tools and remembers context, and can explain its limits.
Day 13Model Context Protocol (MCP) and Enterprise IntegrationLab: Build an MCP Server
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
- 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 · 60 min
Add a second resource and a prompt template to the MCP server, and connect it to Claude Code.
Outcome Students can build an MCP server that securely connects AI assistants and agents to company data.
Day 14Multi-Agent Systems and Human-in-the-LoopLab: Multi-Agent Content Team
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 — Multi-Agent Content Team
- 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 · 60 min
Add a fact-checker agent to the content team and measure its effect on quality and cost.
Outcome Students can build a multi-agent system with human oversight and judge when it is worth the extra complexity.
Day 15LLMOps: Deploying and Monitoring GenAI ApplicationsLab: Deploy and Monitor the RAG Chatbot
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 — Deploy and Monitor the RAG Chatbot
- 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 · 60 min
Add an alert rule to the monitoring dashboard and write a one-page runbook for the chatbot.
Outcome Students can deploy a GenAI application as a service and monitor how it behaves in production.
Performance, Security, Governance and Capstone
Day 16Performance, Cost and Serving Open ModelsLab: Make It Faster and Cheaper
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 — Make It Faster and Cheaper
- 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 · 60 min
Calculate the chatbot's monthly cost at 10,000 queries a day, before and after your optimisations.
Outcome Students can reduce the cost and latency of GenAI applications without sacrificing quality.
Day 17Security and Guardrails for GenAILab: Red-Team and Protect Your App
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 — Red-Team and Protect Your App
- 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 · 60 min
Run five attacks from the OWASP Top 10 for LLM Applications against your capstone and add defences for any that succeed.
Outcome Students can identify GenAI security risks and add guardrails that measurably reduce them.
Day 18AI Governance and Responsible AILab: Governance Pack for a GenAI Application
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 — Governance Pack for a GenAI Application
- 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 · 60 min
Complete an EU AI Act risk classification and a risk register for your capstone project.
Outcome Students can apply responsible AI principles and major governance frameworks to assess and document a GenAI application.
Day 19Capstone Review and Production ReadinessLab: Capstone Review Sprint (teams of 3–4)
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 — Capstone Review Sprint (teams of 3–4)
- 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 · 60 min
Fix the remaining issues from the peer review and finalise the capstone README.
Outcome Students can review a GenAI solution against production-readiness criteria and close the most important gaps before release.
Day 20Capstone Demo and the Future of GenAILab: Demo Day
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 — Demo Day
- 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 · 60 min
Finalise your 90-day learning plan and write a short portfolio case study of your capstone project.
Outcome Students can present a complete GenAI solution, explain their design choices and plan their next steps in GenAI.
A 40-hour team project, presented on demo day
Teams of 3–4 build one complete GenAI solution outside the live sessions: a document intelligence assistant, customer support agent, multi-agent research assistant or multimodal content generator. Assessed on the working solution, architecture, test and evaluation results, security and governance, and the Day 20 demo.
- M1Proposal and design
Choose the project, define users and success criteria, design the architecture and evaluation plan
One-page proposal and architecture diagram · Days 10–11 · 4 h - M2Core GenAI flow
Build data ingestion, the RAG or model pipeline, structured outputs and the user interface
Working core flow in the team repository · Days 11–13 · 12 h - M3Agents and integration
Add tools, agents and an MCP integration, with human approval for risky actions
Agent features with tests · Days 13–15 · 8 h - M4Deployment and optimisation
Deploy with Docker and FastAPI, add tracing and monitoring, and reduce cost and latency
Deployed service and monitoring dashboard · Days 15–16 · 6 h - M5Testing, security and governance
Complete Playwright tests and automated evaluations, add guardrails, and write the model card and risk register
Test results, guardrails and governance documents · Days 17–18 · 8 h - M6Review fixes and demo preparation
Fix peer-review findings, finish the README and rehearse the demo
Final repository and demo · Days 19–20 · 2 h
Tools you will use
Join a cohort
Live, instructor-led cohorts with labs every session, practical homework and a team capstone you can show employers.
Enquire about the next cohortRun it for your team
A private cohort for your engineers, scheduled around your teams, with the capstone built on a use case from your own organisation.
Talk to us about a team cohort