# The learning stays with you

> From getsimeon.com/docs/the-learning-stays-with-you (27 October 2026). A write-up of how Simeon is built, for a coding agent (Claude Code, Codex, Cursor…) to use as a reference when building something like it. File paths are Simeon's own: take the ideas, not the paths.

## The idea in one paragraph

The easy way to put AI into studying is a chatbot tutor: the student asks, it explains, it solves, it summarises.
It feels like learning, and the practice scores go up. But the research so far says that when the AI does the
thinking, the student's own learning tends to fall behind, and they come to need the tool for work they could
once do alone. Some researchers call this **cognitive debt**. Simeon is built the other way round. The AI does the
chores around studying: getting the course out of Canvas, reading every file, finding the past papers, checking
the model answers, building a day-by-day plan to the exam. The part that makes you learn stays with you:
recalling, writing answers out on paper, marking them against the points, coming back to what you got wrong.
Simeon gives you somewhere to start. It doesn't do the studying for you.

> **Figure:** Two columns: what the AI does (export the course, read every file, find past papers, check answers, build the plan) and what the student does (recall, write answers on paper, mark against the points, return to weak topics). Where the line is. Everything on the left used to cost a student hours before revision even began. Nothing on the right can be handed over without losing what it's for.

---

## 1. Why not a chatbot tutor

A chat window that can explain anything is a good product to demo. Ask it about a past-paper question and it writes a
clean, correct answer. The student reads it, nods, and moves on. Reading a good answer feels a lot like knowing how to
write one, and that feeling is the problem.

