Skip to content
Back to search

PAIDEIA

Paideia — a Claude Code plugin that forms exam readiness locally. Stop renting your own learning.

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/optimeta--paideia/badge.svg)](/listings/optimeta--paideia)

HTML

<a href="/listings/optimeta--paideia"><img src="/api/listings/optimeta--paideia/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

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

Prerequisites

**Required (both install paths)**

- Python 3.9+ (the plugin checks + offers to install its deps) - A Unix-style shell (`bash` / `zsh`). The bootstrap + grade commands use heredocs, `mkdir -p`, `mktemp`, and subshell backgrounding — native Windows `cmd` / PowerShell isn't currently supported. - **macOS**: `brew install poppler tesseract tesseract-lang` - **Linux (Debian/Ubuntu)**: `apt-get install poppler-utils tesseract-ocr tesseract-ocr-kor` - **Windows**: use [WSL2](https://learn.microsoft.com/windows/wsl/install), then follow the Linux path inside the WSL shell. Git Bash works too if `poppler` and `tesseract` are on `PATH`.

**Optional — only if you want the `--ocr=ollama` mode (every page image stays on your machine)**

- `ollama` + the `qwen3-vl:8b` model (~6 GB). macOS: `brew install ollama`. Linux: see the [ollama install script](https://ollama.com/install.sh). Then `ollama pull qwen3-vl:8b`.

If you don't install Ollama, Paideia's default OCR engine is Claude's own vision — nothing extra to install, nothing extra to subscribe to beyond Claude Code itself.

Install via the Claude desktop app (recommended)

The desktop app is the smoothest reading surface for Paideia — `summary.md`, `patterns.md`, `coverage.md`, and `/paideia:hwmap` tables render inline as the agent emits them (see the screenshot grid above), so there's no separate reader to keep open.

1. Download Claude Desktop from [claude.ai/download](https://claude.ai/download) and sign in. Available for macOS, Windows, and Linux. 2. Open any new conversation and run each line as its own message:

   /plugin marketplace add https://github.com/OPTIMETA/PAIDEIA.git
   /plugin install paideia@paideia-marketplace

3. The 18 `/paideia:` slash commands are now available in every conversation. Continue to **Per-course bootstrap** below.

Install via the Claude Code CLI

If you prefer the terminal, install [Claude Code](https://claude.ai/claude-code) first, then run the same two commands inside `claude`, each as a separate line:

/plugin marketplace add https://github.com/OPTIMETA/PAIDEIA.git
/plugin install paideia@paideia-marketplace

> The full `https://...` URL is deliberate — the `owner/repo` shorthand makes the CLI try SSH first, which fails if you don't have a GitHub SSH key registered. HTTPS always works.

After install, 18 slash commands become available under the `/paideia:` namespace. CLI users should also set up [Obsidian as a reading companion](#a-reading-tip-use-obsidian) — the terminal can't render math.

Per-course bootstrap

Open Claude Code inside the folder you want to use for this course, then run:

/paideia:init-course

This interactively: 1. Checks Python / poppler / tesseract deps and offers to install missing ones (ollama is only probed when you pick the `ollama` engine in step 4) 2. Asks which interface language you want for this course — `en` (default) or `ko`. All subsequent paideia prompts, drill instructions, and generated MD narrative in this folder will follow that choice. Structural tokens (file paths, slash command names, pattern IDs `P1, P2, …`, YAML keys, tier markers) stay in English regardless 3. Asks for `COURSE_NAME`, `EXAM_DATE`, `EXAM_TYPE`, `USER_WEAK_ZONES` 4. Asks which OCR engine you want as the default: `claude` (native vision, no install), `ollama` (local Qwen3-VL, pulls the 6 GB model in the background), or `tesseract` (lightest, lowest fidelity) 5. Creates the directory skeleton (`materials/`, `converted/`, `course-index/`, `quizzes/`, `mock/`, `twins/`, `chain/`, `derivations/`, `cheatsheet/`, `weakmap/`, `answers/converted/`, `errors/`) 6. Writes `.course-meta` (carries `INTERFACE_LANG` + `OCR_ENGINE`, read by `/paideia:grade`, `session_start.py`, `vision_ocr.py`, and every slash command) and a project-level `CLAUDE.md`

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 · 16 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "paideia-marketplace",
  3. "owner": {
  4. "name": "TaewoooPark",
  5. "url": "https://github.com/TaewoooPark"
  6. },
  7. "plugins": [
  8. {
  9. "name": "paideia",
  10. "source": "./plugins/paideia",
  11. "description": "Exam-prep workspace for math/physics courses — 18 commands + 6 skills. Every course PDF routes through a parallel vision pipeline (faithful LaTeX, no pdfplumber word-salad). Hand-writing OCR is selectable per course: Claude native vision (default), local Qwen3-VL via Ollama, or Tesseract. Ships a per-course statusline (paideia · COURSE · D-N · phase · Pk ↑) auto-wired by init-course, /paideia:doctor for one-shot install + workspace diagnostics with permission-free --fix, and /paideia:alt to import an OPTIMETA Exam Radar export so lecture-emphasis exam signal folds in beside HW density.",
  12. "version": "0.9.0",
  13. "keywords": ["exam-prep", "math", "physics", "ocr", "claude-vision", "vision-pipeline", "statusline"]
  14. }
  15. ]
  16. }
README.md · README · 588 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1 align="center">ΠΑΙΔΕΙΑ · Paideia</h1>
  2. <p align="center">
  3. <strong>Your course. Your patterns. Your errors. Your cheatsheet.</strong><br>
  4. <em>A Claude Code plugin that turns your own materials into a permanent, editable, per-course study graph — every artifact shaped by you, not by a generic syllabus.</em>
  5. </p>
  6. <p align="center">
  7. <img src="https://img.shields.io/github/license/OPTIMETA/PAIDEIA?style=flat-square&labelColor=000000&color=333333&cacheSeconds=3600" alt="License">
  8. <img src="https://img.shields.io/github/stars/OPTIMETA/PAIDEIA?style=flat-square&logo=github&logoColor=white&labelColor=000000&color=333333&cacheSeconds=3600" alt="GitHub stars">
  9. <img src="https://img.shields.io/github/last-commit/OPTIMETA/PAIDEIA?style=flat-square&labelColor=000000&color=333333&cacheSeconds=3600" alt="Last commit">
  10. <img src="https://img.shields.io/github/languages/top/OPTIMETA/PAIDEIA?style=flat-square&labelColor=000000&color=333333&cacheSeconds=3600" alt="Top language">
  11. &nbsp;
  12. <img src="https://img.shields.io/badge/Claude%20Code-000000?style=flat-square&logo=anthropic&logoColor=white&labelColor=000000&cacheSeconds=3600" alt="Claude Code">
  13. <img src="https://img.shields.io/badge/Plugin-000000?style=flat-square&labelColor=000000&color=000000&cacheSeconds=3600" alt="Plugin">
  14. <img src="https://img.shields.io/badge/Markdown-000000?style=flat-square&logo=markdown&logoColor=white&labelColor=000000&cacheSeconds=3600" alt="Markdown">
  15. <img src="https://img.shields.io/badge/Python-000000?style=flat-square&logo=python&logoColor=white&labelColor=000000&cacheSeconds=3600" alt="Python">
  16. <img src="https://img.shields.io/badge/Ollama-000000?style=flat-square&logo=ollama&logoColor=white&labelColor=000000&cacheSeconds=3600" alt="Ollama">
  17. <img src="https://img.shields.io/badge/Qwen3--VL-000000?style=flat-square&labelColor=000000&color=000000&cacheSeconds=3600" alt="Qwen3-VL">
  18. <img src="https://img.shields.io/badge/Tesseract-000000?style=flat-square&labelColor=000000&color=000000&cacheSeconds=3600" alt="Tesseract">
  19. &nbsp;
  20. <img src="https://img.shields.io/badge/LaTeX-000000?style=flat-square&logo=latex&logoColor=white&labelColor=000000&cacheSeconds=3600" alt="LaTeX">
  21. <img src="https://img.shields.io/badge/Obsidian-000000?style=flat-square&logo=obsidian&logoColor=white&labelColor=000000&cacheSeconds=3600" alt="Obsidian">
  22. </p>
  23. <p align="center">
  24. <a href="https://news.hada.io/topic?id=29865"><img height="34" src="https://img.shields.io/badge/GeekNews-%231%20on%2026.05.26-333333?style=for-the-badge&labelColor=000000&color=333333" alt="GeekNews #1 on 26.05.26"></a><a href="https://news.hada.io/weekly/202622"><img height="34" src="https://img.shields.io/badge/GeekNews%20Weekly-%23360-333333?style=for-the-badge&labelColor=000000&color=333333" alt="GeekNews Weekly #360"></a><br>
  25. <a href="https://www.producthunt.com/products/paideia"><img height="34" src="https://img.shields.io/badge/Product%20Hunt-Launched-333333?style=for-the-badge&logo=producthunt&logoColor=white&labelColor=000000&color=333333" alt="Product Hunt launch"></a><a href="https://www.taewoopark.com/projects/paideia"><img height="34" src="https://img.shields.io/badge/Interactive%20Demo-Live-333333?style=for-the-badge&labelColor=000000&color=333333" alt="Interactive demo at taewoopark.com"></a>
  26. </p>
  27. <p align="center">
  28. <a href="./README.ko.md">한국어 README</a>
  29. &nbsp;·&nbsp;
  30. <a href="https://taewoopark.com"><strong>taewoopark.com</strong> — author site</a>
  31. </p>
  32. <p align="center"><sub><strong>The PAIDEIA family — one study engine, every agentic runtime</strong></sub></p>
  33. | Platform | Repository | What it is |
  34. |:--:|:--|:--|
  35. | <a href="https://github.com/OPTIMETA/PAIDEIA"><img src="https://cdn.simpleicons.org/claude/D97757" height="24" alt="Claude"></a> | **[PAIDEIA](https://github.com/OPTIMETA/PAIDEIA)** | The original — a **Claude Code** plugin. |
  36. | <a href="https://github.com/OPTIMETA/PAIDEIA-codex"><img src="https://upload.wikimedia.org/wikipedia/commons/e/ef/ChatGPT-Logo.svg" height="24" alt="OpenAI Codex"></a> | **[PAIDEIA-codex](https://github.com/OPTIMETA/PAIDEIA-codex)** | **OpenAI Codex** CLI edition. |
  37. | <a href="https://github.com/OPTIMETA/PAIDEIA-opencode"><img src="https://cdn.simpleicons.org/opencode/888888" height="24" alt="opencode"></a> | **[PAIDEIA-opencode](https://github.com/OPTIMETA/PAIDEIA-opencode)** | **opencode** edition. |
  38. | <a href="https://github.com/OPTIMETA/PAIDEIA-Hermes"><img src="https://github.com/hermes-agent.png" height="24" alt="hermes-agent"></a> | **[PAIDEIA-Hermes](https://github.com/OPTIMETA/PAIDEIA-Hermes)** | **hermes-agent** plugin. |
  39. | <a href="https://github.com/OPTIMETA/PAIDEIA-mcp"><img src="https://cdn.simpleicons.org/modelcontextprotocol/888888" height="24" alt="MCP"></a> | **[PAIDEIA-mcp](https://github.com/OPTIMETA/PAIDEIA-mcp)** | Standalone local **MCP** server — drive PAIDEIA from Alt local models. |
  40. | <a href="https://github.com/OPTIMETA/PAIDEIA-Alt"><img src="https://github.com/altalt-org.png" height="24" alt="Alt · altalt.org"></a> | **[PAIDEIA-Alt](https://github.com/OPTIMETA/PAIDEIA-Alt)** | **Exam Radar** — the Alt lecture-capture plugin ([altalt.org](https://altalt.org)). |
  41. <p align="center">
  42. <em>Generic study tools teach you the average syllabus. Paideia teaches you <strong>your</strong> syllabus —<br>
  43. from your professor's notes, your HW emphases, your handwriting, your errors. Every artifact is a markdown file you can edit.</em>
  44. </p>
  45. <p align="center">
  46. <img src="./docs/media/paideia-main.jpg" alt="PAIDEIA terminal preview" width="100%">
  47. </p>
  48. ---
  49. ## What Paideia means
  50. In ancient Greece, **Παιδεία** was never the deposit of facts into a passive student. It was the lifelong formation of a complete human being — through structured encounter with primary texts, guided practice under a master, and reflective dialogue that folds feedback into deeper revision.
  51. This plugin implements that cycle for the specific, bounded problem of **exam preparation** in math, physics, and engineering courses:
  52. ```
  53. ingest ──▶ analyze ──▶ drill ──▶ grade ──▶ weakmap ──▶ cheatsheet
  54. ▲ │
  55. └────────────────── feedback loop ───────────────────────┘
  56. ```
  57. Every stage produces a markdown artifact that lives in your course folder forever. Nothing is ephemeral. Nothing is hidden behind an API. Nothing stops working when the next funding winter hits.
  58. ---
  59. ## What generic study tools can't do
  60. Most study tools can't personalize to *your* course, *your* professor, or *your* mistakes — because the product they sell is a generic curriculum.
  61. - **Coursera, edX, Khan Academy** — fixed curriculum; no idea what your professor actually emphasizes.
  62. - **Quizlet, Anki, Brainscape** — you manually curate every card; nothing derives patterns from your own solution manuals.
  63. - **Chegg, Course Hero** — generic solution manuals; not organized around your course's recurring idioms.
  64. - **Brilliant, Duolingo Max, Khanmigo** — generic exercises; no knowledge of what you got wrong on HW2 last month.
  65. - **ChatGPT Study Mode, Gemini "Deep Study", NotebookLM** — no persistent per-course state. Every new session starts cold, and last week's mistakes don't shape this week's drill unless you re-upload and re-explain.
  66. None of them *form* understanding around the specific material in front of you. They each give every student the same answer. Paideia does the opposite: every artifact is derived from *your* folder — lecture notes, textbook chapter, HW, solutions, handwritten attempts — and accumulates permanently in plain markdown you can edit.
  67. | Axis | Paideia | Typical edu-SaaS / LLM chat |
  68. |-----|---------|------------------------------|
  69. | Solution patterns (`P1..Pk`) | Extracted from *your course's* own solutions, citing your own files | Generic textbook list, or none |
  70. | Drill priority | Weighted by *your professor's* HW emphasis (HW density = exam tier) | Fixed curriculum, or your own guesswork |
  71. | Cheatsheet | Built from *your* `errors/log.md` — whatever you actually got wrong | Boilerplate from the syllabus |
  72. | Per-course state across sessions | Permanent markdown + YAML, grows as you work | Conversation resets; paid tier for history |
  73. | Editing an artifact you disagree with | Open the `.md` in any editor, save | Read-only UI |
  74. | Carrying last semester's prep into next semester | Fork the course folder, edit deltas | Start over |
  75. | Version history of your own understanding | `git log` / `git diff` any artifact | Not surfaced |
  76. | Where the artifacts live | Your disk, as text | Remote DB, exportable only with paid tier |
  77. The plugin uses Claude Code (which is a paid tool) to do the heavy lifting, but everything it produces lives on your disk as plain markdown. If you later switch to a different model runner, or pause your Claude Code subscription, the course-index, patterns, error log, weakmaps, and cheatsheets are all still yours to open, read, edit, and diff. The scaffold is the plugin; the study graph is yours.
  78. By default, OCR goes through Claude's native vision inside your existing Claude Code session. If you'd rather the handwritten PDFs never leave the machine, `ollama pull qwen3-vl:8b` is a one-time ~6 GB download that flips every subsequent OCR pass to local Qwen3-VL inference. Either way, everything downstream — patterns, coverage, weakmaps, cheatsheets, the error log — is plain markdown on your disk.
  79. ---
  80. ## The load-bearing principle: HW density = exam probability
  81. Most "study smart" advice tells you to hunt your blind spots. That is **backwards**. The professor has *already told you* where the exam points live — by assigning homework. Sections with heavy HW coverage are 🔥🔥 Exam-primary. Sections with zero HW are ⚪ Low-risk, not "hidden traps". The professor's omission is the strongest possible signal that the topic is off the exam.
  82. Paideia's ranking is explicit about this, and every drill command honors it by default:
  83. | Tier | HW count on section | Treatment | Share of mock-exam points |
  84. |------|---------------------|-----------|---------------------------|
  85. | 🔥🔥 Exam-primary | 3+ | Drill hardest | ≥70% |
  86. | 🔥 Exam-likely | 2 | Drill next | ~25% |
  87. | 🟡 Exam-possible | 1 | Warm-pass review | ≤5% |
  88. | ⚪ Low-risk | 0 | Reference only | 0 |
  89. `/paideia:quiz all`, `/paideia:mock`, `/paideia:hwmap hot` all weight output by this tiering. If you insist on drilling a ⚪ section, the plugin complies once and warns you that exam probability is low — your limited time is worth more than an imagined gotcha.
  90. ---
  91. ## The formation cycle, stage by stage
  92. <p align="center">
  93. <video src="https://github.com/user-attachments/assets/13aa92f6-386e-473c-a422-769b673a96ca" width="100%" autoplay loop muted playsinline></video>
  94. <br><sub><em>Running PAIDEIA from the Claude Code CLI.</em></sub>
  95. </p>
  96. <p align="center"><sub><em>And from the Claude desktop app — the same plugin renders analyze + hwmap artifacts side by side:</em></sub></p>
  97. <table>
  98. <tr>
  99. <td align="center" width="50%">
  100. <img src="docs/media/desktop-summary.png" alt="summary.md generated by /paideia:analyze">
  101. <br><sub><b><code>summary.md</code></b> — topic tree from <code>/paideia:analyze</code></sub>
  102. </td>
  103. <td align="center" width="50%">
  104. <img src="docs/media/desktop-pattern.png" alt="patterns.md generated by /paideia:analyze">
  105. <br><sub><b><code>patterns.md</code></b> — solution-pattern cards from <code>/paideia:analyze</code></sub>
  106. </td>
  107. </tr>
  108. <tr>
  109. <td align="center" width="50%">
  110. <img src="docs/media/desktop-coverage.png" alt="coverage.md generated by /paideia:analyze">
  111. <br><sub><b><code>coverage.md</code></b> — section → exam-probability map from <code>/paideia:analyze</code></sub>
  112. </td>
  113. <td align="center" width="50%">
  114. <img src="docs/media/desktop-hwmap.png" alt="/paideia:hwmap output">
  115. <br><sub><b><code>/paideia:hwmap</code></b> — HW-density drill priority</sub>
  116. </td>
  117. </tr>
  118. </table>
  119. <p align="center">
  120. <strong>Recommended:</strong> run Paideia from the <strong>Claude desktop app</strong> for the smoothest experience — markdown, LaTeX, and tables render inline as the agent produces them, so analyze and hwmap outputs are readable without leaving the conversation. If you prefer the CLI (the demo above), pair it with <strong>Obsidian</strong> pointed at your course folder; see <em>A reading tip: use Obsidian</em> below.
  121. </p>
  122. | Stage | What it does | Commands | Produces |
  123. |-------|-------------|----------|----------|
  124. | **Encounter** | Read the professor's signal | `/paideia:ingest` | `converted/**/*.md` — every lecture, textbook chapter, HW, solution, as clean markdown |
  125. | **Structure** | Extract the grammar of the course | `/paideia:analyze` | `course-index/{summary,patterns,coverage}.md` — topic tree, recurring solution patterns (P1..Pk), HW-density exam-tier ranking |
  126. | **Practice** | Active recall weighted by what the professor actually tests | `/paideia:quiz`, `/paideia:twin`, `/paideia:blind`, `/paideia:chain`, `/paideia:mock` | `quizzes/`, `twins/`, `chain/`, `mock/` — problems you solve on paper |
  127. | **Reflection** | Your hand-written work becomes a grade | `/paideia:grade` | `answers/converted/<name>.md` + `errors/log.md` — OCR via Claude vision (default), Ollama/Qwen3-VL, or Tesseract; then strategy-based grading |
  128. | **Diagnosis** | Errors compressed into a priority-ranked weakness report | `/paideia:weakmap` | `weakmap/weakmap_<ts>.md` — append-only history |
  129. | **Distillation** | One page, error-driven, printable | `/paideia:cheatsheet`, `/paideia:derive`, `/paideia:pattern` | `cheatsheet/final.md`, `derivations/<slug>.md` — reference only what you actually need |
  130. Supporting: `/paideia:hwmap` surfaces HW-density exam-probability, `/paideia:init-course` bootstraps a fresh course folder.
  131. ---
  132. ## Install
  133. ### Prerequisites
  134. **Required (both install paths)**
  135. - Python 3.9+ (the plugin checks + offers to install its deps)
  136. - A Unix-style shell (`bash` / `zsh`). The bootstrap + grade commands use heredocs, `mkdir -p`, `mktemp`, and subshell backgrounding — native Windows `cmd` / PowerShell isn't currently supported.
  137. - **macOS**: `brew install poppler tesseract tesseract-lang`
  138. - **Linux (Debian/Ubuntu)**: `apt-get install poppler-utils tesseract-ocr tesseract-ocr-kor`
  139. - **Windows**: use [WSL2](https://learn.microsoft.com/windows/wsl/install), then follow the Linux path inside the WSL shell. Git Bash works too if `poppler` and `tesseract` are on `PATH`.
  140. **Optional — only if you want the `--ocr=ollama` mode (every page image stays on your machine)**
  141. - `ollama` + the `qwen3-vl:8b` model (~6 GB). macOS: `brew install ollama`. Linux: see the [ollama install script](https://ollama.com/install.sh). Then `ollama pull qwen3-vl:8b`.
  142. If you don't install Ollama, Paideia's default OCR engine is Claude's own vision — nothing extra to install, nothing extra to subscribe to beyond Claude Code itself.
  143. ### Install via the Claude desktop app (recommended)
  144. The desktop app is the smoothest reading surface for Paideia — `summary.md`, `patterns.md`, `coverage.md`, and `/paideia:hwmap` tables render inline as the agent emits them (see the screenshot grid above), so there's no separate reader to keep open.
  145. 1. Download Claude Desktop from [claude.ai/download](https://claude.ai/download) and sign in. Available for macOS, Windows, and Linux.
  146. 2. Open any new conversation and run each line as its own message:
  147. ```
  148. /plugin marketplace add https://github.com/OPTIMETA/PAIDEIA.git
  149. ```
  150. ```
  151. /plugin install paideia@paideia-marketplace
  152. ```
  153. 3. The 18 `/paideia:` slash commands are now available in every conversation. Continue to **Per-course bootstrap** below.
  154. ### Install via the Claude Code CLI
  155. If you prefer the terminal, install [Claude Code](https://claude.ai/claude-code) first, then run the same two commands inside `claude`, each as a separate line:
  156. ```
  157. /plugin marketplace add https://github.com/OPTIMETA/PAIDEIA.git
  158. ```
  159. ```
  160. /plugin install paideia@paideia-marketplace
  161. ```
  162. > The full `https://...` URL is deliberate — the `owner/repo` shorthand makes the CLI try SSH first, which fails if you don't have a GitHub SSH key registered. HTTPS always works.
  163. After install, 18 slash commands become available under the `/paideia:` namespace. CLI users should also set up [Obsidian as a reading companion](#a-reading-tip-use-obsidian) — the terminal can't render math.
  164. ### Per-course bootstrap
  165. Open Claude Code inside the folder you want to use for this course, then run:
  166. ```
  167. /paideia:init-course
  168. ```
  169. This interactively:
  170. 1. Checks Python / poppler / tesseract deps and offers to install missing ones (ollama is only probed when you pick the `ollama` engine in step 4)
  171. 2. Asks which interface language you want for this course — `en` (default) or `ko`. All subsequent paideia prompts, drill instructions, and generated MD narrative in this folder will follow that choice. Structural tokens (file paths, slash command names, pattern IDs `P1, P2, …`, YAML keys, tier markers) stay in English regardless
  172. 3. Asks for `COURSE_NAME`, `EXAM_DATE`, `EXAM_TYPE`, `USER_WEAK_ZONES`
  173. 4. Asks which OCR engine you want as the default: `claude` (native vision, no install), `ollama` (local Qwen3-VL, pulls the 6 GB model in the background), or `tesseract` (lightest, lowest fidelity)
  174. 5. Creates the directory skeleton (`materials/`, `converted/`, `course-index/`, `quizzes/`, `mock/`, `twins/`, `chain/`, `derivations/`, `cheatsheet/`, `weakmap/`, `answers/converted/`, `errors/`)
  175. 6. Writes `.course-meta` (carries `INTERFACE_LANG` + `OCR_ENGINE`, read by `/paideia:grade`, `session_start.py`, `vision_ocr.py`, and every slash command) and a project-level `CLAUDE.md`
  176. 7. Wires both a project-scoped statusline (`scripts/statusline.py`) **and** a `SessionStart` hook (`scripts/session_start.py`) in `.claude/settings.json`. The statusline shows `paideia · <COURSE> · D-N · <phase> · P<k> ↑` whenever you're inside the course folder; the hook prints a matching two-line reminder at the top of every new conversation so first-turn context is already primed
  177. 8. `git init` so your prep is versioned from the first keystroke
  178. You can always override the OCR engine for a single grade call: `/paideia:grade --ocr=claude path/to/answer.pdf`.
  179. ### Existing course folders (migration note)
  180. If you initialized a course before language support existed, `.course-meta` won't have an `INTERFACE_LANG` field — the plugin treats that as `en` and switches all prompts/output to English. **To keep Korean output for an existing course, add a single line to `.course-meta`:**
  181. ```
  182. INTERFACE_LANG: ko
  183. ```
  184. That's the whole migration. No re-init needed. Fresh courses go through the language picker in step 2 of `/paideia:init-course`.
  185. ---
  186. ## Course folder layout
  187. After `/paideia:init-course`, your course folder looks like this:
  188. ```
  189. my-course/
  190. ├── .course-meta # course name, exam date, interface language (en|ko), OCR engine
  191. ├── CLAUDE.md # project rules Claude Code reads every turn
  192. ├── .gitignore # hides raw PDF scans + OCR scratch; the study graph itself (errors/log.md, answer keys, solutions) stays committed
  193. ├── .claude/
  194. │ └── settings.json # wires the PAIDEIA statusline + SessionStart hook for this folder only
  195. │
  196. ├── materials/ # YOU DROP RAW FILES HERE (PDF or MD)
  197. │ ├── lectures/ # professor's notes, slide decks
  198. │ ├── textbook/ # textbook chapters
  199. │ ├── homework/ # HW problem sets
  200. │ └── solutions/ # HW solutions / worked examples
  201. │
  202. ├── converted/ # auto-generated markdown — do not edit
  203. │ ├── lectures/ # output of /paideia:ingest (vision-transcribed LaTeX)
  204. │ ├── textbook/
  205. │ ├── homework/
  206. │ └── solutions/
  207. │
  208. ├── course-index/ # knowledge base — built by /paideia:analyze
  209. │ ├── summary.md # topic tree (§1, §1.1, §2, …)
  210. │ ├── patterns.md # recurring solution patterns, labeled P1, P2, …
  211. │ ├── coverage.md # HW ↔ § map with 🔥🔥 / 🔥 / 🟡 / ⚪ exam tiers
  212. │ └── radar.md # lecture-emphasis signal — imported by /paideia:alt
  213. │
  214. ├── answers/ # YOU DROP HAND-WRITTEN SCAN PDFs HERE
  215. │ └── converted/ # /paideia:grade writes OCR'd markdown here
  216. │
  217. ├── errors/
  218. │ └── log.md # append-only YAML error log (seed for /weakmap + /cheatsheet)
  219. │
  220. ├── quizzes/ # /paideia:quiz — each problem has a hidden _answers.md sibling
  221. ├── mock/ # /paideia:mock — full mock exams (hidden _sol.md siblings)
  222. ├── twins/ # /paideia:twin — same pattern, new surface
  223. ├── chain/ # /paideia:chain — multi-pattern integration problems
  224. ├── derivations/ # /paideia:derive — clean reference derivations
  225. ├── cheatsheet/ # /paideia:cheatsheet — error-driven one-pager (+ optional PDF)
  226. └── weakmap/ # /paideia:weakmap — timestamped, append-only history
  227. ```
  228. **Only two directories are yours to edit by hand:**
  229. - `materials/` — drop source PDFs (or MDs) into the matching subfolder.
  230. - `answers/` — drop hand-written scan PDFs into the root; the OCR'd markdown shows up under `answers/converted/`.
  231. Everything else is produced by slash commands and should be treated as regenerable. Delete and rebuild whenever, `git log <dir>` to see your own progress over time, or point Obsidian at the whole folder as a vault.
  232. ---
  233. ## A reading tip: use Obsidian
  234. If you run Paideia from the CLI rather than the Claude desktop app, this is the recommended companion. Paideia writes everything as plain markdown with LaTeX math (`$...$`, `$$...$$`); you can read it in any editor, but **[Obsidian](https://obsidian.md)** is the natural choice:
  235. - Renders `$...$` and `$$...$$` math via MathJax with zero configuration
  236. - Backlinks let you click from `quizzes/q_<ts>.md` straight into the cited `converted/lectures/chN.md §K`
  237. - The whole course folder is just a vault — point Obsidian at `~/courses/my-course`, and everything is a searchable graph
  238. - Works entirely offline, free, local. Consistent with Paideia's philosophy: your notes, your disk, your tool
  239. VS Code with a markdown-math extension works too. The terminal — even with a markdown preview — is bad for math; don't fight that.
  240. ## And the lecture end: Alt
  241. Obsidian is the companion at the reading end. **[Alt](https://www.altalt.io/ko/)** is the companion at the other end — where the lectures come in. Alt records and transcribes your lectures, and OPTIMETA's **Exam Radar** plugin runs inside it to rank topics by how strongly the professor emphasized them out loud. Send that into Paideia with `/paideia:alt`, and the loop closes: **attend the lecture → capture it → extract the exam signal → study what matters.** Lectures live in Alt, deep personal study lives in Paideia, and Exam Radar is the bridge — finally one continuous workflow instead of scattered tools.
  242. ---
  243. ## Full workflow — an example
  244. ### Phase 0 — once per course (15 minutes)
  245. ```bash
  246. cp ~/textbooks/ch*.pdf ~/courses/my-course/materials/textbook/
  247. cp ~/lecture-notes/wk*.pdf ~/courses/my-course/materials/lectures/
  248. cp ~/hw/hw*.pdf ~/courses/my-course/materials/homework/
  249. cp ~/hw/hw*_sol.pdf ~/courses/my-course/materials/solutions/
  250. ```
  251. In Claude Code:
  252. ```
  253. /paideia:ingest # every PDF → vision pipeline (parallel agents, LaTeX-faithful)
  254. /paideia:analyze <weak-zone hints> # build patterns + coverage + summary
  255. /paideia:hwmap hot # surface 🔥🔥 exam-primary zones
  256. ```
  257. ### Phase 1 — diagnostic (40 minutes)
  258. ```
  259. /paideia:quiz all 20 # broad diagnostic, 20 problems
  260. # solve on paper (40 min), scan to answers/diagnostic.pdf
  261. /paideia:grade # local qwen3-vl OCR + strategy grade
  262. ```
  263. ### Phase 2 — targeted drilling (bulk of your prep time)
  264. ```
  265. /paideia:weakmap # priority-ranked weakness report
  266. /paideia:blind hw3-p2 # strategy-only drill on a known problem
  267. /paideia:twin hw3-p2 # variant with same pattern, new surface
  268. /paideia:chain 3 # multi-pattern integration problem
  269. /paideia:quiz weakmap 5 # 5 problems targeting the latest weakmap
  270. ```
  271. ### Phase 3 — integration (~90 minutes)
  272. ```
  273. /paideia:mock 90 # full 90-min mock weighted by HW density
  274. # solve on paper, scan, upload to answers/mock_<ts>.pdf
  275. /paideia:grade # grade the mock
  276. ```
  277. ### Phase 4 — compression (60 minutes, night before exam)
  278. ```
  279. /paideia:cheatsheet --pdf # error-driven one-pager
  280. /paideia:weakmap # review weak zones one more time
  281. ```
  282. ### Phase 5 — cool-down (10 minutes before exam)
  283. ```
  284. /paideia:weakmap # top 3 only. Do not learn new things.
  285. ```
  286. ---
  287. ## Commands (18 total)
  288. | Command | Purpose |
  289. |---------|---------|
  290. | `/paideia:init-course` | Bootstrap a fresh course folder (dep check, skeleton, metadata prompt, background `ollama pull`) |
  291. | `/paideia:doctor [--fix]` | Diagnose the install + workspace (Python, poppler, tesseract, Ollama/Qwen3-VL, course folders, `.course-meta`, writable paths, statusline wiring); `--fix` repairs the permission-free issues |
  292. | `/paideia:ingest [--force]` | Every PDF in `materials/**` → markdown in `converted/**` via the vision pipeline (parallel agents, one per PDF, LaTeX-faithful). |
  293. | `/paideia:analyze [hints]` | Build `course-index/{summary,patterns,coverage}.md` |
  294. | `/paideia:reindex [--fix]` | Idempotent, analyze-free rewrite: retired coverage.md tier markers → canonical vocabulary; errors/log.md nature/phase facet materialization (header-data 1:1). Atomic, byte-preserving. |
  295. | `/paideia:graph [--rebuild]` | Generate `course-index/concept-graph.md` — mermaid concept graph with INTERFACE_LANG node labels, document-order C-IDs, and Obsidian wikilinks. Reads only the built index (no analyze fan-out). |
  296. | `/paideia:hwmap hot\|<§>` | Surface 🔥🔥 Exam-primary sections ranked by HW density |
  297. | `/paideia:pattern <§\|Pk\|keyword>` | Show pattern cards from course-index |
  298. | `/paideia:derive <target>` | Clean reference derivation to `derivations/<slug>.md` |
  299. | `/paideia:quiz <topic\|§\|weakmap> [N]` | N practice problems, answers hidden in sibling `_answers.md` |
  300. | `/paideia:blind <problem-id>` | Strategy-check drill on a known problem (no re-solve, describe approach) |
  301. | `/paideia:twin <problem-id>` | Variant of a known problem — same pattern, new surface |
  302. | `/paideia:chain <N>` | Multi-pattern integration problem combining N patterns |
  303. | `/paideia:mock <minutes>` | Full mock exam, HW-density weighted |
  304. | `/paideia:grade [--ocr=<engine>] [path]` | OCR answer PDF via the engine set in `.course-meta` (Claude vision / Ollama / Tesseract), strategy-grade, append `errors/log.md` |
  305. | `/paideia:weakmap [concept]` | Priority-ranked weakness report saved to `weakmap/weakmap_<ts>.md` |
  306. | `/paideia:cheatsheet [--pdf]` | Error-driven one-pager |
  307. | `/paideia:alt [paste]` | Import an OPTIMETA Exam Radar (Alt plugin) export → `course-index/radar.md` + a lecture-emphasis column on `coverage.md` + a gold-zone weakmap |
  308. ---
  309. ## Under the hood
  310. ### Ingest pipeline: vision for every PDF
  311. `/paideia:ingest` routes every PDF in `materials/**` through the same vision pipeline. `pdfplumber` was tried first as a fast path for prose-heavy material (textbook, HW) and proved unreliable: even pages that *look* like plain prose silently word-salad as soon as they mix equations, figures, multi-column layouts, or margin notes. Rather than maintain a per-category heuristic with fallbacks we'd have to retune per course, we route everything uniformly.
  312. | Source | Method |
  313. |---|---|
  314. | `materials/**/*.pdf` | Vision pipeline (parallel agents, LaTeX-faithful) |
  315. | `materials/**/*.md` | Copy-through with provenance header |
  316. How the pipeline runs: every page is rendered to PNG at `dpi=160`; every PNG is resized to ≤1800 px on the long edge **before any agent starts reading** (Claude's many-image requests hard-reject images >2000 px; 16:9 slides at dpi=160 blow past that unless you preempt the resize); then one parallel `general-purpose` agent is spawned per PDF, each of which reads its own pages *sequentially* (parallel batches trip the same dimension limit) and transcribes to LaTeX markdown. PDFs over 30 pages are split across multiple agents in consecutive page ranges and re-joined under one provenance header, so a big textbook chapter can't overflow a single agent's context. Output like `$$\hat H = -\frac{\hbar^2}{2m}\partial_x^2 + V(x)$$` instead of `ℏ ∂ p2 ℏ 2 ∂ 2 p ̂`. A real 13-lecture, 208-page quantum mechanics course ran end-to-end with zero `[?]` markers.
  317. Details in `plugins/paideia/skills/pdf/VISION.md`.
  318. ### Hand-writing OCR: three engines, you pick
  319. The user does not type math into chat. They solve on paper, scan to PDF, drop the PDF into `answers/`, and run `/paideia:grade`. The plugin converts the scan to markdown via one of three engines, chosen per course (via `OCR_ENGINE` in `.course-meta`) and overridable per call (via `/paideia:grade --ocr=<engine>`):
  320. | Engine | Default? | How it runs | When to pick it |
  321. |---|---|---|---|
  322. | `claude` | **Yes** | `pdftoppm` renders each page → Claude reads each PNG directly → synthesizes markdown in one pass. No extra model, no subprocess, nothing to install. | The out-of-the-box path. Strong on Korean + LaTeX; no model-load stall. |
  323. | `ollama` | opt-in | `vision_ocr.py --engine=ollama` → local Qwen3-VL 8B with automatic tesseract fallback. | You want the page images to never leave the machine (not even to Anthropic). Requires `ollama pull qwen3-vl:8b` once (~6 GB). |
  324. | `tesseract` | opt-in | `vision_ocr.py --engine=tesseract` → pytesseract (`eng` if `INTERFACE_LANG=en`, `eng+kor` if `ko`). | Fastest and lightest; acceptable for typed scans; poor on hand-writing. |
  325. Each engine writes `answers/converted/<stem>.md` with a `<!-- SOURCE: ... -->` / `<!-- TIER: ... -->` header comment so `/paideia:grade` can caveat low-confidence OCR.
  326. Default choice (`claude`) is deliberately the path of least friction: anything that already ships with Claude Code is enough. The `ollama` engine exists for users who want a hard privacy boundary on the page images themselves, and `tesseract` exists as a reliable floor when nothing else is available.
  327. ### Strategy-based grading, not line-by-line
  328. OCR noise in hand-written math makes strict algebraic grading useless — a single misread `∫` vs `∑` would cascade. More importantly, **pattern recognition is the actual exam bottleneck**, not arithmetic. The grader therefore checks three things on each problem:
  329. 1. **Pattern** — did the student pick the right Pk from `course-index/patterns.md`?
  330. 2. **Variables** — did they identify the right substitution / basis / index / contour?
  331. 3. **End-form** — does their final expression have the right shape (dimensions, asymptotics, structure)?
  332. Errors get logged as YAML to `errors/log.md` with a typed classification (`pattern-missed | wrong-variable | wrong-end-form | algebraic | sign | definition`). This log is the seed for `/paideia:weakmap` and the *only* input to `/paideia:cheatsheet --pdf`.
  333. ### Patterns extracted from *your* solutions
  334. `/paideia:analyze` doesn't ship a generic "calculus moves" list. It reads your course's actual solution manual, extracts recurring solution patterns, and labels them P1, P2, ... with worked instances that cite your own `converted/solutions/` files. The patterns are *your course's idioms*, not a textbook's. For a complex analysis course, P3 might be "closed contour + Jordan's lemma + residue at essential singularity." For a linear systems course, P3 might be "partial fractions + inverse Laplace with complex poles." Every discipline has its own moves; only the course itself reveals them.
  335. ### Append-only history
  336. `weakmap/` never overwrites. Every `/paideia:weakmap` invocation produces `weakmap/weakmap_<ISO-timestamp>.md`. You can `git log weakmap/` and see exactly which weaknesses collapsed first, which ones persisted, which new ones emerged after the diagnostic mock. This is "`git diff` your own understanding over time" in practice.
  337. ### Statusline: where you are in the cycle, at a glance
  338. `/paideia:init-course` writes a project-scoped `.claude/settings.json` that points Claude Code's statusline slot at `scripts/statusline.py`. The statusline shows:
  339. ```
  340. paideia · <COURSE_NAME> · D-<days-to-exam> · <phase> · P<top-miss> ↑
  341. ```
  342. - **`<phase>`** is derived from **activity** on disk (not a calendar, and not merely file existence), so it advances when you actually use the artifact, not when you seed an empty one:
  343. - `setup` — `course-index/patterns.md` doesn't exist yet → run `/paideia:ingest` + `/paideia:analyze`
  344. - `diag` — patterns exist, but `errors/log.md` has no graded entry yet → run `/paideia:quiz all 20`, solve on paper, then `/paideia:grade`
  345. - `drill` — quiz problems exist AND `errors/log.md` has at least one graded `- problem_id:` entry → cycle `/paideia:blind` · `/paideia:twin` · `/paideia:quiz weakmap`
  346. - `mock` — a mock-sourced entry has appeared in `errors/log.md` (i.e., you've actually graded a mock) → compress with `/paideia:cheatsheet --pdf`
  347. - `cram` — `cheatsheet/final.{md,pdf}` exists → taper, re-read the weakmap, stop learning new things
  348. - `cool` — `D-0` overrides everything (exam is today)
  349. - **`<top-miss>`** is the most frequent `pattern:` tag from the latest `weakmap/weakmap_*.md` (falls back to `errors/log.md`). The `↑` is a reminder that this is the pattern to drill next.
  350. - **Color** is a random neon shade, picked deterministically from `sha1(session_id)` — it stays stable within one session but rotates across sessions. Pure decoration; no information is color-encoded.
  351. - **Silent fallback** — if the CWD has no `.course-meta`, the script outputs nothing, and Claude Code falls back to its default statusline. Safe to leave wired.
  352. On top of the statusline, `/paideia:init-course` also wires a `SessionStart` hook (`scripts/session_start.py`, matcher `startup|resume`) that prints a matching two-line reminder — course name with D-N, current phase, and the top-miss pattern with a suggested next command — at the top of every new conversation. The hook and the statusline read the same `.course-meta` + `errors/log.md` + latest weakmap, so they agree; the hook just echoes the same signal inline in the prompt, where first-turn context tends to land before the eye hits the status bar. Both slots exit silently if the CWD has no `.course-meta`, so it's safe to leave wired when you `cd` elsewhere.
  353. Under the hood, the statusline memoizes its output at `~/.cache/paideia/<sha1(cwd|session)>.json` and invalidates on the `mtime` of every file whose contents affect the display (`.course-meta`, `course-index/patterns.md`, `errors/log.md`, `cheatsheet/final.{md,pdf}`, newest `weakmap/mock/quizzes` file). Claude Code re-renders the statusline on every prompt; without the cache, a mature course folder with hundreds of weakmap entries would re-scan on every turn.
  354. To disable the statusline for one course, delete or edit that course's `.claude/settings.json`. To disable globally, edit `~/.claude/settings.json` instead. To customize the format or colors, edit `plugins/paideia/scripts/statusline.py` — everything is in one file.
  355. ---
  356. ## What ships
  357. ```
  358. PAIDEIA/
  359. ├── .claude-plugin/marketplace.json # marketplace manifest
  360. ├── LICENSE # MIT
  361. ├── README.md # this file
  362. ├── README.ko.md # Korean mirror
  363. └── plugins/paideia/
  364. ├── .claude-plugin/plugin.json # plugin manifest (name, version, author)
  365. ├── README.md # quick-reference card
  366. ├── skills/
  367. │ ├── pdf/
  368. │ │ ├── SKILL.md # routing decision tree + reference extractors
  369. │ │ └── VISION.md # default ingest pipeline — parallel vision agents per PDF
  370. │ ├── vision-ocr/SKILL.md # Claude vision (default) + Ollama Qwen3-VL + tesseract
  371. │ ├── course-builder/SKILL.md # ingest + analyze pipeline
  372. │ ├── exam-drill/
  373. │ │ ├── SKILL.md # drill primitives (twin, blind, chain, mock)
  374. │ │ └── twin-recipe.md # invariance rules for variant generation
  375. │ ├── answer-processing/SKILL.md # strategy-grade hand-written OCR output
  376. │ └── alt-import/SKILL.md # import an Exam Radar (Alt) export → radar.md + coverage lecture column
  377. ├── commands/ # 18 slash commands
  378. │ ├── init-course.md doctor.md ingest.md analyze.md
  379. │ ├── reindex.md graph.md hwmap.md pattern.md
  380. │ ├── derive.md quiz.md blind.md twin.md
  381. │ ├── chain.md mock.md grade.md weakmap.md
  382. │ ├── cheatsheet.md
  383. │ └── alt.md
  384. └── scripts/
  385. ├── paideia_lib.py # shared core: .course-meta parsing, D-day math, the phase state machine, RETIRED_TO_CANONICAL
  386. ├── log_tool.py # deterministic errors/log.md writer — schema-validated, idempotent per source
  387. ├── doctor.py # /paideia:doctor: install + workspace diagnostic, permission-free --fix
  388. ├── reindex.py # /paideia:reindex: atomic, analyze-free coverage.md marker rewrite + errors/log.md facet materialization
  389. ├── verify_tool.py # /paideia:grade symbolic preflight: LaTeX/SymPy equivalence via math-verify, honest downgrade when absent
  390. ├── vision_ocr.py # opt-in: ollama qwen3-vl driver + tesseract forcing, for --ocr=ollama|tesseract
  391. ├── statusline.py # emits `paideia · <COURSE> · D-N · <phase> · P<k> ↑` for Claude Code's statusline slot
  392. └── session_start.py # SessionStart hook: two-line "phase / top-miss / next command" at the top of every new session
  393. ```
  394. ---
  395. ## Design convictions
  396. 1. **The terminal is bad for math.** Claude produces markdown files; you read them (ideally in Obsidian).
  397. 2. **Typing solutions is slow and error-prone.** You solve on paper, scan, and the plugin OCRs locally.
  398. 3. **OCR noise is inevitable.** So grading is strategy-based (pattern / variables / end-form), not line-by-line algebra. This is what the actual exam grader is evaluating anyway.
  399. 4. **Patterns must be extracted from *your* course's solutions** — not from a generic list. Every discipline has its own idioms; only the course itself reveals them.
  400. 5. **Your errors are the most valuable study signal** — more than the textbook, more than the lectures. The cheatsheet is generated from `errors/log.md`, not from the syllabus.
  401. 6. **HW density tells you the exam.** Your time is finite; spend it where the points are.
  402. 7. **Everything is yours to edit.** Patterns, weakmaps, cheatsheets, the error log — all plain markdown/YAML in your own git history. Disagree with `P3`? Rewrite it, and the next drill uses your edit. Fork a course folder from last semester into a new one and edit deltas. The plugin is a scaffold; the study graph is yours.
  403. ---
  404. ## FAQ
  405. **Does this work for non-math courses?**
  406. It's built around problem-pattern extraction, so it shines in quantitative disciplines: math, physics, EE, CS-theory, ML-theory, statistics, engineering. For history or literature it would still ingest and produce summaries, but the drill commands assume problems have solution patterns.
  407. **Korean and English mixed materials?**
  408. Yes. Ingestion and OCR are configured for `eng+kor`. Patterns and grading responses honor the language mix of your source materials.
  409. **How is this different from just asking ChatGPT / Claude / Gemini to help me study?**
  410. Per-course persistence. An LLM chat has no memory of the pattern you missed on HW2 two weeks ago, no ranking of which sections your professor actually emphasizes, no notion of "your typical error type." Paideia writes all of that to markdown files on your disk. A `/paideia:weakmap` today is informed by every `/paideia:grade` since the course began, because `errors/log.md` is append-only. A generic chat session, however smart, is a blank slate every time you open it.
  411. **Can I edit the patterns / cheatsheet / weakmap if I disagree?**
  412. Yes. That's the whole point of keeping them as plain markdown. If `P3` feels wrong, open `course-index/patterns.md` and rewrite it — subsequent drills will use your edit. If the cheatsheet emphasizes the wrong thing, trim it. The plugin is a scaffold; the study graph is yours to shape.
  413. **Do I need Ollama / Qwen3-VL to use this?**
  414. No. The default OCR engine is Claude's native vision — it uses the Claude Code session you're already in and needs no extra install. Ollama + `qwen3-vl:8b` is an opt-in path for users who want the page images to stay on their machine entirely (not even visible to Anthropic's servers during a grade call). `tesseract` is a third option for minimal-install setups or typed scans.
  415. **What if my machine can't run `qwen3-vl:8b` even though I picked Ollama?**
  416. The `vision_ocr.py` driver automatically falls back to tesseract on any Ollama failure (`eng` if your course's `INTERFACE_LANG` is `en`, `eng+kor` if `ko`). You can also just set `OCR_ENGINE: claude` in `.course-meta` (or pass `--ocr=claude`) and skip Ollama entirely.
  417. **Can I reuse the plugin across multiple courses?**
  418. Yes — each course lives in its own folder with its own `.course-meta`, `course-index/`, `errors/log.md`, and `weakmap/`. Nothing is shared or polluted across courses. Open Claude Code inside whichever course folder you're working on.
  419. **Can I trust an LLM to grade my work?**
  420. Grading is strategy-based (pattern match, not algebra), the grader cites the pattern from `course-index/patterns.md`, and every grade writes a YAML entry you can audit in `errors/log.md`. If a grade is wrong, fix the YAML entry — the next `/paideia:weakmap` reflects the correction.
  421. **Is my data private?**
  422. Your PDFs, markdown, errors, and weakmaps all live in your local course folder — nothing is uploaded to any third-party service. The only network traffic the plugin itself generates depends on the OCR engine you pick: with `claude` (default), page images flow through your existing Claude Code session (i.e., whatever path your normal Claude Code conversation already takes — nothing new); with `ollama`, nothing leaves the machine after the one-time model download; with `tesseract`, nothing leaves the machine ever.
  423. ---
  424. ## Connect
  425. <p align="center">
  426. <a href="https://github.com/TaewoooPark"><img src="https://img.shields.io/badge/-GitHub-181717?style=for-the-badge&logo=github&logoColor=white&cacheSeconds=3600" alt="GitHub"></a>
  427. <a href="https://x.com/theoverstrcture"><img src="https://img.shields.io/badge/-X-000000?style=for-the-badge&logo=x&logoColor=white&cacheSeconds=3600" alt="X (Twitter)"></a>
  428. <a href="https://www.linkedin.com/in/taewoo-park-427a05352"><img src="https://img.shields.io/badge/-LinkedIn-0A66C2?style=for-the-badge&logo=linkedin&logoColor=white&cacheSeconds=3600" alt="LinkedIn"></a>
  429. <a href="https://www.instagram.com/t.wo0_x/"><img src="https://img.shields.io/badge/-Instagram-E4405F?style=for-the-badge&logo=instagram&logoColor=white&cacheSeconds=3600" alt="Instagram"></a>
  430. <a href="https://taewoopark.com"><img src="https://img.shields.io/badge/-taewoopark.com-000000?style=for-the-badge&logo=safari&logoColor=white&cacheSeconds=3600" alt="Personal site"></a>
  431. <a href="mailto:ptw151125@kaist.ac.kr"><img src="https://img.shields.io/badge/-Email-D14836?style=for-the-badge&logo=gmail&logoColor=white&cacheSeconds=3600" alt="Email"></a>
  432. </p>
  433. ---
  434. ## License
  435. MIT. Use freely. Fork and modify for your own courses — the point of the plugin is that the study graph it builds is yours to shape, not a fixed product you have to live with.
  436. ---
  437. <p align="center">
  438. <em>Generic curricula teach the average student. Παιδεία — formation, one student at a time.</em>
  439. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

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