Classroom of Doubt

Teach three AI Classmates with hidden misconceptions. Diagnose their faulty reasoning, repair it through explanation, and prove the learning transfers to a new problem.

Comment

Classroom of Doubt: The AI That Makes You Do the Thinking

What if the best way for AI to help me learn was to stop explaining—and start misunderstanding?

Inspiration

I am currently a postgraduate student, and AI has become part of how I learn. Whenever I encountered a difficult idea, I could ask for a simpler explanation, an analogy, or a polished summary and get one in seconds. It felt like a superpower.

But I started noticing an uncomfortable gap. Something could feel completely clear while I was reading the response, yet be surprisingly difficult to reconstruct later without the chat in front of me. I was moving through material faster, but I was not always building understanding I could retrieve, explain, and use on my own.

In other words:

$$ \text{fluency while assisted} \not\Rightarrow \text{independent understanding} $$

I dug into the research to understand whether I was simply using the tool badly. A large randomized study of high-school mathematics found that unrestricted GPT-4 access improved performance during practice, but students performed worse than the control group when the AI was removed. A guarded, hint-based tutor largely avoided that negative effect. The lesson I took from this was not that AI is inherently bad for learning, but that the design of the interaction determines who does the cognitive work (Bastani et al., 2025).

Another series of experiments gave me language for what I was feeling. When an LLM presented a ready-made synthesis, learners invested less effort in gathering and integrating information than people using traditional web search. In the tasks studied, they reported shallower learning and produced advice that was shorter, less factual, and less original (Melumad and Yun, 2025). AI could remove friction, but some of that friction was where sensemaking happened.

So I decided to flip the script. Instead of asking AI to teach me, I would teach it.

That idea is supported by learning-by-teaching research. A meta-analysis of 28 studies found positive effects from preparing to teach and even larger effects when learners actually taught after preparing. The benefits extended to deep learning and delayed measures, and interactive teaching was especially valuable (Kobayashi, 2019). Teaching forces retrieval. It exposes gaps that rereading can hide. It makes “I recognize this” collide with “Can I actually explain why?”

That became the seed for Classroom of Doubt.

What I built

Classroom of Doubt is a misconception-diagnosis game for students reviewing material they have already encountered. The Learner teaches three simulated Classmates, each holding a different hidden but plausible Misconception.

One Classmate might believe that a run of heads makes tails more likely on the next independent coin flip. Another might confuse independent events with mutually exclusive events. A third might treat an expected value as a guaranteed outcome. The Learner has only eight Teaching Turns to work out what each Classmate believes, adapt the explanation, and repair the reasoning.

The Classmates do not reveal their Misconceptions, and they do not accept a correction just because it sounds confident. The Learner keeps a private Diagnosis Notebook, can teach one Classmate or the whole group, and can speak through a push-to-talk interface or type. At the end, each Classmate independently attempts an unseen Exit Ticket. The resulting Learning Report links outcomes to exact excerpts from the Learner's teaching: what changed, what remained doubtful, and whether the repaired reasoning transferred to a new problem.

There is no leaderboard and no opaque “87% mastery” score. The product asks a more useful question: What did your explanation actually change?

How I built it

The core of the project is an Evidence Gate framework. Every hidden Misconception has reasoning elements that must be addressed, claims that would reinforce or contradict it, and a separate transfer rubric. GPT-5.6 interprets the Learner's natural-language explanation and proposes exact supporting evidence, but it does not get to declare that a Classmate has learned.

Instead, an application-owned state engine validates that evidence and controls every transition:

$$ B_{t+1} = f(B_t, E_t, C_t) $$

where Bt is the current Belief State, Et is validated supporting evidence, and Ct is contradiction or regression evidence. A Classmate can remain entrenched, begin questioning, repair the Misconception, or regress if later teaching reinforces the faulty rule.

I separated the live GPT-5.6 path into seven bounded roles:

  • an Orchestrator chooses which Classmates should respond;
  • an Evidence Evaluator compares teaching with the hidden Evidence Gates;
  • Classmate Actors speak only from the application-approved Belief State;
  • a Diagnosis Evaluator checks the Learner's private diagnosis;
  • an Exit Ticket Performer attempts a new problem without seeing its answer;
  • a Transfer Evaluator checks both the answer and its reasoning;
  • a Report Writer turns validated events into useful feedback without inventing evidence.

This separation means the same model that writes a convincing Classmate response cannot silently grade that response or mutate hidden state. Structured outputs and server-only state keep Misconceptions, Evidence Gates, and answer rubrics out of the browser.

Codex was my engineering collaborator across the build. I used it to turn the product idea into an explicit specification, sharpen the domain language, develop the belief-state engine test-first, define GPT-5.6 role contracts, build the responsive teaching and reporting flows, and exercise the complete journey in a real browser. It also helped me catch the less glamorous but essential problems: stale writes, duplicate Teaching Turns, hidden-state leakage, voice-finalization races, narrow-screen usability, error recovery, reduced-motion behavior, and accessible typed input.

The app includes three curated Concept Packs—introductory probability, forces and motion, and natural selection—and supports both a live GPT-5.6 experience and a deterministic path that uses the same APIs, state engine, content, and report renderer for reproducible judging.

Challenges I faced

The hardest problem appeared precisely because I had made AI the student: LLMs are often too agreeable to be credible protégés.

A recent preprint tested whether simulated LLM students preserve a coherent Misconception and update selectively. Across seven models and several prompting strategies, the simulated students changed their answers at similarly high rates after targeted, irrelevant, and generic corrective feedback. They behaved less like learners whose reasoning had changed and more like capable problem-solvers taking any correction as permission to abandon the role (Do, Sonkar, and Sachan, 2026).

That failure mode would make my entire learning loop dishonest. If a Classmate accepted “No, that's wrong,” the Learner could feel persuasive without locating or repairing the underlying reasoning. Persona prompts alone were not enough. The Evidence Gate framework, application-controlled Belief States, regression handling, and unseen transfer checks all grew from this challenge.

A second challenge was balancing natural conversation with trustworthy evaluation. Hard-coded keyword matching would reject valid explanations phrased in unexpected ways; giving the model full authority would recreate the agreeableness problem. The solution was a hybrid boundary: GPT-5.6 handles semantic interpretation, while deterministic code controls authority and preserves an audit trail.

The third challenge was making rigor feel playful rather than punitive. The Classmates needed distinct conversational behavior without becoming stereotypes. The report needed to be honest without pretending to certify mastery. Voice needed to feel immediate while preserving an editable draft and never storing raw audio. Every one of those choices pushed the product toward evidence, agency, and useful doubt rather than grades or gamification.

What I learned

I began this project thinking the answer was to use less AI. I finished with a more useful principle: use AI to create the conditions for thinking, not to remove the need for it.

Powerful models are excellent at explanation, interpretation, and responsive conversation. But in a learning product, helpfulness is not the same as learning, agreement is not the same as understanding, and a correct answer is not proof of correct reasoning.

Classroom of Doubt turns those limitations into the activity. The AI does not replace the Learner's synthesis; it gives the Learner three different minds to diagnose. It does not reward confidence; it asks for relevant evidence. It does not stop at “I understand”; it tests whether the repaired idea survives a new problem.

The project is my attempt to use AI as an aid rather than a crutch: not a machine that always has the explanation, but a classroom that makes me earn my own.

Built With

Share this project:

Updates