Learning by Teaching

Learning by teaching (LbT) — the instructional framework, grounded in the protégé effect, in which students deepen their understanding by explaining material to a peer, tutee, or agent. Decades of work in LbT and peer tutoring show that explaining concepts, anticipating misunderstandings, and responding to questions consolidate understanding and support transfer. In the AI era, teachable agents — and increasingly LLMs configured as novice tutees — operationalize LbT at scale, positioning students as instructors who must explain, correct, and fill gaps.

Questions to Consider

• Recall a time you truly understood something only after explaining it to someone else. What was happening mentally — and why do you think teaching produces deeper understanding than just studying alone?
• A common view is that teaching is for experts, and novices have nothing to offer. Yet 'learning by teaching' rests on the opposite premise: preparing to teach forces you to organize knowledge and find your own gaps. How does that reframe who benefits from teaching?
• The page describes 'teachable agents' — software that students teach as part of learning. With an LLM, you can configure a chatbot as a fallible novice tutee that asks questions and makes mistakes. What would you need to design into such a tutee for it to actually improve learning rather than just chat?
• One challenge is 'engineering fallibility': AI models are trained to give expert, fluent answers, which is the opposite of the struggling novice the learning-by-teaching paradigm wants. Why might an error-prone tutee be more effective for learning than a correct one?
• A ChatGPT-based teachable agent improved learning but its tendency to generate correct code limited error-correction practice. How might a tool that always gives the right answer actually shortchange the learner who needs to practice spotting and fixing mistakes?
• If you were to design a learning-by-teaching activity for your own class, what would make the teaching task consequential enough that students put real effort into it rather than copy-pasting an answer?

Introduction

Learning by teaching is the finding, usually traced to the protégé effect, that preparing to teach — and actually explaining to another person or a teachable agent — produces deeper processing than studying alone. The demands of teaching force learners to organize knowledge, anticipate misunderstandings and generate explanations, which surfaces gaps in their own understanding and strengthens Metacognition. AI enters the idea from both directions: tutoring systems and teachable agents can play the student, while a growing literature asks what happens to learning when the machine, rather than the learner, supplies the explanation (Generative AI, CS Education).

The Protégé Effect

