The curriculum.

The literacy.

AI is not one thing — it is five capabilities, learned best by building each one. We teach the five domains separately, then together; your child finishes able to name what a system is doing, why it works or fails, and where it sits in the larger picture.

The five domains

1. 1Perception

   How a machine takes in the world. Pixels become images; sound becomes spectrograms; words become tokens; sensor signals become readings. Students train classifiers, explore datasets, and learn where perception fails — small data, biased data, adversarial inputs.

2. 2Reasoning

   How a machine works over what it perceives. Search, logic, planning, decision-making — the operations that turn a representation into an answer. Students implement these themselves in Python, not by calling a library but by writing the algorithm.

3. 3Learning

   How a machine improves from examples. What training data is, how a model adjusts to it, what overfitting and underfitting look like in practice. Students train small models from scratch and see what changes when the data changes.

4. 4Natural interaction

   How a machine talks, listens, and acts in a world it shares with humans. Language is the deepest case. Students build with foundation models, learn to prompt as a form of writing, and verify every output against ground truth.

5. 5Societal impact

   What AI changes when it leaves the lab — labour, equity, privacy, attention, truth. Throughout every cycle, students name a harm, an actor who controls it, and a check the system needs. This is the human discipline that makes the other four useful.

How we measure

Every student is scored on the same rubric — five domains, five levels each, baseline and exit. Numbers, not adjectives. Published per cohort once the first cohort graduates.

The progression.

Underneath every cycle is a Python curriculum that climbs from graphics sandboxes to advanced algorithms. Four tracks. Each track builds on the one before. The top track carries college credit — the kind that transfers to a university transcript.

The four tracks

1. Foundations

   Before code is text. Block-based graphics, sequencing, decomposition, pattern recognition. Where Beginner students learn what a program is — and what it is not — before they write a line.

2. Programming

   Python from the parts. Variables, conditionals, loops, functions, strings, lists, file I/O. Built alongside graphics the student can see change as the code runs. The transition from "follow steps" to "design steps."

3. Systems

   Python in depth. Data structures, abstraction, object-oriented design. The transition from "write a script" to "design a system." Where the student begins to read others' code as critically as they write their own.

4. Advancedcredit-bearing

   Algorithms, complexity, recursion — at university entry-level rigor. The advanced track culminates in a credit-bearing assessment; students who complete it carry college credit forward to university, regardless of where they enroll.

How we measure

Every module is auto-graded. Every student has a progress report — module-by-module, week-by-week — that we share with parents and publish per cohort. Two metrics, both honest: a literacy rubric (the five domains above) and a progression report (this Python curriculum). Both go live on /results the week the first cohort graduates.

The extension.

When students are ready, the code leaves the screen. Robotics is the bridge — sensors become real, decisions move servos, perception bumps into walls. It changes how students think about every line of code that follows.

• Sensors as the perception domain made physical — light, distance, sound, touch.
• Decisions as the reasoning domain made consequential — the robot acts; the action cannot be un-acted.
• Failure as the learning loop made visible — the maze is solved or it is not; the student debugs the model, the algorithm, or the world.

The extension is opt-in for Intermediate and Advanced students. Most of every cycle still happens in simulation; the physical robot is an addition, not the spine. Families who choose not to add it lose none of the curriculum substance.

The engineering.

The way engineers build with AI changed in 2023. The textbooks have not caught up. We teach the modern stack — foundation models as the substrate, prompting as composition, retrieval as memory, agents as architecture, and verification as the discipline that makes any of it trustworthy.

Four working practices

1. 1Prompting as composition

   A prompt is not a search query. It is a piece of writing with a structure — context, instruction, constraints, examples, output shape. Students learn to write prompts the way a careful author writes a brief.

2. 2Retrieval as memory

   Models do not know your facts. Retrieval is how the model is given the relevant ground truth for the question at hand. Students build small retrieval-augmented systems and watch them outperform raw prompting on knowledge tasks.

3. 3Agents as architecture

   An agent is a model with permission to take action — to call a tool, to read a file, to send a message. Students design agents at small scale and learn what kinds of work agents can be trusted with and what they cannot.

4. 4Verification as discipline

   Every output is met with the same three habits: question the claim, verify against ground truth, decide whether to override. Critical thinking is not a topic — it is the discipline that runs underneath every other practice in this list.

The environment.

Your child builds with the same tools a working AI engineer uses today. Not a sandboxed teaching simulator. Not a toy model. The real ones — under a Navigator who knows what they can and cannot do.

What your child works with

• Anthropic's Claude — the frontier reasoning and writing model. Students build with it, prompt it, verify it, override it.
• Google Gemini — the frontier multimodal model. Image, video, and document inputs for projects that span more than text.
• Python in a hosted development environment — the same kind a working engineer would open on Monday morning.

These tools change every quarter. The curriculum does not chase versions; we teach the habits and the literacy that survive any version. When your child sits in front of a new model in ten years, they will recognize what kind of system it is, what it can be trusted with, and what to verify.