The Microsoft stack end to end: stand up Foundry, ground it permission-aware with Foundry IQ and Azure AI Search, design with the patterns, then evaluate, ship secure MCP tools and a production-ready agent frontend.
The Claude stack end to end: choose your runtime, from Messages API and Agent SDK to Managed Agents, ground it with pgvector and hybrid search, design with the patterns, then evaluate, ship secure MCP tools and a production-ready agent frontend.
Building agents low-code on Microsoft 365: from a first agent through knowledge, actions, MCP and flows to LLM-judged evaluation, analytics, ALM and governance.
Start at the user interface, tune Claude Code into an instrument, put reviews on every diff, and finish with a spec-driven harness with validation and feedback gates, the way we build ourselves.
Start at the user interface, tune Copilot into an instrument across IDE, CLI and the app, delegate issues to agents from mission control, put reviews on every pull request, and finish with a spec-driven harness on Spec Kit, Actions and Agentic Workflows.
Choose, control, redesign: where AI creates value, under which conditions it may act, and how work, roles and accountability change. You bring one process of your own; it travels through all three days.
A light but workable governance function: make AI use visible, controllable and responsibly scalable through register and triage, controls and agent authority, vendors and data flows, and operating model and literacy, without creating a paper tiger.
Use Microsoft Copilot effectively, critically and safely, then delegate bounded work to Copilot Cowork without losing control of data, actions and quality. Two spread days; between them you collect one recurring task from your own role.
Use Claude effectively, critically and safely for knowledge work, then delegate bounded work to Claude Cowork with clear boundaries around files, connectors, actions and quality. Two spread days; between them you collect one recurring task from your own role.
Translate a business problem into a defensible end-to-end AI architecture: master the building blocks first, from rules and optimization to RAG and agents, then decide, combine and design to production. One running case defended before a review board, vendor-neutral throughout.
Design, build and operate production data products in Microsoft Fabric: OneLake, Lakehouse, Warehouse, Data Factory, Delta Lake and Real-Time Intelligence, from architecture and ingestion to controlled production operation. Loading one source into bronze is an early lab, not the end result.
Design, build and operate governed lakehouse data products with Databricks, Delta Lake, Unity Catalog and the Lakeflow platform: managed ingestion, CDC, batch and streaming pipelines, orchestration, governance and cost monitoring. Taught with current product names and patterns, not the curriculum of several years ago.
Develop reliable predictive and forecasting models, from raw data to validated, explainable and governed model assets. Baselines first, leakage discipline throughout, and current tools without tying the competence to one library.
Choose, deploy, secure and operate a practical AI platform: one managed provider and one private model behind a single governed gateway, with keys, budgets, fallbacks, observability and a runbook included. Private hosting is one option, not the default answer.
The mathematical language of modern AI in four courses: linear algebra, calculus and automatic differentiation, probability and statistics, and information theory, each taught through the models they explain, from attention and backpropagation to sampling and loss design.
Neural networks built, trained and diagnosed from first principles: backpropagation by hand before frameworks take over, optimization and training dynamics as one coherent system, and architectures compared on the structure they model. One experiment discipline runs through the track: baseline, controlled change, measurement, ablation, conclusion.
Language models from tokenization and the transformer block to frontier scale: efficient attention and state-space memory, sparse Mixture-of-Experts, pretraining data and optimization, post-training and reasoning, closing with a research lab that reconstructs and partly reproduces a current frontier architecture. The current capstone edition is The Road to K3.
Stand up Microsoft Foundry properly and deploy a bounded agent: models, Agent Service, toolboxes, identity, tracing and evaluations, in the portal or from the SDK.
Grounded agents on the Microsoft stack, built twice: a direct Azure AI Search index tool against Foundry IQ knowledge bases, permission-aware, cited and measured.
The Claude stack is not one agent builder: Messages API with your own loop, the Agent SDK, or Managed Agents. Build a bounded agent and make the runtime choice deliberately.
Permission-aware RAG on the open stack: Postgres full-text plus pgvector, fused with RRF and a reranker, Row Level Security end to end, and the judgment to know when RAG is the wrong tool.
Build, test and publish your first Copilot Studio agent in a day: an Agent Brief, instructions, topics, knowledge, all live in Teams and Microsoft 365 Copilot before you leave.
Where Copilot Studio agents earn their keep: permission-aware knowledge, actions through connectors and MCP, deterministic agent flows, and event triggers kept safely in draft-and-approve.
From demo to managed production: LLM-judged test sets with Agent Evaluation, the Copilot Agent Kit, transcripts and Application Insights, solutions and ALM, DLP, and a release decision you can defend.
Every reliable agent is built from the same twenty-one patterns. This course walks Antonio Gulli's Agentic Design Patterns end to end and applies them to a workflow of your own.
The flagship systems, CI, and online-eval course: instrument with tracing, curate datasets, score with calibrated judges, wire a CI eval gate, and monitor live traffic. Course-local eval elsewhere stays narrowly scoped; this owns the production loop.
Build and deploy a secure stateless remote MCP server on the 2026 spec, hardened, least-privilege, and shipped as a Cloudflare Worker, so any AI client can call your tools.
Build a production agent experience on AG-UI with CopilotKit: streaming, generative UI, shared state, and human-in-the-loop on high-impact actions.
Start at the user interface: design the flow in Claude Design, make every state explicit in a handover contract, then sync it natively into Claude Code for controlled implementation.
Claude Code as a tuned instrument instead of a chat box: CLAUDE.md and rules, skills and plugins, hooks, subagents, MCP, permissions and sandboxing, worktrees, /goal and /loop, headless and routines. Every object, put to work.
Reviews that scale with the code you now produce: /code-review on every diff, managed review on every pull request, /security-review on demand, standards that get enforced, and a sharp line around what stays human.
The capstone: a spec-driven harness where a feature moves from contract and plan to implementation, independent validation and human feedback gates, the way we build software ourselves.
Start at the user interface: design the flow in Claude Design, capture it in a versionable handover contract in the repository, and let GitHub Copilot implement it. Controlled, verifiable, reviewable.
GitHub Copilot as a tuned instrument across IDE, CLI, GitHub.com and the app: instructions, AGENTS.md, prompt files, skills, custom agents, hooks, MCP, Spaces and Memory. Every object, put to work.
Stop typing along, start delegating: parallel agent sessions started from issues, prompts or the CLI, steered from the Agents page and the Copilot app, with automations and governance from prompt to pull request.
Reviews that scale with the code you now produce: Copilot on every pull request, standards in instructions that get read, Fix with Copilot on findings, and the deterministic gates that actually block a merge: CodeQL, Code Quality, rulesets.
The capstone: a spec-driven delivery harness on GitHub, with Spec Kit from constitution to tasks, coding agents implementing, deterministic Actions and Agentic Workflows correctly separated, and rulesets and human feedback gates on the way to merge.
Most AI initiatives never reach measurable value. Pick the ones that will: the right form of AI per problem, a ranked opportunity portfolio, and a Pilot Charter with stop-or-scale criteria fixed up front.
The AI Act is only part of the risk picture. Build governance as a business process: know what AI you run, your role as provider or deployer, and the controls, owners and evidence that make your approach defensible.
Not how much work agents can take over, but what must stay human, and what can be delegated under which conditions. Author, Editor, Director and Orchestrator as a diagnostic, applied to one process of your own.
Not a tour of the buttons: choose the right Copilot work mode per task, turn prompts into proper work briefings, work within existing access rights, and check what comes back, critically and safely.
Chat for an answer, Cowork for work: know when to delegate, brief with milestones and a final human review, automate low-risk tasks draft-and-approve, and control what runs in your name.
Choose the right Claude work mode per task, whether Chat, research, Projects, Artifacts, connectors or Cowork, brief it properly, build context that lasts, and check output critically before it leaves your hands.
Know when to delegate to Cowork, brief with boundaries around files, connectors and actions, schedule recurring work safely, and turn results into work products with clear sharing rules.
Find all the AI in your organization, formal and informal, and move every application through one flow: discover, register, triage, assess, decide, deploy, monitor, change, respond, retire.
May this AI service be used for this data? Draw the full data flow, judge providers and deployment models, and decide with conditions instead of a flat yes or no.
Governance as a service: an operating model with roles and decision rights, role-based literacy, and adoption that gets measured, because blocking alone breeds shadow AI.
No buzzword catalogue: for every technology you learn the input and output, the data it needs, how quality is measured, its typical failures, and when something simpler is better.
RAG is not a button: from ingestion and chunking to reranking, context assembly and citations. Build a minimal vendor-neutral pipeline, measure it, and defend whether RAG is even needed.
Not every problem is an LLM problem. Decompose the business problem, compare solution categories on their merits, and record the decisions as ADRs, before a product choice dictates the problem definition.
Bring every choice together in a production-ready architecture, covering security, reliability, observability, scale, cost and governance, and defend it before a review board.
Most small teams don't need a GPU cluster. They need one controlled access layer. Put a managed provider and a private model behind a single gateway, with keys, budgets, fallbacks and a runbook.
One platform does not mean zero architecture. Decide between Lakehouse, Warehouse and Eventhouse, structure OneLake and your workspaces, and engineer Delta tables that hold up under real change.
Getting one file into bronze is a demo. This course builds the ingestion framework around it: the right movement pattern per source, incremental loads and CDC, and pipelines that survive reruns, backfills and bad records.
Silver is not just cleaned bronze. Build incremental, tested transformations with merge, SCD Type 2 and materialized lake views, and publish gold data products consumers can actually rely on.
A data product that only runs on the happy path is a liability. Ship it through Git and deployment pipelines, lock down access, wire up monitoring, add a real-time flow, then break it on purpose and recover.
The Databricks you learned a few years ago is not the platform you will run today. Build the foundation on current patterns: Unity Catalog for governance, Delta engineered with liquid clustering and predictive optimisation, and a deliberate position on Iceberg.
Ingestion is where lakehouse projects quietly fail: schema drift, duplicates, late events and half-loaded tables. Build it on the current services instead: Lakeflow Connect for managed sources, Auto Loader for cloud files, and AUTO CDC in place of legacy APPLY CHANGES.
Delta Live Tables is not the name anymore, and APPLY CHANGES is not the API. Build declarative batch and streaming data products with Lakeflow pipelines: streaming tables, materialized views and expectations, with orchestration handled by the platform.
A pipeline that runs in a notebook is not a production service. Ship it through Declarative Automation Bundles, orchestrate it with Lakeflow Jobs, watch cost and health in system tables, and prove you can recover when it breaks.
Data science is not a sequence of calls to fit() and predict(). Before any model, you need a sound question, honest splits and a baseline worth beating: that discipline starts here.
Linear and logistic regression are not warm-up exercises: they are the transparent benchmark every ensemble must beat. Learn what these models optimise and what cross-entropy actually means.
On tabular data, boosted trees are still the models to beat. Train forests, XGBoost and LightGBM properly, then judge them on calibration, latency and complexity, not one score.
A single accuracy number is how optimistic models reach production. Learn which split is valid when, which metric answers which question, and how calibration and thresholds turn probabilities into decisions.
Unlabeled results are the easiest to oversell. Engineer features with leakage discipline, cluster and reduce dimensions with restraint, and detect anomalies without calling every rare case wrong.
A forecast validated with a shuffled split is fiction. Model trend, seasonality and stationarity, backtest with rolling origins, and make foundation models earn their place against a seasonal naive baseline.
A model nobody can explain, trace or monitor is not finished. Turn a validated model into a governed asset: SHAP explanations, subgroup assessment, a registered pipeline and a defensible go or no-go.
Attention is a matrix operation, embeddings are geometry and low-rank adaptation is a statement about rank. This course builds the linear algebra that lets you derive and check those concepts instead of following them as recipes.
Backpropagation is not a framework function, it is the chain rule organised over a graph. Build your own autodiff engine and you will never read loss.backward() the same way again.
A benchmark difference means nothing until you know the variance across seeds. This course builds the probabilistic and statistical machinery to state, estimate and doubt results properly.
Cross-entropy is not an arbitrary loss and perplexity is not a magic number: both fall out of a handful of information-theoretic definitions. This course derives them and shows where the intuition breaks.
PyTorch will happily train a network you do not understand. Build the perceptron, the multilayer network and backpropagation yourself, verify every gradient, and only then let autograd take over.
An optimizer choice is a claim, not a preference. Compare SGD, momentum, AdamW and Muon under fair baselines, break and repair gradient flow, and report results over multiple seeds.
Every architecture is an inductive bias made concrete. Build CNNs, residual blocks, recurrent networks and autoencoders, probe what they learn, and see precisely why recurrence gave way to attention.
Every frontier model still runs on the operations of one 2017 paper. Build a transformer from first principles: derive attention, keep every tensor shape explicit, train a small language model and measure exactly what it costs.
A transformer only trains at depth because its residual and normalization design allows it. Follow information and gradients through deep networks, and put standard residuals, Pre-LN, Post-LN and Attention Residuals to a controlled test.
Full attention pays a quadratic price for exact recall, and long context makes the bill visible. Compare linear attention, state-space models, MLA and the KDA hybrid, and measure which efficiency claims survive your own benchmarks.
A trillion-parameter model that activates a fraction of itself per token is a routing problem as much as a modeling one. Build a sparse Mixture-of-Experts, break its load balancing on purpose, and trace the sparse scaling path from Switch Transformers to DeepSeek and Kimi K3.
A base model is decided before the first gradient step: tokenizer, data mixture, compute budget and optimizer set the ceiling. Design the full pretraining chain and train a compact base model you can account for, token by token and FLOP by FLOP.
A base model predicts tokens; instruction following, reasoning, vision and tool use are built in post-training. Follow the path from SFT through preference learning to reinforcement learning, with the Kimi K-series as the running research case.
Frontier reports make claims; research method decides which ones hold. Reconstruct the paper dependency graph behind Kimi K3, reproduce one component at reduced scale and defend your conclusion before a research review panel.