AIQ
AIQ
Part of the How Computers Think lesson guide. Teaching a different grade? 🌈 Explorer (5–7) · 🔧 Builder (8–10) · 💻 Hacker (11–14)
Deliver this flatly, letting the numbers do the work:
"The Apollo Guidance Computer had 72KB of memory. Your phone has 6GB — roughly 83,000x more. Yet AGI remains unsolved. Let's examine why raw computation doesn't equal intelligence — from transistor physics to the limits of von Neumann architecture."
Ask directly: "If we've had an 83,000-times increase in one resource, and intelligence still hasn't appeared as a byproduct, what does that tell you about the relationship between computing power and intelligence?" Take a few answers, then frame the lesson: this isn't a lesson about how computers work at a surface level — this age band already mostly knows that — it's about the specific architectural reasons scaling has not been sufficient, which is a live, unresolved question in AI research, not settled trivia.
Architect mode has no mascot by design, and the delivery here should match that: treat this as a university-preview lecture rather than a game-show reveal. Students at this stage are being prepared for portfolio work and career paths in the app, so it's worth being explicit that the vocabulary in this lesson (von Neumann architecture, the frame problem, neuromorphic computing) is the same vocabulary used in undergraduate computer science and AI courses — not simplified classroom terminology.
Structure this as a short lecture-and-discussion, using the app's three scenes as a spine and going considerably deeper on the "why" than the in-app content itself does.
Nearly every general-purpose computer built since the 1940s, including the phone in every student's pocket, follows the von Neumann architecture: a single memory holds both the program's instructions and its data, and a central processing unit fetches instructions from that memory one at a time, decodes them, and executes them sequentially. This is the concrete mechanism behind the "Input → Process → Output" idea introduced earlier in the lesson series — Process is this fetch-decode-execute loop, running billions of times a second. Moore's Law — the decades-long trend of transistor counts roughly doubling on a regular cadence — has pushed chips from thousands of transistors to tens of billions, packed at process nodes measured in a few nanometers. That is what has driven the 83,000x memory increase in the hook, and comparable gains in raw processing speed.
It's worth being precise with this class about what "process node" even measures, since students will encounter the term in tech coverage: it's roughly the size of the smallest feature that can be reliably manufactured on a chip, and smaller generally means more transistors fit in the same physical area — which is exactly why transistor counts have scaled the way they have. It's also worth being honest that this scaling has slowed in recent years as feature sizes approach the physical size of a handful of atoms, which sets up Part 2 and the discussion questions well: the free lunch of "just wait, chips get smaller and faster" is running out even before you ask whether it would have led to AGI in the first place.
Two limitations are worth naming precisely, because they explain why "just add more compute" has not been sufficient on its own:
Note for discussion honesty: modern large-scale AI systems mostly sidestep the frame problem as it was originally posed (by learning statistical patterns from data rather than maintaining explicit symbolic world models), but the deeper point survives — representing "what a situation actually means, and what follows from it" is a different kind of problem than executing instructions quickly, and nobody has a settled answer for how much of it can be solved by scaling alone.
This is a good place to be candid about the limits of your own certainty as the teacher, and to model that explicitly for students: the frame problem, the von Neumann bottleneck, and the observation that decades of scaling haven't produced AGI are all well-established. Exactly which architectural or algorithmic change (if any single one) would resolve them is an open research question, not something this lesson — or this teacher — can answer definitively. Presenting it that way is more accurate, and more useful to a college-bound student, than either overclaiming that AGI is imminent or dismissing it as impossible.
Briefly introduce neuromorphic computing as one active research direction: chips designed to mimic the structure of biological neural circuits (event-driven, massively parallel, and far more energy-efficient per operation than a von Neumann chip) rather than executing sequential instructions from shared memory. Frame it accurately as exploratory — an alternative architecture being researched specifically because some researchers think von Neumann-style scaling alone is not the path to more general intelligence, not as a solved replacement.
Also worth naming: most of the large-scale AI progress students have heard about in the news (large language models, image generators) still runs on ordinary von Neumann hardware — GPUs, which are still fetch-decode-execute machines, just heavily parallelized for the specific pattern of arithmetic that these systems need. That's an important nuance: the recent leap in AI capability came primarily from new algorithms and enormous amounts of training data running on refined (not fundamentally different) hardware, not from a hardware paradigm shift. Neuromorphic computing remains a separate, earlier-stage research track.
Run the lesson's underlying sorting exercise as a closing discussion, but at this level frame it as sorting problems rather than sorting facts. "Making a chip run faster at fixed transistor size" is largely an engineering problem — hard, but the path is understood. "Representing what doesn't change when an action occurs, at the scale of the real world" (the frame problem) and "producing genuine, general understanding rather than increasingly convincing pattern-matching" are open problems — nobody currently has a settled architecture or algorithm that is agreed to solve them. Have students sort a few more candidates themselves: shrinking a transistor further, storing more data cheaply, building a system that reliably knows the limits of its own knowledge. Expect disagreement on that last one — that disagreement is itself a fair reflection of where the field actually stands.
Where students tend to push back: some will argue that if a system's outward behavior is indistinguishable from understanding, the internal distinction this lesson draws is philosophical hair-splitting rather than something that matters practically. That's a legitimate position with real defenders (it echoes long-running debates in the philosophy of mind), and it's fine to say so rather than overriding it. Where you can push back usefully is on consequences: whether or not the internal distinction "matters" often depends heavily on the stakes of a specific decision — a wrong answer from a search engine and a wrong answer from a medical or legal AI system carry very different costs if the system's apparent confidence isn't backed by genuine understanding of the situation.
At this level, the useful check isn't just "did they pick the right option" but "can they explain, in a sentence, why the wrong options are wrong." Use the explanations below as talking points if you want to turn the quiz review into a two-minute oral check rather than a silent multiple-choice pass.
Close with: "Hold two ideas at once when you read AI news this year: computing power really has grown by an almost unimaginable factor since Apollo, and that growth really has enabled things that were impossible a decade ago. But 'more compute' and 'more understanding' are not the same axis, and conflating them is one of the most common — and most consequential — mistakes in how AI gets discussed publicly, including by people who should know better."
Extension activity — research and argue: Have students research one real non-von-Neumann or neuromorphic project (for example, Intel's Loihi or IBM's TrueNorth) and prepare a short written or verbal argument answering: "Is artificial general intelligence achievable through scaling classical, von Neumann-style computation alone, or does it require an architectural shift?" Require them to reference at least one specific limitation from today's lesson (the von Neumann bottleneck or the frame problem) in their reasoning, and to state clearly what evidence would change their mind.
If there's extra time: have students bring in one recent AI product claim (a headline, an ad, a press release) and evaluate it in class using today's framework: does the claim describe a specific, testable capability (a task the system does well), or does it lean on vague language about "understanding," "thinking," or "reasoning" without specifying what that means? This is good practice for the kind of skeptical reading this age band will need well beyond this course.