Learning by teaching rests on the finding that preparing to teach and actually explaining to another person produces deeper processing than studying alone. The demands of teaching — articulating ideas, anticipating misunderstandings, and answering questions — force learners to organize knowledge, identify gaps in their own understanding, and generate explanations that support retention and transfer. Benefits are most evident in Collaborative Learning contexts and in well-structured domains that support teachable agents (e.g., Betty's Brain). The protégé effect names the mechanism: students put forth more effort and reflect more deeply when they feel responsible for teaching something, so they clarify Misconceptions about AI and fill gaps through explanation and Metacognition.

Teachable Agents: From Rule-Based to Conversational

Teachable agents are the software systems through which learning by teaching is operationalized — a learner teaches a system as part of learning. Traditional teachable agents were rule-based or retrieval-based and could respond only to limited commands; their key limitation was an inability to engage in natural-language dialogue. Large language models change this: they can flexibly adopt roles via prompting — including the role of a "tutee" that asks questions or makes mistakes — and engage in open-ended dialogue, enabling LbT in less-structured domains (writing, vocabulary) than was previously possible.

The knowledge base's evidence base traces this shift to conversational, LLM-based teachable agents:

• ChatGPT as a teachable agent (Chen et al.) supports LbT in programming, improving knowledge gains, programming ability, and self-regulated learning — though its tendency to generate correct code limits error-correction practice.
• Explique at scale (Wang et al.) deployed an AI teachable agent (Algorithm Apprentice) to 546 students over an 11-week semester, finding that explanation-oriented dialogue predicts fewer incorrect quiz submissions, while external-content reuse predicts more.
• Vocabulary teaching (Uchida et al.) used an LLM as a student to generate dynamic questions, improving retention at 3 and 7 days.

Engineering Fallibility: LLMs as Novice Tutees

A central design challenge for LLM-based teachable agents is that LLMs are trained to produce expert-level, fluent responses by default — the opposite of the fallible novice the LbT paradigm wants. Making an LLM a good tutee requires engineering fallibility:

• Generated errors can pass as authentic. In a blinded annotation study, experts misclassified 164 of 196 (83.7%) LLM-generated Java submissions as human-written, so a tutee can supply realistic bugs to debug rather than only correct code (Keramati et al. (2026)).

• Prompting for teachability (Miller & Bosch) found that constraint-based prompts explicitly forcing error production (e.g., "answer incorrectly" or "get 2–3 wrong") elicit novice-like behavior far more reliably than persona-, misconception-, or uncertainty-based prompts.

• Engineered knowledge gaps (Yang et al.) design problems the LLM cannot solve without knowledge only the student possesses, making teaching a necessity and countering the passive over-reliance of LLM-as-tutor use.

• Explique's apprentice constraints (Wang et al.) instruct the tutee to (a) stay a novice, (b) keep requesting clarification until the student's explanation is accurate, and (c) never reveal the target explanation — and to resist students who try to reverse the roles and have the tutee explain back.

• Unlearning as a weights-level route to fallibility. Machine unlearning suppresses 16 targeted knowledge components in Mistral-7B, dropping accuracy from about 0.75 at a 10% forgetting ratio to below 0.5 at 40% while the base model held near 0.85. The suppressed knowledge returned through supervised relearning and coach-guided dialogue, so the tutee's knowledge level is a dial rather than an assertion (Song, Guo & Lin, 2026).

Questioning, Self-Regulation, and Active Learning

Two further affordances recur across the knowledge base:

• Questions identify knowledge gaps. LbT systems use learner-generated questions to expose gaps and reinforce comprehension, and LLM-generated questions replace rigid template-based generators.
• Teach-back surfaces what clarification misses. In a 22-participant post-lecture review system, a Peer agent's reflective teach-back consistently exposed gaps between what learners believed they understood and what they could articulate, which lecture-grounded clarification alone had not revealed (Fang & Reidsma (2026)).
• LbT scaffolds self-AI Regulation in Education. Teaching a conversational agent fosters Self-Efficacy and the implementation of self-regulated learning strategies, and connects LbT to Desirable Difficulties — the effortful act of explaining and correcting is itself a productive struggle that AI's friction-removal would otherwise erase.
• What predicts tutor learning is knowledge-building, not prior knowledge. Across 23 middle-school tutors, the share of responses that built knowledge rather than restated it predicted conceptual post-test scores (β = .138, p < 0.05) while prior test scores did not predict who produced them, and low-prior tutors who built knowledge finished level with high-prior peers (Ameen et al., 2026).

Why It Matters in AI Education

Learning by teaching is the constructive, Active Learning counterpoint to the dominant LLM-as-tutor pattern. Where a tutor gives answers (and risks Over-Reliance), an LbT setup makes the student the teacher, forcing explanation, gap-detection, and knowledge construction. This positions LbT as a key strategy for turning generative AI from a crutch into a tool for deeper learning, and connects to Desirable Difficulties, Active Learning, and Constructivism Pedagogies and Teaching Strategies.

Putting Learning by Teaching into Practice

Design patterns for an AI tutee

The research above converges on a few reusable patterns for turning a default-expert LLM into a productive tutee:

• Constraint-based novice prompts (most reliable). Rather than asking the model to "pretend to be a confused student," explicitly force fallibility and a teaching loop, e.g.: "You are a novice student learning about [concept]. Ask me to teach it to you. Ask clarifying questions and deliberately get 2–3 things wrong during our conversation. Never state the correct answer yourself — wait for me to explain, then tell me whether I made sense."
• The reverse-teaching guard. Add a rule that the tutee must decline to explain the answer back when the student tries to flip the roles: "If I ask you to solve the problem or explain the concept, remind me that I'm the teacher and ask me to explain it instead." Explique shows this resistance is what preserves the LbT interaction.
• Engineered knowledge gaps. Structure the task so the model cannot answer without information only the student holds — the student's knowledge becomes genuinely necessary, not optional. This converts the interaction from optional chat into required teaching.
• An external success criterion. Give the teaching a real consequence — a gatekeeper quiz that unlocks only after the student teaches successfully (Explique), or a code-judging platform the student must make the agent's output pass (Chen). Accountability is what sustains genuine effort and prevents the whole exercise becoming a checkbox.

Tips for instructors

• Make the teaching task consequential, not busywork. The strongest evidence for engagement comes from activities that matter — Explique gated a graded quiz behind the teaching exercise; Chen tied the tutee's output to passing a judging platform. If teaching is purely optional, students will rationally skip the hard part.
• Give students a teaching protocol, not just a chat window. Scaffold the interaction with a structure — "explain the concept → give a concrete example → answer the tutee's questions → check for understanding" — so open-ended dialogue becomes a deliberate teaching sequence rather than aimless conversation.
• Address content-dumping head-on. Explique found that direct copy-paste of external content rose from under 15% to 30–35% of interactions by the end of the semester. Tell students why pasting defeats the purpose, and consider an accountability step (e.g., "explain the agent's misunderstanding in your own words").
• Pair LbT with debugging practice. Because AI writes correct code, students may lose error-correction practice. Deliberately ask the tutee to misimplement something, or follow the teaching session with a bug-finding task, so debugging stays in the loop.
• Watch the effort gradient. Expect novelty to fade; plan to vary the target concepts, add challenge, or rotate which students take the teaching role to sustain cognitive effort across a term.

Tips for developers

• Prefer hard constraints over persona alone. Prompting for "uncertainty" or "a student persona" is unreliable; explicitly force errors and a clarification loop. (See Prompting for Teachability: Designing Novice Personas in LLMs for Learning by Teaching Contexts.)
• Build a completion criterion. Define when the student has explained enough (Explique used an LLM tool function keyed to the concept's learning objectives) so the interaction ends on understanding, not on a time limit or a fixed turn count.
• Log and code the dialogue. Explique used word-per-minute detection plus LLM semantic coding to classify interactions as Detailed / Minimal / External Content Use — that signal is how you detect circumvention and declining engagement before it becomes a problem.
• Give instructors a dashboard. Completion rates and qualitative patterns in teaching interactions let a human intervene when effort drops (Explique's instructors monitored exactly this).

Implications and open questions

• LbT is a scalable antidote to AI over-reliance — it inverts the tutor/student role and keeps the learner cognitively active, which matters more as AI gets more fluent and more "helpful."
• Fallibility is a feature, not a bug. A tutee that is too correct removes the error-correction and gap-detection that make LbT work; design for the productive struggle rather than against it.
• Open questions remain: How do LbT interactions sustain beyond a semester as novelty fully fades? Does LbT transfer to non-CS, less-structured domains at the same scale? Can automated dialogue coding become a practical, real-time engagement monitor for instructors? And how do we keep the teaching role meaningful for every student rather than a motivated few?

Connected Concepts

• Pedagogical Patterns — Explaining to an AI tutee: the best-evidenced sequence in the knowledge base
• Generative AI
• Active Learning
• Constructivism
• Scaffolding
• Self-Regulated Learning
• Metacognition
• Desirable Difficulties
• Cognitive Offloading
• CS Education
• Collaborative Learning
• Intelligent Tutoring
• Pedagogical Agent
• Pedagogies and Teaching Strategies — Umbrella: pedagogies and teaching strategies in AI education

Connected Articles

• Learning-by-Teaching with ChatGPT: The Effect of a Teachable ChatGPT Agent on Programming Education — ChatGPT as a teachable agent in programming
• Turning 500+ Students into Teachers: A Semester-Long Study of an AI Teachable Agent in an Undergraduate Algorithms Course — Explique: teachable agent for 546 students
• Prompting for Teachability: Designing Novice Personas in LLMs for Learning by Teaching Contexts — Designing novice personas for teachability
• Learning by Teaching: Engaging Students as Instructors of Large Language Models in Computer Science Education — Students as instructors of LLMs (Socrates)
• Empowering Vocabulary Learning Through Teaching AI: Using LLMs as a Student to Perform Learning by Teaching in Vocabulary Acquisition — Vocabulary learning by teaching AI
• From Confusion to Consolidation: A Staged Conversational Workflow for Post-Lecture Review — Teach-back consolidation in a conversational review system
• Simulating Novice Students Using Machine Unlearning and Relearning in Large Language Models — machine unlearning to hold a tutee at a novice knowledge level, and relearning through teaching dialogue
• Simulating Students' Java Programming Errors with Large Language Models — Simulating student errors with LLMs
• Beyond prior knowledge: the predictive role of knowledge-building in tutor learning — knowledge-building responses, not prior knowledge, predict tutor learning