Skip to content
Back to search

learning-curve

MarketplaceWorks with Claude CodeGitHub

Structured STEM tutor for pi and Claude Code: assessments, study plans, lessons by subject kind, verified math and code, quizzes with gap reinforcement, spaced repetition — saved to Obsidian.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lelpoco2--learning-curve/badge.svg)](/listings/lelpoco2--learning-curve)

HTML

<a href="/listings/lelpoco2--learning-curve"><img src="/api/listings/lelpoco2--learning-curve/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**pi**

pi install git:github.com/Lelpoco2/learning-curve      # or: pi install ./path/to/learning-curve

**Claude Code**

/plugin install learning-curve --marketplace Lelpoco2/learning-curve

(or `/plugin marketplace add Lelpoco2/learning-curve`, then `/plugin install learning-curve@learning-curve`).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 11 lines
  1. {
  2. "name": "learning-curve",
  3. "owner": { "name": "Lelpoco2" },
  4. "plugins": [
  5. {
  6. "name": "learning-curve",
  7. "source": "./",
  8. "description": "Structured STEM tutor that keeps everything in your Obsidian vault."
  9. }
  10. ]
  11. }
README.md · README · 436 lines
  1. <p align="center">
  2. <picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.png">
  4. <img src="assets/logo.png" alt="Learning Curve logo" width="360">
  5. </picture>
  6. </p>
  7. # Learning Curve
  8. A [pi](https://pi.dev) package and [Claude Code](https://code.claude.com) plugin that turns the agent into a structured **STEM tutor**.
  9. It learns what you know and how you understand, presents a study plan sorted by
  10. difficulty, teaches intuition first (why → when → what), verifies every calculation with
  11. SymPy, checks understanding with quizzes that ask for your reasoning, turns every wrong
  12. answer into a reinforcement note and a retest, and keeps everything alive with spaced
  13. repetition. All notes are written to your note-taking app — Obsidian by default — with
  14. LaTeX math.
  15. The package is **dormant** in normal sessions. It becomes a tutor only when the agent runs
  16. inside a *learning workspace* (a vault containing `.learning-curve/`). The same vault works with
  17. both agents: notes, progress, gaps and flashcards are shared.
  18. ## Contents
  19. - [Requirements](#requirements)
  20. - [Install](#install)
  21. - [Setup and first steps](#setup-and-first-steps)
  22. - [With pi](#with-pi)
  23. - [With Claude Code](#with-claude-code)
  24. - [A typical study session](#a-typical-study-session)
  25. - [Claude Code](#claude-code)
  26. - [Commands](#commands)
  27. - [How it teaches](#how-it-teaches)
  28. - [Lesson kinds](#lesson-kinds)
  29. - [Tools of the tutor](#tools-of-the-tutor)
  30. - [Technologies](#technologies)
  31. - [Math in the terminal (pi)](#math-in-the-terminal-pi)
  32. - [Obsidian formatting](#obsidian-formatting)
  33. - [Fact checking](#fact-checking)
  34. - [Subjects and shared topics](#subjects-and-shared-topics)
  35. - [Vault layout](#vault-layout)
  36. - [Recommended Obsidian plugins](#recommended-obsidian-plugins)
  37. - [Configuration](#configuration)
  38. - [TODO](#todo)
  39. - [Development](#development)
  40. - [Contributing](#contributing)
  41. - [License](#license)
  42. ## Requirements
  43. | What | Needed for |
  44. |---|---|
  45. | [pi](https://pi.dev) ≥ 1.5 **or** [Claude Code](https://code.claude.com) ≥ 2.1.275 | the agent that runs the tutor |
  46. | [Node.js](https://nodejs.org) ≥ 22.18 | Claude Code runs the plugin's tool server and hooks with Node (pi already includes it) |
  47. | [Obsidian](https://obsidian.md) (recommended) or any Markdown note app | reading your notes; the tutor writes them |
  48. | [uv](https://docs.astral.sh/uv/) (optional) | creating the Python environment for SymPy, plots and Manim |
  49. | winget (optional, Windows) | installing MiKTeX for formulas inside Manim videos, and programming toolchains when you ask |
  50. ## Install
  51. **pi**
  52. ```bash
  53. pi install git:github.com/Lelpoco2/learning-curve # or: pi install ./path/to/learning-curve
  54. ```
  55. **Claude Code**
  56. ```
  57. /plugin install learning-curve --marketplace Lelpoco2/learning-curve
  58. ```
  59. (or `/plugin marketplace add Lelpoco2/learning-curve`, then `/plugin install learning-curve@learning-curve`).
  60. ## Setup and first steps
  61. ### With pi
  62. 1. Open pi anywhere and run **`/learn-setup`**. It asks, one step at a time:
  63. - note app (Obsidian recommended; Logseq, Zettlr, Joplin, plain Markdown or any other —
  64. the tutor learns how to use it);
  65. - vault folder;
  66. - notes language;
  67. - flashcards (a Flashcards note per topic, Obsidian Spaced Repetition plugin);
  68. - Obsidian plugins (checklist, recommended ones preselected);
  69. - Python tools (SymPy, NumPy, SciPy, matplotlib, Manim, pypdf) and optionally MiKTeX.
  70. 2. Start pi **inside the vault** folder. The tutor proposes the learning-style interview
  71. (`/style`, 5–10 minutes): it decides how lessons explain things to you.
  72. 3. Choose what to study:
  73. - a whole course: `/new-subject Calculus 1` → goal interview → broad assessment → syllabus
  74. of topics and lesson kind (math, physics, cs, programming…) → you approve it;
  75. - a single topic: `/learn Derivatives` → knowledge assessment → study plan → you approve it.
  76. 4. Then `/lesson` for each lesson. Put your textbooks and lecture notes in `Sources/`: the
  77. tutor checks facts there first.
  78. ### With Claude Code
  79. 1. Open Claude Code in the folder that will be (or already is) your vault and run
  80. **`/learning-curve:learn-setup`**. Claude asks the same questions and creates the workspace
  81. (`workspace_setup` tool).
  82. 2. From then on, start Claude Code in that folder: the tutor persona and your progress are loaded
  83. automatically at session start.
  84. 3. Same flow as pi, with the plugin prefix: `/learning-curve:style`, `/learning-curve:new-subject
  85. Calculus 1`, `/learning-curve:learn Derivatives`, `/learning-curve:lesson`…
  86. An existing vault created with pi works in Claude Code as it is, and vice versa.
  87. In Obsidian: Settings → Community plugins → turn off *Restricted mode*, then reload the vault so
  88. the installed plugins load.
  89. ### A typical study session
  90. ```
  91. /learn → resume the active topic (or the next one of the subject)
  92. /review → (if due) 5–10 minutes of spaced-repetition questions
  93. /lesson → the next lesson: a short guided walk in chat, the full note in Obsidian,
  94. 1–2 guided check questions
  95. "I don't get §2.3" → the tutor rewrites that section of the note in place
  96. /quiz → checkpoint at the end of a block; every wrong answer → reinforcement note → retest
  97. /progress → where you are: lessons done, gaps, reviews due
  98. ```
  99. ## Claude Code
  100. Everything works the same way, with these differences:
  101. | | pi | Claude Code |
  102. |---|---|---|
  103. | Setup | `/learn-setup` wizard | `/learning-curve:learn-setup`: Claude asks the same questions, then runs `workspace_setup` |
  104. | Commands | `/learn`, `/quiz`… | `/learning-curve:learn`, `/learning-curve:quiz`… (also without the prefix when no other plugin uses the name) |
  105. | Quiz dialogs | pi dialogs with review screen | Forms at the bottom of the screen (MCP elicitation): answer field, "why?" field, option lists, review screen. A form shows only the first lines of a question, so the tutor writes the questions in chat first |
  106. | Math in chat | rendered in the terminal (Unicode, full-size exponents) | terminal: the tutor writes Unicode (x², √x); VS Code extension: LaTeX rendered by KaTeX; desktop app: LaTeX between `$$` |
  107. | Note check after writing | automatic | automatic (PostToolUse hook) |
  108. | Status line | built in | optional, see below |
  109. Optional status line (`~/.claude/settings.json`, adjust the path to where Claude Code installed the plugin, or
  110. point it to your clone):
  111. ```json
  112. { "statusLine": { "type": "command", "command": "node /path/to/learning-curve/claude/run.mjs statusline" } }
  113. ```
  114. Outside a learning workspace the plugin adds nothing to the conversation (no persona, no context);
  115. its commands and skills stay available.
  116. ## Commands
  117. In Claude Code every command has the `learning-curve:` prefix (`/learning-curve:learn`).
  118. | Command | What it does | Example |
  119. |---|---|---|
  120. | `/learn-setup` | Create or reconfigure a learning workspace | `/learn-setup` |
  121. | `/learn-plugins` | Manage Obsidian plugins anytime: install from the recommended list or search all community plugins, update, disable, remove | `/learn-plugins` |
  122. | `/new-subject <name>` | Start a whole subject/course: goal interview (optionally your official syllabus), broad assessment, lesson kind, ordered syllabus of topics reusing topics you already have, optional final exam | `/new-subject Fisica 1` |
  123. | `/learn [topic]` | Start or resume a topic — without arguments, continue the active subject with its next topic: assessment → plan → lessons → checkpoints → test | `/learn Integrali` |
  124. | `/lesson [n]` | Next lesson (or lesson n) | `/lesson`, `/lesson 3` |
  125. | `/quiz [scope]` | Quiz on the current lesson/block (first 1–2 questions guided) | `/quiz block 1` |
  126. | `/exercises [scope]` | Practice set with folded hints and solutions | `/exercises limits` |
  127. | `/test [block\|topic]` | Block or topic test | `/test topic` |
  128. | `/exam [subject]` | Final exam of a subject (all topics, questions that connect them) | `/exam Analisi 1` |
  129. | `/grade <note>` | Grade answers you wrote directly in a quiz/exercise note | `/grade Quizzes/Quiz - L03 - 1` |
  130. | `/reformulate <note or concept>` | Rewrite in place a section you did not understand | `/reformulate the factor theorem` |
  131. | `/remember [concept or formula]` | Tips to remember it by reasoning (rebuild it, check it); the ones you like are added to the lesson | `/remember derivative of tan x` |
  132. | `/review` | Today's spaced-repetition reviews | `/review` |
  133. | `/style` | Learning-style interview | `/style` |
  134. | `/progress` | Progress, open gaps, due reviews; refreshes the Dashboard | `/progress` |
  135. | `/check-notes [path]` | Check notes (one, a folder, or the whole vault) for Obsidian formatting problems and optionally let the tutor fix them | `/check-notes Analisi 1` |
  136. You can also just talk: "I don't get the second step of the dot product note" triggers a
  137. reformulation; "let's practise" proposes exercises; "give me a trick for the chain rule" gives
  138. memory aids.
  139. ## How it teaches
  140. - **Assessment first** — an adaptive interview and diagnostic quiz (with "why?"
  141. follow-ups) for the topic and its prerequisites.
  142. - **Study plan** — blocks and lessons sorted by increasing difficulty; big topics are
  143. split; you approve before the first lesson.
  144. - **Lessons** — organised by concept, in numbered sections (`1.`, `1.1`, …) whose titles
  145. say what you are reading ("Why factor", "Factoring methods", "Worked example", "Recap").
  146. The lesson opens with a real problem and when you need the idea; then each concept goes
  147. intuition → its formal, official statement in a blue box (definition, theorem, property,
  148. identity or algorithm, with hypotheses and a source) → folded proof → example → the trap
  149. right next to it. Then a worked example, check questions with folded answers, and a recap
  150. (key ideas + how to remember them). Boxes have one meaning each, headings are followed by a
  151. blank line, and the note checker reports numbering gaps.
  152. - **Remembering by reasoning** — every lesson recap has a *How to remember it* part with 2–4
  153. verified tips: rebuild the result in 30 seconds, sanity checks (units, limit cases,
  154. symmetry, special values), patterns, visual anchors, links to known results; mnemonics
  155. only for pure conventions. Reviews offer the trick when you forget, reinforcement notes
  156. aim a tip at the exact mistake, flashcards train the tricks, and the tips that work for
  157. you are learned over time.
  158. - **Your style** — the learning-style interview plus observations during lessons decide
  159. between pictures, analogies, numbers-first or derivation-first explanations.
  160. - **Verification** — every computed result is checked with `math_check` (SymPy), and
  161. factual claims are checked with `source_lookup` (see *Fact checking*).
  162. - **Quizzes** — guided questions first, then independent; the reasoning is graded, not
  163. only the result. Before submitting, a **review screen** lists every answer: reopen any
  164. question to change the answer or the "why" (pre-filled; Esc keeps it). The tutor sees
  165. which answers changed and the first answer, and uses it in the feedback. Pass = score ≥ 80 % **and** no open gaps: every wrong or badly reasoned
  166. answer opens a gap → reinforcement note → targeted retest.
  167. - **Spaced repetition** — SM-2 scheduling of every quizzed concept; `/review` asks fresh
  168. reasoning questions. Flashcards (one `Flashcards.md` per topic: a numbered section per lesson, one heading per card, question / `?` / answer) can also be reviewed inside Obsidian with the Spaced Repetition plugin.
  169. - **Visuals** — Manim animations, matplotlib plots, Desmos graphs, TikZ diagrams, Mermaid.
  170. ## Lesson kinds
  171. Each subject has a **lesson kind**: the template its lessons follow. The tutor proposes one when
  172. a subject starts (`/new-subject`) and you confirm; a single topic can use a different one (e.g. a
  173. programming topic inside a math course).
  174. | Kind | Sections | Checked with |
  175. |---|---|---|
  176. | `math` | why → concept groups (intuition → definition/theorem → proof → example → trap) → worked example → check → recap | SymPy |
  177. | `physics` | phenomenon → model (assumptions, quantities and units) → laws (with validity conditions) → solving problems → limits of the model | SymPy units, CODATA, orders of magnitude |
  178. | `cs` | problem → definitions → algorithm (idea, pseudocode, trace) → correctness (invariant) → cost → tested implementation | `code_run`, recurrences in SymPy |
  179. | `programming` | the task → core concepts (runnable example, real output, official syntax/API, common error) → build it step by step → debugging → exercises with tests → good practices → cheat sheet | `code_run` on every snippet |
  180. | `generic` | any other subject | sources |
  181. **Programming languages**: you choose the language (and version); the tutor writes every example,
  182. exercise and quiz in it. `code_run` runs Python, JavaScript, TypeScript, SQL (SQLite), Bash,
  183. PowerShell, C, C++, Java, Go, Rust, C#, Ruby, PHP, R, Julia, Lua, Perl, Haskell and Kotlin, and any
  184. other language through a custom command. When a toolchain is missing the tutor shows how to
  185. install it (winget / brew / apt) and installs it only if you agree.
  186. **Custom kinds**: for subjects that fit none (history, languages, a lab course…) the tutor drafts a
  187. template with you and saves it in `.learning-curve/templates/lesson-<kind>.md`; a file named like a
  188. built-in kind (`lesson-physics.md`) overrides it for this vault.
  189. ## Tools of the tutor
  190. The agent uses these tools (in Claude Code they come from the plugin's MCP server):
  191. | Tool | Function |
  192. |---|---|
  193. | `learning_state` | Subjects, syllabus, topics, assessments, study plans, lesson status, lesson kinds, canonical note paths, progress |
  194. | `quiz_ask` | Interactive questions (multiple choice, numeric, short, open, proof), guided hints, "why?", review before submitting |
  195. | `quiz_record` | Grades an attempt: score, pass/fail, opens a gap for every wrong or badly reasoned answer, schedules reviews |
  196. | `learner_profile` | Knowledge level per concept and observations of what explanations work for you |
  197. | `review_queue` | Spaced-repetition queue (SM-2): due items, outcomes, rescheduling |
  198. | `math_check` | Runs SymPy/NumPy/SciPy scripts to verify every computation before it is written or graded |
  199. | `code_run` | Runs code in the language you chose (20 built-in languages + custom commands); checks and suggests toolchains |
  200. | `source_lookup` | Fact checking in your `Sources/` and in reference sources (see *Fact checking*) |
  201. | `plot_render` / `manim_render` | Matplotlib figures and Manim animations saved in the lesson's `media/` folder |
  202. | `note_check` | Obsidian formatting check of a note, a folder or the vault (also automatic after every write) |
  203. | `tutor_context`, `workspace_setup`, `obsidian_plugins` | Claude Code only: what pi does with its wizards |
  204. ## Technologies
  205. | Technology | Function in Learning Curve |
  206. |---|---|
  207. | **pi** (extension API, TUI) | Host agent: tools, commands, dialogs, system prompt, terminal math rendering |
  208. | **Claude Code** (plugins, MCP, hooks, elicitation) | Second host: tool server over MCP (stdio), SessionStart/PostToolUse hooks, quiz forms |
  209. | **TypeScript on Node.js** (type stripping, no build step, no runtime dependencies) | All the plugin code; one platform-neutral core shared by both hosts |
  210. | **Obsidian** + Markdown, YAML properties, callouts, wikilinks | Where the notes live; Dataview queries, folder notes, flashcards |
  211. | **LaTeX** (MathJax in Obsidian, KaTeX in Claude Code's VS Code extension, Unicode in terminals) | All math in notes and chat; vault macros in `preamble.sty` |
  212. | **Python** in a workspace venv created with **uv** | Runs the verification and drawing tools |
  213. | **SymPy, NumPy, SciPy** | `math_check`: exact and numeric verification of results, derivations, units |
  214. | **matplotlib**, **Manim** (+ MiKTeX for formulas in videos) | Plots and animations embedded in lessons |
  215. | **pypdf** | Reads your PDF textbooks for fact checking, with page citations |
  216. | **NIST CODATA, NIST DLMF, OEIS, Encyclopedia of Mathematics, Wikipedia, nLab, arXiv, Crossref** | Reference sources for facts, constants, formulas, papers |
  217. | **SM-2** (spaced-repetition algorithm) | Schedules reviews of every quizzed concept |
  218. | **Obsidian plugins** (Spaced Repetition, Dataview, Latex Suite, Extended MathJax, TikZJax, Desmos, Excalidraw…) | Flashcard review, dashboards, faster LaTeX, diagrams and graphs inside Obsidian |
  219. | **Mermaid** | Topic maps of a subject (built into Obsidian) |
  220. | Language toolchains (Python, Node.js, GCC, JDK, Go, Rust, .NET…) | `code_run` for programming and computer-science lessons |
  221. ## Math in the terminal (pi)
  222. pi renders `$…$` and `$$…$$` in chat as Unicode: stacked fractions, limits under `lim`/`∑`,
  223. integral bounds, matrices, aligned equations (`√(x²+1) ≤ x+1, x ∈ ℝ`). The plugin adds:
  224. - **Vault macros**: formulas using `preamble.sty` macros (`\vb`, `\R`, `\dd`, `\abs`, `\norm`,
  225. `\pdv`, … and any `\newcommand` you add) are expanded just before display, so they render
  226. too. Display-only: notes and what the model sees are unchanged.
  227. - **Full-size exponents**: `2^3 · 2^4`, `x^(n+1)` instead of pi's small Unicode superscripts
  228. (`2³`), in chat and in quiz dialogs; fraction layouts stay aligned. Set `mathExponents` to
  229. `"superscript"` to get pi's default back.
  230. - **Quiz dialogs**: math in questions, options and hints is shown rendered; the tutor still
  231. receives the original LaTeX of the chosen option.
  232. In Claude Code, chat math depends on the client (see *Claude Code*).
  233. Formulas that use something the terminal renderer cannot draw (or that are wider than the
  234. terminal) are shown as LaTeX source.
  235. ## Obsidian formatting
  236. Parts the plugin generates (properties, Dashboard, syllabus and lesson tables, links,
  237. embeds, tags, Mermaid maps) are written by code. Notes the tutor writes follow the
  238. `notes-obsidian` rules and templates, and **every write or edit is checked
  239. automatically**; the tutor fixes reported errors immediately. The checker covers:
  240. - YAML properties: closed frontmatter, `key: value` syntax, quotes and lists, values with
  241. `: ` or `#`, wikilinks in properties, duplicates, required properties per note type,
  242. unfilled `{{placeholders}}`;
  243. - math: unbalanced `$`/`$$`, `\(…\)`/`\[…\]`, spaces inside `$ … $`;
  244. - callouts: lines missing the `>` prefix (fatal for `$$` blocks), unknown types;
  245. - tables: unescaped wikilink pipes;
  246. - links: embeds of missing files (error), links to notes that do not exist yet (warning),
  247. relative `../` links;
  248. - footnotes without definition, unclosed code blocks, more than one `#` title, broken
  249. generated sections.
  250. Code blocks, inline code and `%% comments %%` are ignored. Run `/check-notes` anytime
  251. (e.g. after editing notes by hand).
  252. ## Fact checking
  253. Statements that are not computed — exact theorem statements and **hypotheses**,
  254. definitions and conventions, physical constants, data, names, dates, history — are
  255. checked with `source_lookup` before they go into a note, in this order:
  256. 1. **Your sources**: put textbooks, lecture notes and syllabi (PDF with a text layer,
  257. Markdown, text) in the vault folder `Sources/` (subfolders per subject are fine).
  258. PDFs are read once (pypdf) and cited with a link to the exact page,
  259. e.g. `[[Sources/Analisi 1/Book.pdf#page=212|Book, p. 212]]`. Your book's convention wins.
  260. 2. **Official references**: NIST CODATA (physical constants), NIST DLMF (special
  261. functions, identities — formulas come back as LaTeX with their hypotheses), OEIS.
  262. 3. **Reference encyclopedias**: Encyclopedia of Mathematics, Wikipedia (any language),
  263. nLab.
  264. 4. **Literature**: arXiv, Crossref (DOIs); any specific URL.
  265. Checked statements get footnotes and a **Sources** section in the note (plus a
  266. `sources:` property); anything that cannot be confirmed is marked with a
  267. `[!warning] Not verified` callout. Lookups are cached in the workspace. ProofWiki is not
  268. used: it blocks automated access.
  269. ## Subjects and shared topics
  270. A **subject** is a course with an ordered syllabus of topics. Every topic lives in **one**
  271. home subject folder; other subjects that need it **link** it instead of copying it
  272. (e.g. *Derivatives* lives in *Calculus 1* and is linked by *Physics 1*). When a subject
  273. needs a known topic from a different angle, the tutor adds a short **bridge topic**
  274. (e.g. *Vectors in physics*) that builds on the original. The subject index note shows
  275. the syllabus (↗ marks shared topics), a Mermaid topic map and the final-exam status;
  276. notes carry `subjects: [...]` so Dataview finds shared topics from every subject.
  277. ## Vault layout
  278. ```
  279. <Vault>/
  280. ├── .learning-curve/ config, state, Python venv, Manim sources (hidden in Obsidian)
  281. ├── 00 Learner/ Profile, Learning Style, Dashboard
  282. ├── Sources/ your textbooks, lecture notes, syllabi (fact-checking sources)
  283. ├── preamble.sty shared LaTeX macros (Extended MathJax)
  284. └── <Subject>/
  285. ├── <Subject>.md subject index: syllabus, topic map, final exam
  286. ├── Exams/ final exams
  287. └── NN - <Topic>/ home of the topic, numbered in syllabus order (other subjects link it)
  288. ├── NN - <Topic>.md topic index (folder note)
  289. ├── Study Plan.md
  290. ├── Flashcards.md flashcards of the topic, one section per lesson (if enabled)
  291. ├── Lessons/NN - Title/ lesson note, reinforcement notes, media/
  292. └── Quizzes/ Tests/ Exercises/
  293. ```
  294. Topic folders are numbered like lessons (`01 - Richiami di algebra`, `02 - Insiemi e
  295. funzioni`, …) so Obsidian shows them in syllabus order. When the syllabus changes, folders
  296. are renumbered and every link in your notes is updated. Vaults created before 0.9 are asked
  297. once at startup; to opt out later set `"numberTopicFolders": false` in
  298. `.learning-curve/config.json`.
  299. ## Recommended Obsidian plugins
  300. Chosen from the official community-plugin download statistics, filtered for quality of
  301. life, LaTeX, graphs and math. Preselected: Latex Suite, Extended MathJax, TikZJax, Desmos,
  302. Excalidraw, Spaced Repetition, Dataview, Folder notes, Omnisearch, Homepage, Advanced
  303. Tables. Optional: Charts, Media Extended, Execute Code, Templater, Git, Style Settings,
  304. Iconize. MathJax, callouts, Mermaid and video embeds are built into Obsidian.
  305. Add more later with **`/learn-plugins`**: it installs from the recommended list or from
  306. the whole Obsidian community catalog (searched by name, id or keywords, most downloaded
  307. first), updates, disables (keeping settings) or removes plugins. The tutor only uses
  308. plugin-specific blocks (Desmos, TikZ, Dataview, charts, flashcards) for plugins that are
  309. enabled; plugins installed from Obsidian's own browser are detected too. Reload Obsidian
  310. after changes.
  311. ## Configuration
  312. `.learning-curve/config.json` in the vault:
  313. | Key | Default | Meaning |
  314. |---|---|---|
  315. | `notesLanguage` | from setup | Language of the notes (chat follows your language) |
  316. | `passThreshold` | `0.8` | Minimum quiz/test score |
  317. | `flashcards` | from setup | Flashcards note per topic (Spaced Repetition plugin) |
  318. | `mathExponents` | `"caret"` | Exponents in the terminal: `"caret"` shows them full size (`2^3`, `x^(n+1)`); `"superscript"` keeps pi's small Unicode (`2³`) |
  319. | `learnerFolder` | `00 Learner` | Folder of profile notes |
  320. | `python` | from setup | Interpreter and detected capabilities (SymPy, matplotlib, Manim, LaTeX) |
  321. Recommended model: a strong reasoning model with high thinking (e.g. Claude Opus, high).
  322. ## TODO
  323. Ideas and known gaps for future development:
  324. - [ ] **Tablet whiteboard** (`/tablet`): a page served on the local Wi-Fi where you write with an
  325. Apple Pencil or upload screenshots; each step is sent to the tutor, which sees the whole
  326. resolution process (designed, postponed).
  327. - [ ] **More built-in lesson kinds**: chemistry (reactions, balancing, safety), humanities
  328. (sources, timelines, arguments), foreign languages (vocabulary, grammar, dialogues).
  329. - [ ] **Topic folder numbering in Claude Code** for vaults created before 0.9: pi asks once at
  330. start-up; Claude Code only applies it when already enabled.
  331. - [ ] **Continuous integration**: tests and typecheck on GitHub Actions (Windows, macOS, Linux).
  332. Development and live tests so far ran on Windows.
  333. - [ ] **Screenshots / short demo** in this README (lesson note, quiz form, dashboard).
  334. - [ ] **Listings**: publish in the pi package gallery and submit to Claude Code plugin marketplaces.
  335. - [ ] **Source adapters**: arXiv and the Encyclopedia of Mathematics failed during tests (no
  336. response, HTTP 502); add retries and fallbacks.
  337. - [ ] **Claude Code quiz forms**: a form shows only the first lines of a question (the tutor
  338. writes questions in chat first); revisit if Claude Code adds multi-line form messages.
  339. ## Development
  340. ```bash
  341. npm install # type definitions for development only (no runtime dependencies)
  342. npm test # node --test: core logic, tools, MCP protocol, hooks, templates
  343. npm run typecheck
  344. pi -e ./extensions/index.ts # try it in pi without installing (run inside a workspace)
  345. claude --plugin-dir . # try it in Claude Code without installing (run inside a workspace)
  346. claude plugin validate . # check the Claude Code plugin manifest, commands and skills
  347. ```
  348. The repository has no lockfile on purpose: Claude Code runs `npm ci` when a plugin ships one.
  349. See [docs/DESIGN.md](docs/DESIGN.md) for the architecture and [CHANGELOG.md](CHANGELOG.md) for
  350. the history.
  351. ## Contributing
  352. Contributions are welcome: bug reports, ideas, teaching material (skills, templates, lesson
  353. kinds) and code. Read the [contribution guidelines](CONTRIBUTING.md) and the
  354. [Code of Conduct](CODE_OF_CONDUCT.md); report security problems privately as described in the
  355. [security policy](SECURITY.md).
  356. ## License
  357. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.