The curriculum

Seven modules. Forty-eight lessons. Zero prerequisites.

The path below is designed to be walked in order. Each module ends with a project that forces you to use everything that came before it. Lessons marked live are published; the rest are being written.

Start with a live lesson Open the playground

Track A · Foundation

For beginners

Read the Core lessons in each module and do every lab. Skip anything tagged deep on the first pass — you can always come back. Expect 45–60 hours end to end.

Track B · Practitioner

For working professionals

Read everything, including the deep lessons, and implement each module's project from scratch in NumPy before reaching for a framework. Expect 80–100 hours end to end.

1

Mathematical Foundations

The four pieces of maths that every AI idea is built from. Taught visually first — you will not see a proof before you have seen a picture.

Vectors, and what "direction in meaning-space" really means Core
Matrices as transformations, not tables of numbers Core
Dot products, similarity, and why cosine shows up everywhere Core
Derivatives: measuring how output responds to input Core
Partial derivatives and the gradient vector Core
Probability, distributions, and expected value Core
Bayes' rule and updating beliefs with evidence Deep
Information, entropy, and cross-entropy Deep
Project: build a document-similarity search with nothing but dot products Lab

2

How Machines Learn

Before any neural network: what learning from data actually means, and the optimisation loop that sits underneath every model you will ever train.

Supervised, unsupervised, and reinforcement learning Core
Linear regression: the simplest learning machine Core
Loss functions — how a model knows it is wrong Core
Gradient descent, step by step live
Learning rate, momentum, and the Adam optimiser Core
Logistic regression and classification boundaries Core
Overfitting, underfitting, and the bias–variance trade-off Core
Train/validation/test splits and cross-validation Core
Regularisation: L1, L2, and why they behave differently Deep
Project: train a house-price predictor from scratch in NumPy Lab

3

Neural Networks

From a single artificial neuron to a deep network that trains itself. This is the module where the black box becomes transparent.

What a neuron actually computes live
Why we need activation functions at all Core
Stacking layers: the universal approximation idea Core
The forward pass, drawn one matrix at a time Core
Backpropagation: the chain rule doing bookkeeping Core
Weight initialisation and why it decides whether you train at all Deep
Batch normalisation, dropout, and other stabilisers Deep
Vanishing and exploding gradients Deep
Project: handwritten digit recogniser, no framework allowed Lab

4

Seeing and Sequencing

The two specialised architectures that dominated the 2010s, and which still power a large share of deployed AI today.

Convolution as pattern matching with a sliding window Core
Filters, feature maps, pooling, and stride Core
What a trained CNN's layers actually learn to see Core
Recurrent networks and the idea of hidden state Core
LSTMs and GRUs: gates that decide what to remember Deep
Embeddings — turning words into vectors Core
Transfer learning and fine-tuning a pretrained model Core
Project: classify images with a fine-tuned CNN Lab

5

Transformers and Large Language Models

The architecture behind ChatGPT, Claude and Gemini — assembled piece by piece until nothing about it is mysterious.

How an LLM reads your sentence live
Attention: letting every word look at every other word Core
Queries, keys and values, worked through by hand Core
Multi-head attention and why one head is not enough Core
Positional encoding — teaching a bag of words about order Core
The full transformer block, assembled Core
Pretraining, next-token prediction, and scaling laws Core
Instruction tuning and RLHF: from text predictor to assistant Core
Sampling: temperature, top-k, top-p and what they trade off Core
Context windows, KV caching, and inference cost Deep
Why models hallucinate, mechanically Deep
Project: build a miniature GPT that writes Sanskrit verse Lab

6

Building With AI

The engineering layer: how real applications are assembled on top of models, and the failure modes that only appear in production.

Prompting as programming: structure, examples, constraints Core
Embeddings and vector databases Core
Retrieval-augmented generation, end to end Core
Function calling and tool use Core
Agents: planning, memory, and where they break Core
Evaluating an AI system when there is no single right answer Deep
Fine-tuning vs. RAG vs. prompting — choosing correctly Deep
Cost, latency, and quantisation Deep
Project: a question-answering assistant over your own documents Lab

7

Consequences

Not an afterthought module. If you are going to build these systems, you need to understand what they do when they meet the real world.

Where bias enters a model, and the four places to look Core
Privacy, training data, and memorisation Core
Interpretability: what we can and cannot see inside a model Core
AI safety — the near-term and long-term arguments, fairly stated Core
Regulation: the EU AI Act, India's DPDP Act, and what they require of you Core
The economics of automation, without the hype or the doom Core
Project: audit a model you have built for bias and document it Lab

Every lab, in one place

Labs run entirely in your browser. Nothing is uploaded anywhere.

Perceptron boundary

Drag two weights and a bias; watch the dividing line move across the data.

Descent simulator

Set a learning rate and starting point, then watch the model converge — or explode.

Live tokenizer

Type any sentence and see exactly how a model splits it into tokens.

Activation explorer

Compare sigmoid, tanh, ReLU and GELU on one set of axes.

Python playground

Real Python with NumPy, running in your tab. Four starter exercises included.

More coming

Attention visualiser, convolution filter sandbox, and an embedding-space explorer are next.