# Respecting the course

> From getsimeon.com/docs/respecting-the-course (3 November 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

A course's slides, past papers and solutions belong to the school and their authors. A student can use them for their
own revision, but that doesn't make them Simeon's to pass around, or an AI company's to learn from. So Simeon holds one
position: **each student uses their own course, on their own computer, for their own revision.** Three decisions come
from that. Before Claude or ChatGPT reads a course, Simeon waits until the student says training is off. There's a
local option, Ollama, where the course never leaves the computer. And during beta testing we removed sharing plans, even
though it was the easiest way for Simeon to spread.

---

## 1. Why we insist on training off

To build a plan, Claude Code or ChatGPT Codex reads the course and sends what it reads to its company, under the
student's own account. On personal plans, both companies may train their models on that content unless the student
turns it off. A student who agreed to that for their own chats never decided it for a lecturer's slides, and arguably it
isn't their decision to make. Once content has gone into training, there's no taking it back out.

The setting takes a minute, costs nothing and doesn't change the plan. With so little on one side and so much on the
other, we stopped treating it as a preference.

Our first version, in October 2026, was a suggestion: a note with a **Not now** button. A note like that is easy to
press past on the way to the thing you came for, and the course is already on its way by the time you think about it.
So since November the job waits. **Before Simeon reads your course** comes up before a build, an update, flashcards or a
summary, and it only ends in one of two ways: **I understand, and training is off**, or **Cancel**. **Open the setting**
goes straight to the company's page and leaves the pop-up where it is.

| Assistant | The switch | Turn it off, and |
|---|---|---|
| Claude Code | claude.ai: Settings → Privacy → Help improve Claude | Anthropic keeps chats and coding sessions for 30 days instead of up to 5 years |
| ChatGPT Codex | chatgpt.com: Settings → Data controls → Improve the model for everyone | OpenAI won't train on new conversations; how long it keeps them is under its own policy |
| Ollama | None needed | No AI company sees the course |

Three details of how it's built:

- **It's asked once per assistant.** Turning it off in Claude says nothing about ChatGPT, so switching assistants asks
  again.
- **The answer stays on the computer.** It's one local date (`trainingOffConfirmed.<assistant>`), never counted and
  never sent. Settings shows it, so a student can see what they said.
- **The paths get checked by hand.** The companies move these settings, so the two paths and links are checked against
  the live sites before a release.

**What it can't do.** Simeon can't see the setting, so "training is off" is the student's word. We could only make it
a real lock if we could read their account, and we don't want to. And turning training off isn't the same as nothing
leaving the computer: the course still goes to the company to do the work, and it's kept there for a while under their
terms. For anyone who wants more than that, there's section 2.

## 2. Why there's a local option

Some students won't want a course on a company's servers, whatever the setting says. Some schools' rules may not allow
it. And some students don't pay for an AI subscription at all. Ollama answers all three: the model runs on the student's
own computer, free, with no account.

The promise is simple to say and took some care to keep. Simeon runs Codex against a local model, and we found that a
Codex signed in to ChatGPT still talks to chatgpt.com, even when its model is local: we saw 8 to 10 connections a
question. So Simeon gives Codex its own folder when it runs on Ollama (`CODEX_HOME`), one that has never been signed in,
and then it talks only to Ollama on the same computer. If you make the same promise in your own software, watch the
network to check it.

It's offered, not pushed, because it costs something, and we say so:

- **Plans are slower and rougher** than with Claude or ChatGPT, so those stay first in the list.
- **Good plans need 16 GB of memory.** With less, Simeon uses a small model that suits Ask Simeon better than building.
- **Models must fit.** Only a model that fits in the computer's memory, less 3 GB, is offered or run. A 9.6 GB model
  froze an 8 GB Mac, so we stopped allowing it.
- **Marking a photo** needs a model that can see pictures.

The local option is also why training off can be a firm rule. A student who won't or can't turn it off, or who'd rather
nothing left at all, still has a way to use Simeon.

## 3. Why we removed sharing plans

Simeon used to turn a plan into a file a friend could open and add to their own copy. One plan for a
course is useful to everyone on that course, and it was our best idea for how Simeon would spread through a class.

We took it out during beta testing, in v2026.10.26. A plan holds the course's questions, model answers and marking
points. On a student's own computer, for their own revision, that's private study. Sent to the next person, it's
distribution, and a button in the app would have made Simeon the thing doing it. No wording or limit on the file changes
that, so we removed the feature instead of adding terms to it.

- **What went:** the share file, **Add a friend's plan**, and the page a shared copy opened on, in both apps and on the
  study page, along with the two counts that went with them. The app's `/import` now answers `410 Gone`.
- **What came instead:** **Tell a friend about Simeon**, which sends only getsimeon.com. The friend builds their own
  plan from their own course, with their own dates.
- **What stayed:** a plan already added from a friend, since removing it would lose someone's progress. They can delete
  it themselves. And a student's own plan still reaches their own iPad and phone, encrypted, because that isn't sharing.

It also made the app simpler to secure. A plan from someone else is untrusted input to a page that can talk to the
app, and every string in it had to be cleaned. With sharing gone, a plan from a stranger has no way in. (A plan restored
from a recovery code still goes through the same cleaning.)

The cost is real. A friend now has to install Simeon and build a plan, where before they could open a file, and study
groups can't work from one copy. We think that's the right trade.

## 4. What we don't claim

- **This isn't legal advice, or a promise that any use is allowed.** We think each student revising from their own course is
  private study, in the places we know best: the UK, Sweden and the Netherlands. Schools set their own rules on course
  material and AI, and some may not allow sending it to an AI service at all. Simeon tells students to check. It can't
  check for them.
- **It isn't anonymity.** Simeon also takes out the names it can before an AI reads the course, but a scanned page still
  shows what's printed on it. We say "keeps names out of what it can", never "anonymous".
- **We rely on the companies' word.** Training off is a setting on someone else's service, under terms they can change.
  Giving feedback in those products can also send a whole conversation for training.
- **A student can still lie to the button, or copy their files.** We've made the respectful path the default, and the only
  one built in. We can't make it the only one possible.

## Reusing it in other software: a recipe

If your product hands someone else's material to an AI:

1. **Work out whose material it is**, and write down the one sentence you'll hold to. Every decision here came from ours.
2. **Check what's on by default on the user's account.** If their chats can train a model, your product is what puts
   the material there.
3. **Make the job wait.** Say it before the first job, link straight to the setting, and don't start until they answer.
   Keep the answer on their computer.
4. **Offer a way that sends nothing**, and be plain about what it costs. That's what makes a firm rule fair.
5. **Watch the network** before you promise that nothing leaves.
6. **Don't build the feature that turns private use into distribution**, however well it would spread your product.
   Send people to your product instead of to the material.

## Sources

- Anthropic, [Updates to our consumer terms](https://www.anthropic.com/news/updates-to-our-consumer-terms) and
  [Claude Code: data usage](https://docs.anthropic.com/en/docs/claude-code/data-usage). Checked 3 November 2026.
- OpenAI, [How your data is used to improve model performance](https://help.openai.com/en/articles/5722486-how-your-data-is-used-to-improve-model-performance).
  Checked 3 November 2026.

### Where to look in the code

| What | File |
|---|---|
| The pop-up, and the job waiting on it | `local/mac-app/Sources/AITerms.swift`; `aiTermsSheet` in `desktop/` |
| Where the switch is, and the student's answer | `local/mac-app/Sources/Training.swift` |
| Ollama: Codex never signed in, and which models fit | `local/mac-app/Sources/Assistant.swift` (`ollamaCodexHome`, `ollamaBudget`); `desktop/src-tauri/src/assistant.rs` |
| `/import` answering 410 | `local/mac-app/Sources/AskServer.swift` |
| Cleaning a recovered plan | `src/import_plan.py` (`clean_plan`) |
| Tell a friend | `shareSimeon` and `dashShare` in `src/build_app.py`; `Links.shareSimeon` in the Mac app |