LLM Classroom: large language model foundations
From the Transformer architecture, tokenisation, parameters and self-attention through the three training stages, RAG, quantisation, local deployment, AI guardrails and future trends. Everything explained with everyday analogies — no maths or coding background required.
Syllabus
Module 1: How a model works inside
Transformers, tokenisation, parameters, embeddings and self-attention in plain language
- 01Why teachers need to understand LLMs, not just use themStarting from a real staffroom question, this lesson explains why teachers benefit from understanding how large language models work, and maps out the seven modules ahead. 10 min· Level: Foundation
- 02The Transformer architecture in plain languageUsing a stack of worksheets passed down a staffroom as the analogy, this lesson explains how a Transformer processes a sentence layer by layer and writes one word at a time. 12 min· Level: Foundation
- 03Tokenisation, and why Chinese costs more than EnglishUsing the analogy of a Lego brick box, this lesson explains what a token is, why Chinese uses more tokens than English, and what that means for cost and length control. 12 min· Level: Foundation
- 04What parameters actually store, from 10B to a trillionUsing the brain-cell analogy, this lesson explains what a parameter is, why it stores patterns rather than entries, and why parameter count is a poor basis for procurement. 11 min· Level: Foundation
- 05Embeddings, positional encoding and self-attentionThree classroom analogies, a seating plan, a class number and underlining an exam question, unpack the key components inside a model and their link to a knowledge base. 13 min· Level: Intermediate
Module 2: How a model is made
Pre-training, fine-tuning and alignment — and where hallucination and bias come from
- 06Pre-training, self-supervised learning and data cleaningTwo analogies, a cloze worksheet and a library acquisitions budget, explain how a model teaches itself in the first training stage and why data quality decides everything after. 12 min· Level: Foundation
- 07Fine-tuning, SFT and where instruction-following comes fromUsing the analogy of a student teacher learning from a mentor, this lesson explains how supervised fine-tuning turns a model that merely continues text into a real assistant. 12 min· Level: Intermediate
- 08Alignment with RLHF and DPOUsing the analogy of marking against a rubric rather than a model answer, this lesson explains how alignment training works and why a school still needs guardrails of its own. 13 min· Level: Intermediate
- 09Where hallucination and bias come from, and how to manage themThis lesson takes apart the four structural causes of hallucination and the three sources of bias, then sets out five practical measures a teacher can start using immediately. 14 min· Level: Foundation
- 10Knowledge cutoffs and model versioningWhat a knowledge cutoff is, how to verify one in official documentation, which teaching tasks it affects, and how a panel should manage model versions and prompt template updates. 12 min· Level: Foundation
Module 3: Ecosystem and getting models
Hugging Face, small language models and on-device deployment
- 11Hugging Face, the GitHub of AI, and why teachers can browse it tooA public site where AI models are stored openly. Even without any coding background, a teacher can use it to check who built a model, what licence it carries and what its known limits are. This lesson walks through it using the analogy of a shared global resource cupboard. 10 min· Level: Foundation
- 12Reading a model card, and what GGUF and Safetensors meanThe pile of filenames and documentation on a model page follows a fixed structure. This lesson treats the model card as the nutrition label on a food package and GGUF as a compressed video format, so a teacher or IT coordinator can judge in five minutes whether a model belongs in school. 11 min· Level: Foundation
- 13The rise of small language models, from Phi and Gemma to the 8B classA school does not necessarily need the largest model. This lesson uses the analogy of an experienced primary generalist teacher versus a university professor to explain why a few billion parameters covers most school work, and when a flagship is still worth calling on. 11 min· Level: Intermediate
Module 4: Core application concepts
Prompts, knowledge bases and RAG, chunking, context caching, agents, MCP and frameworks
- 14Prompt engineering in one lesson, or why the same question gets such different answersTwo teachers ask the same thing. One gets a worksheet ready to print, the other gets waffle. The difference is not luck but four specific ingredients. This lesson explains prompt engineering through the analogy of briefing a supply teacher. 12 min· Level: Foundation
- 15The school knowledge base and retrieval-augmented generationA general AI does not know which unit your Primary 4 class reached last term. Retrieval-augmented generation has it consult the school's own documents before answering, like an open-book exam where the teacher hands over only the relevant pages. This lesson explains how, and why it beats trying to train the AI about your school. 13 min· Level: Foundation
- 16Chunking, reranking and lost in the middlePaste a long document into an AI and it often misses the crucial passages in the middle. This lesson explains a real and well-documented effect, and gives teachers four immediate remedies: how to cut documents, why passages should overlap, what reranking does, and putting the most important instruction last. 14 min· Level: Intermediate
- 17Context caching and cost control, or why asking about the same document again is cheaperAsk fourteen questions about one curriculum document and everything from the second question onwards can cost far less. This lesson explains context caching through the analogy of leaving one worksheet on the desk instead of reprinting it, and shows how it also settles the order your prompt should follow. 11 min· Level: Intermediate
- 18From chatbot to AI agent, with tool calling and MCPRather than expecting an AI to remember everything, give it a calculator and a phone. This lesson explains how tool calling lets a model get things done, what separates an agent from a chatbot, and why MCP works like a standard plug socket. 13 min· Level: Intermediate
- 19What LangChain and LlamaIndex actually doThese two names keep appearing in vendor proposals and grant applications. Teachers do not need to code, but it is worth knowing what problem they solve. This lesson compares a framework to a school's standard forms and procedures, and offers four questions for scrutinising any technical proposal. 11 min· Level: Hands-on
Module 5: Local deployment and efficient fine-tuning
LoRA / QLoRA, quantisation, and running models in school with Ollama and LM Studio
- 20Parameter-efficient fine-tuning with LoRA and QLoRA on one GPUStarting from a tracing-paper analogy, this lesson explains how LoRA and QLoRA let a school fine-tune a model that understands its own marking conventions on a single consumer graphics card, and when fine-tuning is the wrong tool. 14 min· Level: Intermediate
- 21Quantisation, from FP16 down to INT8 and INT4Using the analogy of saving a photo as a smaller JPEG, this lesson explains what a school gains in hardware cost and loses in accuracy by quantising a model, and how Edor.ai's on-premises deployment runs INT8 and INT4. 12 min· Level: Intermediate
- 22Running models in school with Ollama and LM StudioStarting from one machine in the IT room, this lesson walks through running a model on the campus network with Ollama and LM Studio, the honest hardware expectations, the traps nobody mentions, and which tasks belong on campus. 14 min· Level: Hands-on
- 23On-device AI, Apple Intelligence and the data-never-leaves advantageStarting from the AI features on a student's iPad, this lesson explains why on-device processing has a structural privacy advantage, where its capability ceiling sits, and how a school applies the same principle at campus scale. 12 min· Level: Foundation
Module 6: Safety, evaluation and hard limits
Guardrails, LLM-as-a-Judge and leaderboards, hallucination and cost, ethics and copyright
- 24AI guardrails with Llama Guard, NeMo Guardrails and enforced JSONUsing the duty teacher at the school gate as an analogy, this lesson unpacks how incoming messages are checked, how outgoing content is reviewed, how formats are locked, and what Edor.ai's four-layer gating actually guards. 14 min· Level: Intermediate
- 25Jailbreaks and prompt injection, and how a school defends against themUsing the analogy of a note hidden inside a piece of homework telling the marker to award full marks, this lesson separates injection from jailbreaking and sets out the defences a school can actually implement. 13 min· Level: Intermediate
- 26Privacy, bias and copyright — a school's AI ethics checklistTurning the three ethical topics that meetings discuss in the abstract into checklists a school can act on, covering what must never be pasted in, what bias looks like in a classroom, and how to handle copyright and academic integrity. 13 min· Level: Foundation
- 27Automated evaluation and leaderboards, from MMLU to Chatbot ArenaUsing a public examination ranking as an analogy, this lesson explains what MMLU, GPQA, Chatbot Arena and LLM-as-a-Judge actually measure, why leaderboards are gameable, and why your own thirty questions matter more. 13 min· Level: Intermediate
Module 7: What comes next
Multimodality, reasoning models and embodied AI