One AI course from Grade 1 to Grade 12, mapped to the world's AI curricula

Children see a machine rank its guesses, read how sure it is, and learn that when it says "maybe", a person should check.

Children compare their own memory with a phone's, see a machine keep only what it was taught, and what happens when it forgets or remembers too much.

Children play the same game robot on easy and hard settings and watch an opponent learn their repeated trick.

Learners ask a machine for its reason, tell a good explanation from a poor one, and know to be careful when it cannot explain.

Learners follow the money behind a free game, see ads chosen from what they looked at, and learn that AI costs money to run.

Learners spot autoplay and features built not to stop, write an honest report on their own use, and decide when it ends.

Learners see why a chatbot feels like a friend but is not one, notice it praising every idea, and keep talking to real people.

Learners build a rule-based chatbot in Python with input cleaning, keyword voting, context memory, fallbacks and A/B testing.

Learners practise SIFT, STOP and three-question checks across chapters, tracing a viral statistic back to its source.

Learners compute queries, keys, values, scaled scores, multiple heads and position signals by hand, then compare encoder-only and decoder-only designs.

Learners step through tokens, next-word odds and sampling settings (temperature, top-k, top-p), and see how each changes a chatbot's voice.

Learners work through the two Word2Vec training methods, count training pairs from a context window, and see why similar words end up close together.

Learners write the sliding-filter edge finder and pooling step in Python, then follow how stacked layers grow from edges to objects.

Learners work through bounding-box overlap, removing duplicate boxes, pixel-level masks, and comparing face embeddings to decide if two photos match.

Learners compute with Bayes' rule, read network probability tables, run the forward step of a hidden Markov model, and solve puzzles with constraint search.

Learners score moves with best-worst-case reasoning, then see why adding randomness and Monte Carlo trials protects a strategy from being predicted.

Learners clean text, build word-count vectors, calculate word-importance scores, and code a Naive Bayes text classifier, including a spam detector.

Learners code decision stumps, bagging, boosting and a widest-street support vector machine, then bend the boundary with a kernel.

Learners code PCA, t-SNE, density-based and hierarchical clustering, a small autoencoder, and masked-audio self-supervised learning on unlabelled data.

Learners compare SGD, momentum, RMSprop and Adam, and see how batch normalisation, dropout, early stopping and weight setup keep deep networks training.

Learners read TensorBoard curves, save and restore checkpoints, and work out why a GPU trains faster than a CPU.

Learners rotate test folds, catch test data leaking into training, and shrink overfit models with Ridge and Lasso penalties.

Learners split a series into trend and season, build ARIMA-style forecasts with differencing, and compare them with LSTM networks.

Learners update a Q-table by hand, follow deep Q-networks with replay, policy gradients and actor-critic, and design reward functions.

Learners build recommenders, work through collaborative filtering with a taste-twin example, and tune the result in a simulator.

Learners run one denoising step by hand, compare noise schedules and samplers, and code a one-dimensional diffusion in Python.

Learners follow the generator-versus-detector game, compute style with Gram matrices, and explore why GAN training goes wrong.

Learners follow text-to-speech from phonemes and rhythm to neural voices, trace the Whisper speech pipeline, and weigh voice cloning.

Learners compute contrastive image-text pairs, zero-shot labels, and choose how to fuse sight, sound and text in one model.

Learners build a retrieval pipeline with chunking and embeddings, choose between prompting, retrieval and fine-tuning, and count the weights a LoRA adapter changes.

Learners trace the think-act-observe loop, design an agent with tools and memory, and set guardrails for when it fails.

Learners follow the three steps of human-feedback training, see how a reward model is built, and why raw pretraining alone is not enough.

Learners read ROC curves and AUC, pick decision thresholds, and study residual plots, MAE and RMSE to see where a model's misses cluster.

Learners read famous benchmarks critically, see how leaderboards reward narrow tuning, and practise fold-based validation used in data science competitions.

Learners read papers in three passes, question weak baselines, read ablation tables and p-values, and learn why results fail to reproduce.

Learners practise a robot in a virtual world, measure the gap to reality, and choose what closes it before using a real machine.

Learners prune and quantise a model by hand, read what a quantiser does, and decide what fits on a small chip or phone.

Learners study prompt injection, poisoned training data, model theft and adversarial examples, and think like an attacker before defending.

Learners study how a model can look correct yet pursue the wrong goal, and compare safety research with capability research.

Learners flip coins to add noise to answers, work out why anonymous data still leaks, and see how privacy-preserving AI works.

Learners calculate selection rates and fairness checks across groups, and see why different fairness measures cannot all be met at once.

Learners shuffle features to measure importance, read explanations for single predictions, and write counterfactuals such as what would have changed a rejection.

Learners run a shift cipher, XOR a byte, and build a tiny public-key RSA key pair to see how secrets are shared safely.

Learners compare data-rich and data-poor languages, writing scripts and transliteration, and see how one model can transfer between related languages.

Learners size a market, work out unit economics and pricing, read funding stages and dilution, and plan a first release.

Learners test whether a project claim is honest, say what is covered and what is not, and state their own model's weakest case first.

Learners write impact-based resume bullets, build STAR answers, practise coding-pattern problems, and sketch a machine learning system design.

Learners serve a model through an API, read a Dockerfile, plan scaling and cloud cost, and watch for data drift once it is live.

Learners start threads, protect shared data with locks, run async tasks, and measure code with timers and a profiler.

Learners write decorators, generators, context managers and typed data models, and test and document code the way professional teams do.