Protégé

Inspiration

We kept noticing the same failure in ourselves. You read the chapter, you follow every line, it all makes sense, and then someone asks you to explain it and there's nothing there. Learning science has a name for this: fluency mistaken for understanding. Recognising an explanation is easy. Producing one is the hard part, and only the second one is knowledge.

Then we looked at what AI study tools actually do, and every single one of them makes the problem worse. They explain things to you. They summarise, they simplify, they answer. All input, all fluency, and being explained to feels exactly like knowing.

The technique that genuinely works is the reverse. The protégé effect, which is the finding that students learn material significantly more deeply when they prepare to teach it, and Feynman's method both rest on the same mechanism. Teaching forces every gap in your understanding into the open, because you can't hand wave to someone who doesn't already know what you mean.

Nobody has built it, and the reason is obvious. It needs a listener who is patient, available at one in the morning, and convincingly ignorant. That is a very hard person to find and a very interesting thing to ask a language model to be.

What it does

Protégé gives you an AI student who genuinely doesn't know your topic. You pick something you're studying, and then you teach it.

It doesn't answer you. Each turn, it does four things.

It repeats back what your explanation actually taught it. Not what you meant, but what your words landed as. This is the moment people react to, because you see your own hand waving from the outside.

It names the misconception you created. If your explanation would leave a real student holding a wrong idea, it says so, in the first person: "what I now wrongly believe: encryption is something the website does after my message arrives." Which is exactly what you told it, if you listen to yourself carefully.

It asks one question, aimed at the single weakest, most assumed thing you just said. Not a quiz question from a bank, but a question that only exists because of the specific hole in your specific explanation.

It redraws a map of your understanding. The model maintains a set of concepts that any competent explanation of the topic must cover, and re-grades every one of them each turn. Concepts you've genuinely explained get pulled toward the centre. Ones you've skipped drift to the outer ring. Your blind spots are, literally, the dots on the edge of the screen.

You can pick who you're teaching. A nine-year-old who takes every word literally and destroys jargon, a skeptical classmate who accepts nothing you didn't justify, or a sharp examiner hunting for the edge case your explanation breaks on. Each one finds a different kind of gap in the same explanation.

You can also just talk to it out loud and hear it answer, which is much closer to real teaching and catches the filler that typing lets you hide.

At the end you don't get a score on yourself. You get a report on your explanation: a grade, the things you taught well quoted back in your own framing, the specific things to go study and why they matter, and spaced repetition cards generated from your own gaps, exportable as CSV straight into Anki or Quizlet. The output of a session is a study plan you wrote by failing to explain something.

How we built it

It's a single HTML file. No framework, no build step, no dependencies, no backend. That was a deliberate constraint, because an educational tool that needs npm install before a student can try it is a tool most students never try. Clone it and open the file, or open the GitHub Pages link.

Every turn is one call to the Anthropic Messages API from the browser, replaying the whole transcript. The model is stateless, so the conversation is the memory.

The interesting engineering isn't the API call, it's the output contract. The model doesn't return prose that we display. It returns a structured object that drives the entire interface:

json { "reply": "what I now think you told me", "question": "the one thing I need you to clear up", "comprehension": 52, "misconception": "the wrong belief your words left me with", "concepts": [{ "name": "Key exchange", "status": "shaky", "note": "named, not explained" }], "flashcards": [{ "front": "...", "back": "..." }] }

Three prompt level constraints make it behave like a student instead of a chatbot.

It's forbidden from knowing anything. The system prompt bars it from teaching, correcting, or using any fact the user hasn't supplied. Its only knowledge of the topic is your explanation, which is what makes the misconceptions honest rather than performed. The concept list is pinned. The prompt requires the same concept names across every turn, with statuses being the only thing that changes. Without this the model reshuffles its taxonomy each turn and the map becomes noise instead of a trend. Comprehension rises for mechanisms, not assertions. It's instructed not to reward confident sounding claims. This is what stops the meter being flattered upward by fluent filler, which would recreate the exact illusion the whole project exists to break.

The concept map is hand drawn SVG, positioned by status, with CSS transitions on the node coordinates so concepts visibly migrate inward as you explain them. Voice is the Web Speech API in both directions. State lives in memory. The API key lives in local storage and is sent only to Anthropic.

It also ships with a fully scripted demo mode that runs with no API key at all, so anyone can open the link and see the entire product in thirty seconds, and an autopilot mode that performs the demo hands free for recording.

Challenges we ran into

Making a model be ignorant is much harder than making it be smart. Our first versions were useless. The model would ask a question and then, in the same breath, answer it. It knew everything about every topic and couldn't stop helping. Getting it to hold the line took explicitly forbidding correction and pinning its knowledge to the transcript, and the fix wasn't a bigger prompt, it was a narrower one.

Scoring an open ended explanation with no answer key. A quiz app compares your answer to a stored correct answer. We have neither. The model has to construct a model of what a good explanation of an arbitrary topic requires, then grade unstructured human prose against it, and keep that model stable across a whole session so the map means something.

Keeping the score honest. Early on, comprehension climbed whenever the user sounded confident. That is precisely the illusion of competence we set out to break, rebuilt inside our own product. Instructing the model to distinguish an explained mechanism from an asserted claim fixed it.

Structured output from a model asked to be in character. Asking for JSON and warm first person student dialogue in the same response is a real tension. Handling the cases where it wraps output in a code fence, or drifts, meant the parse layer had to be forgiving and the failure had to be visible to the user rather than a silent stall.

Accomplishments we're proud of

The misconception mirror. Watching someone read a wrong belief that they personally caused, in the first person, is the single most effective teaching moment we've ever built, and it lasts about four seconds.

Also, it's genuinely finished. No build step, deploys anywhere static, works on a phone, keyboard operable, respects reduced motion, and a stranger with no API key can experience the full product from a single link. We'd rather ship something small that completely works than something large that demos.

What we learned

That the constraint is the product. Every meaningful decision in Protégé was a subtraction. The model can't teach, can't correct, can't use outside knowledge, can't change its concept list, can't reward confidence. Almost everything interesting here came from taking capability away from a very capable model and pointing what remained at one job.

And that "AI for education" nearly always means using AI to produce answers faster. It turns out the more valuable thing is to use it to produce a question, specifically the one question you were avoiding.

What's next

Classroom mode, where a teacher sets one topic and sees an aggregated concept map across thirty students, turning "which idea is my whole class skipping" into something you can see rather than guess at after the test. Session history with re-teaching of the same topic a week later, so the gap map becomes a record of what actually stuck. And diagram input, so you can teach with a drawing, because for a lot of topics that's how a real teacher would.