A Claude Code skill that designs and runs a fully personalized course on any topic — entirely in the terminal. No platform, no video, no voice. Just text, grounded in the learning science that actually moves retention.
You tell Claude what you want to learn and what you want to be able to do when you're done. The skill turns that into a real course — curriculum, lessons, practice, projects, assessments — and teaches it to you across multiple sessions, adapting as it learns how you think.
It is not a chatbot that answers questions. It is a teacher with a lesson plan, a model of you, and a memory that persists between sessions.
You: "I want to learn dynamic programming so I can pass a trading-firm interview in 2 months."
Skill: intake → finds your gaps → tests your baseline → designs a 7-unit course →
shows it to you for approval → then teaches it, unit by unit, session by session,
remembering exactly where you are and what you're still shaky on.
Most "AI tutors" just explain things on demand. This skill is built on eight learning-science principles, applied as hard rules — not vibes.
| Principle | What it means here |
|---|---|
| Goal-weighted everything | Your stated end-goal weights every research query, lesson, and assessment. A "pass the interview" course ≠ a "deeply understand" course. |
| Productive failure first | Every lesson opens with an attempt before any instruction. You struggle first; the lesson is framed as resolving that struggle. |
| Pre-test before every unit | A short retrieval probe before instruction. Nail it cleanly → you're offered an accelerated pass. |
| Spaced retrieval | Prior material returns at expanding intervals via a scheduling queue — not when it's convenient, when it's due. |
| Interleaving | Confusable concepts get mixed in practice and checkpoints, so you learn to tell them apart. |
| Adaptive scaffolding | Help fades based on a rubric, as you demonstrate competence — not on a fixed timer. |
| Student model | A persistent file is the agent's evolving understanding of you: strengths, gaps, patterns in how you think. |
| Gaps close by demonstration, never by explanation | Every misconception is logged and re-tested until you show you've got it ≥2× spaced apart. Being told once doesn't count. |
The skill moves through five phases. Nothing gets generated until you approve the plan.
ENTRY ──► resume an existing course? OR start a new one?
│
▼
SETUP ─────────────────────────────────────────────────────────
1. Intake → what you want, how deep, your end-goal
2. Prereq analysis → researches + probes what you must know first
3. Baseline → tests where you are today (problems / roleplay / take-home)
4. Pacing → spaced vs compressed vs self-paced (with retention caveats)
│
▼
DESIGN ────────────────────────────────────────────────────────
5. Curriculum → research-backed, with interleaving + spaced-retrieval plan
6. Unit synthesis → breaks the course into units
7. ⛔ APPROVAL GATE → you review and approve before ANY content is generated
│
▼
CONTENT GEN ───────────────────────────────────────────────────
8. Parallel sub-agents generate lessons, practice, projects,
simulations, and assessments per unit (capped at 3 concurrent)
│
▼
RUNTIME (the unit loop, per session) ──────────────────────────
9. pre-test → [ PF attempt → lesson → talk session ] ×lessons →
project → checkpoint → update spaced-retrieval queue + student model
│
▼
FINAL ASSESSMENT ──► what you demonstrated, what's still brittle
For each unit:
1. Pre-test (retrieval probe; accelerated-pass escape valve)
2. For each lesson:
a. PF attempt (you try first)
b. Lesson walkthrough (framed as resolving your attempt)
c. Talk session (probe + surface older material)
3. Project + debrief
4. Checkpoint (pass → advance | fail → loop back specific lessons)
5. Update spaced-retrieval-queue.md + student-model.md
6. Update progress.md
Markdown files are the only memory across sessions. Course state lives on your machine, never in this repo:
~/thinker/vault/learning/
├── index.md # manifest — every course, one row each
└── <course-slug>/
├── course-definition.md # topic, depth, end-goal, target skills
├── student-model.md # ⭐ the agent's model of YOU (most important file)
├── progress.md # exactly where you are; how resume works
├── prereqs.md # gaps + how each was resolved
├── baseline-map.md # where you started
├── pacing.md # your chosen schedule
├── curriculum.md # the plan
├── spaced-retrieval-queue.md # what's due for review, when
├── units/ lessons/ pf-attempts/ talk-sessions/
├── projects/ simulations/ assessments/
└── approval.md # timestamped proof you approved the plan
student-model.md is the heart of it. It tracks a concept ledger (every concept + status), an open-gaps ledger (misconceptions that must be re-tested until demonstrated), and patterns in how you think. It's updated after every signal — never batched — so resume always works and you can see your own progress.
This is a Claude Code skill. Drop it where Claude Code looks for skills:
# Personal skill (available in every project)
git clone https://github.com/akeildev/personalized-learning-terminal \
~/.claude/skills/personalized-learning-terminal
# OR project-scoped
git clone https://github.com/akeildev/personalized-learning-terminal \
.claude/skills/personalized-learning-terminalRestart Claude Code (or start a new session). The skill auto-registers from its SKILL.md.
- Claude Code (CLI, desktop, web, or IDE extension).
- Exa MCP (recommended) — used for prereq research and curriculum grounding. Without it the skill still runs, but research depth is reduced.
- That's it. No API keys of its own, no servers, no build step.
Just talk to Claude in a session where the skill is installed:
/personalized-learning-terminal # explicit invoke
/learn # short alias
# …or natural language:
"I want to learn distributed systems deeply, as a course."
"Teach me music theory over multiple sessions."
"Design me a curriculum for SaaS pricing strategy."
# …and to come back:
"Resume my course."
"Continue learning Go."
"List my courses."
"Where was I?"
When it triggers: topics you want to learn deeply / properly / over time / as a course, or resuming/listing existing courses.
When it won't: quick one-shot questions ("what is a closure?") — those don't need a course. If it's ambiguous, the skill asks one question: "Quick answer, or a course you'll return to?"
personalized-learning-terminal/
├── SKILL.md # the skill manifest Claude Code loads (entry point)
├── README.md # you are here
├── LICENSE # MIT
├── references/ # the agent's detailed playbooks, loaded as needed
│ ├── 00-overview.md # entry / resume / manifest / done-criteria
│ ├── 01-setup.md # intake, prereqs, baseline, pacing
│ ├── 02-design.md # curriculum, unit synthesis, approval gate
│ ├── 03-content.md # sub-agent fan-out: concurrency + model rules
│ ├── 04-runtime.md # the unit loop, fading rubric, accelerated-pass
│ ├── 05-state.md # file layout, schemas, compaction, concurrency
│ └── 06-modalities.md # terminal delivery patterns, slides, lesson formatting
├── agents/
│ └── openai.yaml # interface metadata (display name, default prompt)
└── scripts/
└── init_course.sh # scaffolds a new course directory + manifest row
SKILL.md is the contract Claude Code reads. The references/ files are progressively loaded by the agent only when a phase needs them — keeping context lean.
This skill is text-only on purpose. Be clear-eyed about what that costs:
- No real-time observation. The agent sees your results and self-report, not your live struggle. Productive-failure feedback is softer than an in-person tutor's.
- No voice, no whiteboard. Diagrams are ASCII or generated static files.
- Adaptive fading is approximate — driven by a conversational rubric, not observed expertise growth.
What's not compromised: the intellectual core. Goal-driven, productive-failure-ordered, spaced, interleaved, pre-tested, adaptively scaffolded, student-modeled, and user-approved. The sensory richness is what's missing — not the pedagogy.
- lyceum — a sibling open-source skill family: "send Claude Code to college, graduate a deployed specialist." Different goal (the agent learns a domain and ships); shared philosophy (real learning-science pipelines, open and inspectable).
MIT © 2026 Akeil Smith — see LICENSE.