Learning research has said for decades that memory is built by **effortful retrieval**, not by reading. Testing
yourself beats re-reading even when re-reading feels more productive (Roediger & Karpicke, 2006). Material you
produce yourself is remembered better than material you're given (the *generation effect*: Slamecka & Graf, 1978).
Difficulties that slow you down during practice, like recalling instead of looking up or spacing sessions out instead
of cramming, make learning stick for longer (Bjork & Bjork's *desirable difficulties*). A large review of study
techniques rated only two as highly useful: **practice testing** and **spreading practice out over time** (Dunlosky et
al., 2013).

A chatbot tutor removes those difficulties. That is what makes it pleasant, and why it can backfire. Handing
mental work to a tool is called *cognitive offloading* (Risko & Gilbert, 2016). It's often sensible: nobody needs to
memorise a phone number. But in studying, the effort you offload is the thing you came to do.

## 2. What the recent studies found

The evidence on generative AI and learning is new and still thin, but the early results point the same way.

**High-school maths, about 1,000 students (Bastani et al., PNAS, 2025).** Students practised with either a plain
ChatGPT-style assistant (*GPT Base*), an assistant with guardrails that gave hints instead of answers (*GPT Tutor*), or
no AI. During practice, both AI groups did far better than the control group. Then the AI was taken away for the exam.
The GPT Base group scored **17% lower** than students who never had it. The authors put it down to students using the
assistant as a crutch. The guardrails mostly removed that harm: the GPT Tutor group did about as well as the control.

> **Figure:** Bar chart of grades relative to the control group. Practice with AI: GPT Base plus 48 percent, GPT Tutor plus 127 percent. Exam without AI: GPT Base minus 17 percent, GPT Tutor about the same as control. Grades relative to students who never had the AI (Bastani et al., 2025). The assistant that answered made practice look better and the exam worse. Bars for practice and the exam are drawn to the same scale.

**Essay writing with EEG, 54 adults (Kosmyna et al., MIT Media Lab, 2025).** People wrote essays with ChatGPT, with a
search engine, or with nothing. The brain-only group showed the strongest, most widespread brain connectivity and the
ChatGPT group the weakest. ChatGPT users struggled to quote essays they had written minutes earlier and felt little
ownership of them. In a fourth session, people who had been using ChatGPT wrote without it and still showed lower
engagement. The paper's title gave the idea its name: *accumulation of cognitive debt*. It's a preprint with a small
sample, and some critics say the term goes further than the EEG can show. But it fits the other findings.

**University students, 117 in a randomised trial (Fan et al., British Journal of Educational Technology, 2025).**
Students revising an essay with ChatGPT improved their essays more than the other groups. Their knowledge gain
and transfer were no better. The authors call the pattern *metacognitive laziness*: leaning on the tool instead of
planning, monitoring and checking your own work.

**Knowledge workers, 319 surveyed (Lee et al., CHI 2025, Microsoft Research and Carnegie Mellon).** The more people
trusted the AI, the less critical thinking they reported doing. The more they trusted themselves, the more they did.
This is self-reported, so it measures what people noticed, not what they could do.

The pattern across all four: **an AI that does the task makes the output better and the person no better, or
worse, once it's gone.** An exam is the moment it's gone.

## 3. Where Simeon draws the line

So the question for us wasn't "how much can the AI teach?" It was: **which parts of studying cost a student time
without teaching them anything?** Those parts go to the AI. The rest stays with the student.

| The chore (AI) | Why it's safe to hand over |
|---|---|
| Exporting the course from Canvas | Clicking through 60 modules teaches nothing |
| Turning PDFs, slides and scans into text | Searchable notes, not understanding |
| Finding every past paper and question | Hours of searching, zero learning |
| Writing model answers with marking points | The student still has to produce the answer; this is what they check it against |
| Recomputing every number (by code, not the model) | Solution sheets have slips; a student shouldn't learn a wrong answer |
| A day-by-day plan to the exam, with spacing | Planning is overhead; the plan spreads practice over the days left instead of the night before |

| The learning (student) | What Simeon does instead of doing it for them |
|---|---|
| Recalling the answer | Hides the model answer until they say they've finished |
| Writing it out in exam conditions | Times it at the paper's own mark rate, and asks for paper, not a text box |
| Judging their own answer | Shows the marking points to tick off; the student saves the score |
| Coming back to weak spots | Keeps the marks and sends them back to the topics they lost marks on |
| The mock | Timed and alone, like the real thing |

Setting up good studying is real work, and it's what stops most people starting. A student who could spend six hours
building a revision plan from a messy Canvas course usually doesn't, and crams instead. Taking that work away doesn't
take away any learning; it gets them to the learning sooner.

## 4. How the app keeps the thinking with the student

The line is in the product, not just in this page. Where it shows:

- **Test mode hides the answer.** On a past-paper question, the model answer and marking points stay hidden while a
  timer runs at the exam's pace. Revealing them takes two presses: *I have finished — reveal answer*, then a
  confirmation that says there's no un-seeing them, and that a self-mark on an unfinished answer means nothing.
- **The student marks themselves.** The marking points are a checklist they tick against what they actually wrote.
  When they ask Simeon to mark a photo of their handwriting (or a typed answer), Simeon proposes the ticks, and the
  student checks them before saving the score. The judgement is theirs.
- **"Teach me how to do it" gives hints, never the answer.** The assistant sees the model answer so its hints are
  right, but is told not to give the result, a number or a step from it, even partly, even when asked. It teaches
  the idea on a different worked example, then asks the student to try the first step, checks what they tried, and
  gives the next hint. This is the GPT Tutor design from the study above.
- **Quizzing waits for an attempt.** When Simeon is asked to quiz, it picks a question and says what to watch for,
  without the answer. In Claude or ChatGPT (Simeon's MCP server), the rule is the same: ask, wait for the student's
  answer, only then reveal and check it point by point.
- **Ask Simeon answers questions, grounded in the course.** Highlight anything and ask about it. That one is
  explanation on demand, and we don't pretend otherwise. It answers in the course's own notation, points back into the
  plan (a day, a topic, a question to practise), and won't write answers for graded work that's still open.
- **Numbers show where they came from.** Tap a figure in a model answer and Simeon shows how it was calculated and
  which numbers in the question it used, so a student can follow the working instead of taking it on trust.

## 5. What we don't claim

- **The studies are early.** Small samples, short time spans, one preprint. We read them as a warning about a
  direction, not a precise measurement.
- **Simeon still uses AI with students, not only for them.** Ask Simeon explains, and marking a photo is the AI's
  first opinion. Both are things a good study partner does, and both keep the student's own attempt first.
- **The plan is a start, not a script.** It's built from the course, checked by code, and the student can change it.
  It decides what to practise and when; it can't make anyone practise.
- **Nothing here stops a student from offloading.** They can reveal an answer without trying. Simeon makes the
  effortful path the default and the easy one, but the choice stays theirs.

## Reusing it in other software: a recipe

If you're building a learning product with AI in it:

1. **List what the learner does, and sort it.** For each step ask: does doing it build the skill being tested? If not
   (finding material, formatting, planning, checking arithmetic), automate it hard. If yes, keep it with the learner.
2. **Make the learner's attempt come first.** Hide answers by default, and make revealing them a deliberate act.
3. **Hints, not answers.** Give the model the answer so its hints are right, and tell it plainly never to reveal it.
   Teach on a different example; check the learner's step; give the next hint.
4. **Let the learner judge.** Marking against a scheme is itself practice. If the AI marks, it proposes and the learner
   confirms.
5. **Check with code what code can check.** Learners trust what they're shown. Recompute numbers outside the model.
6. **Measure without the AI.** If your product's success metric is how well people do *with* it, you'll build a
   crutch. Measure how they do when it's gone.

## Sources

- Bastani, H., Bastani, O., Sungu, A., Ge, H., Kabakcı, Ö., & Mariman, R. (2025). Generative AI without guardrails can
  harm learning: Evidence from high school mathematics. *PNAS*, 122(26). doi:10.1073/pnas.2422633122
- Kosmyna, N., et al. (2025). Your brain on ChatGPT: Accumulation of cognitive debt when using an AI assistant for
  essay writing task. arXiv:2506.08872 (preprint).
- Fan, Y., et al. (2025). Beware of metacognitive laziness: Effects of generative artificial intelligence on learning
  motivation, processes, and performance. *British Journal of Educational Technology*. doi:10.1111/bjet.13544
- Lee, H.-P., Sarkar, A., et al. (2025). The impact of generative AI on critical thinking: Self-reported reductions
  in cognitive effort and confidence effects from a survey of knowledge workers. *CHI '25*. doi:10.1145/3706598.3713778
- Roediger, H. L., & Karpicke, J. D. (2006). Test-enhanced learning: Taking memory tests improves long-term retention.
  *Psychological Science*, 17(3), 249–255.
- Slamecka, N. J., & Graf, P. (1978). The generation effect: Delineation of a phenomenon. *Journal of Experimental
  Psychology: Human Learning and Memory*, 4(6), 592–604.
- Bjork, E. L., & Bjork, R. A. (2011). Making things hard on yourself, but in a good way: Creating desirable
  difficulties to enhance learning. In *Psychology and the Real World*.
- Dunlosky, J., Rawson, K. A., Marsh, E. J., Nathan, M. J., & Willingham, D. T. (2013). Improving students' learning
  with effective learning techniques. *Psychological Science in the Public Interest*, 14(1), 4–58.
- Risko, E. F., & Gilbert, S. J. (2016). Cognitive offloading. *Trends in Cognitive Sciences*, 20(9), 676–688.

### Where to look in the code

| What | File |
|---|---|
| Test mode: the hidden answer, the timer, the two-step reveal | `src/build_app.py` (`doReveal`) |
| Teach me how to do it: hints, never the answer | `local/mac-app/Sources/AskServer.swift` (`learnNote`) |
| Quizzing without giving the answer, Ask Simeon's rules | `local/mac-app/Sources/AskServer.swift` |
| Marking a photo or a typed answer: proposed ticks, the student saves | `src/build_app.py` (`gradeTyped`), `/ask` with `kind: "grade"` |
| Simeon in Claude: ask, wait, then reveal | `local/mac-app/MCP/main.swift` |
| Every number recomputed, and its trace | `local/course_context/plancheck.py`, `local/course_context/traces.py` |