teach stu.

Inspiration

Most study tools explain material to students. The problem is that reading a good explanation can create the feeling of understanding without proving that you can explain the idea yourself.

We wanted to reverse that relationship. Instead of asking an AI to teach you, what if the AI were the confused classmate and you had to teach it?

Teach Stu is inspired by the Feynman technique: explaining a concept exposes gaps that rereading can hide. Stu is deliberately curious, occasionally overconfident, and sometimes wrong. To make progress, you have to explain ideas clearly, connect them, and catch his mix-ups.

Our goal was to turn studying from passive review into an active conversation where your own words become the evidence that you understand.

What it does

Teach Stu lets a student paste lecture notes, upload text-based PDFs, or simply enter a topic and start talking. The student chooses one of three depths—Big picture, Exam ready, or Expert—and then teaches the subject to Stu.

Behind the conversation is a private Step 5 Preview Judge. It builds a hidden “cover, explain, connect” rubric and evaluates each explanation against the selected depth and source material. Students see one overall progress bar rather than a checklist of answers, so they still have to decide what matters.

Stu asks one focused question at a time and occasionally introduces a plausible misconception for the student to catch. When the Judge accepts an idea, it must cite an exact quote from the student’s own message, and the server verifies that quote before awarding credit. Contradictions can also revoke earlier progress.

When the topic reaches 100%, Teach Stu enters Re-learn mode. Stu teaches the material back using verified parts of the student’s explanations, corrects earlier mistakes against the notes, and asks follow-up quiz questions.

Students can also:

Record an explanation and review or edit the transcript before sending it.
Hear Stu’s responses through StepFun text-to-speech.
Keep the original PDF or pasted notes beside the conversation.
Jump from a source-grounded recap back to the relevant page.
Pause, resume, or delete a locally saved session.
Try deterministic sample sessions without using an API key.

How we built it

Teach Stu is a Vite and React application written in strict TypeScript, with an Express API deployed as a same-origin Vercel Function. Zod validates model output and API boundaries, PDF.js extracts and renders source documents, and IndexedDB saves notes, drafts, and conversations locally in the browser.

Every live topic calls StepFun’s step-5-preview at runtime.

First, Step 5 Preview turns the topic, selected depth, and optional notes into a private rubric. On every teaching turn, it acts as the hidden Judge: it receives the relevant source passages, rubric, conversation, and current progress, then returns a structured verdict containing credits, revocations, problems, and supporting evidence.

The visible Stu uses step-3.7-flash. Stu receives only the visible conversation and a sanitized direction from the Judge. It never receives the notes, private rubric, answer checklist, or hidden progress state, which prevents it from leaking what the student is supposed to say.

The server applies another reliability layer after the model call. Evidence must quote an actual student message verbatim. Unknown rubric IDs, altered quotes, assistant-authored evidence, duplicate evidence, and empty affirmations such as “yes, exactly” are rejected. Private state is stored in an authenticated, encrypted token bound to the topic and source documents.

Optional voice uses StepFun speech models. Browser recordings are decoded and converted to mono PCM WAV in memory, submitted through StepFun’s documented ASR interface, and returned as an editable transcript. Stu’s replies are normalized for spoken mathematical notation before text-to-speech generation. Raw recordings are not retained by Teach Stu.

The final product came together across parallel team branches:

Lucy developed the StepFun evaluation and requesting flow.
Lea designed the visual experience, animated Stu, landing page, and study workspace.
James developed the production StepFun speech handling and interruption-safe voice flow.
Samer integrated the branches, strengthened the Judge architecture, added deployment and domain infrastructure, and connected the full application on Vercel.
The team used GitHub issues, task branches, shared architecture decisions, code ownership, and reviews to coordinate concurrent human and AI work.

Challenges we ran into

The hardest problem was making AI evaluation trustworthy enough to affect visible progress. A model saying “correct” was not sufficient. We had to define strict structured outputs, separate missing information from factual contradictions, require evidence from the student’s latest explanation, and verify that evidence again in application code.

Separating the Judge from Stu was another major design challenge. A single model that sees both the notes and the conversation can accidentally reveal answers. We instead gave the strong model responsibility for evaluation and gave the visible student a much narrower view of the session.

Latency was also difficult. Step 5 Preview performs the reasoning-heavy work well, but using it for both evaluation and conversation can make every turn feel slow. We kept Stu on a faster model and built a background-grading prototype where Stu responds first while Step 5 checks the explanation in order.

Finally, deployment evolved several times. We began with a static Firebase Hosting preview, discovered that the free Firebase plan could not run the required backend, and moved the complete frontend and Express API to Vercel while keeping credentials server-side.

Accomplishments that we're proud of

We are proud that Teach Stu uses Step 5 Preview for a meaningful part of the product rather than as a generic chatbot. Step 5 decides what the student has actually demonstrated, tracks contradictions across turns, and creates a grounded re-learning experience from verified evidence.

We built an interaction where the AI is intentionally less informed than the evaluator. Stu cannot leak the hidden rubric because he never receives it. This made the playful character compatible with serious assessment.

We are also proud of the source and evidence system. Progress comes from the student’s words, every accepted claim can be traced back to what they actually typed, and the final recap can link back to the original notes.

The app supports a complete learning loop: bring material, teach it, catch misconceptions, reach full coverage, hear it taught back, and answer a quiz. It also works with pasted notes, real PDFs, typed explanations, or voice.

Most of all, the final product reflects contributions from the whole team. Separate experiments in pedagogy, interface design, voice, deployment, and reliability became one coherent application rather than remaining disconnected prototypes.

What we learned

We learned that the best role for the most capable model is not always the most visible one. Step 5 Preview is most valuable as the careful evaluator behind the experience, while a faster model can handle the conversational personality.

We learned that grounding requires application logic in addition to prompting. Structured schemas, quote verification, state binding, source checks, and rollback behavior are what turn a promising model response into dependable product behavior.

We also learned that progress indicators influence how people teach. Revealing every rubric item turns the session into a checklist. A single overall bar gives feedback while preserving the need to organize and explain the topic independently.

Voice interactions taught us to treat transcripts as drafts rather than answers. Students can pause while thinking, inspect what the system heard, correct mathematical terms, and explicitly decide when to send the explanation.

Finally, coordinating several developers and coding agents required repository structure as much as communication. GitHub issues, small branches, worktrees, shared decision logs, and owner reviews gave every contributor the same context and reduced conflicting work.

What's next for Teach Stu

Our next priority is finishing the background-grading architecture. Stu will respond quickly while Step 5 Preview evaluates the previous explanation in the background, with ordered state updates so no teaching evidence is lost or graded out of sequence.

We are also developing Teach Stu as an ASI:One agent using uAgents, the Agent Chat Protocol, and interactive cards. This would let students complete the same setup, teaching, progress, and re-learn flow from an agent conversation.

Other next steps include:

Testing the experience with students across mathematical, scientific, and interpretive subjects.
Adding OCR and stronger mathematical-layout handling for scanned or equation-heavy PDFs.
Improving real-time voice interaction and pronunciation of technical notation.
Adding clearer recovery when a provider call is slow or temporarily unavailable.
Measuring whether teaching Stu improves recall compared with passive review.
Expanding source-grounded quizzes and spaced follow-up sessions.
Polishing the mobile experience and completing the custom-domain deployment.

Teach Stu started with one question: if you can make a confused AI understand your notes, do you understand them better yourself? We want to keep building until the answer is measurable.