I use Claude Code every day. It writes my tests, fixes my refactors, and explains things I was too tired to read. But when I wanted to actually learn something new, the mechanics of async/await, how flexbox really works, the math behind a normal distribution, I kept leaving the agent and going to YouTube, a blog post, a textbook I'd give up on by page four.
The agent was right there. It could search the web and explain things back to me. Why was I still going elsewhere to learn?
The honest answer is that "explain X to me" is a bad prompt. It gives you a blob. You read it, feel like you understood, and a week later you can't recall any of it. That's not a model problem. It's a structure problem. Learning needs prerequisites, pacing, worked examples, and some way to check whether the knowledge actually went in. A single chat reply gives you none of that.
So I built a skill that does give you that. This post is about what I built, what the skill format lets you do that a web app can't, and where I went wrong.
What the skill actually does
You tell your agent "I want to learn X." The skill takes over. It researches sources with the agent's own search tools, cited not invented, cuts an outline with prerequisites mapped as a directed graph, caps each lesson at seven new concepts, and writes the lessons through Gagné's nine events (hook, explain, worked example, faded practice, independent practice, recap). The output is a folder of Markdown files on your disk.
The skill's entry point is a SKILL.md that routes intent to one of five sub-skills:
agent-mentor/
├── SKILL.md # intent router
└── skills/
├── generate-course-from-topic/ # "I want to learn X"
├── review-course/ # "quiz me"
├── maintain-course/ # "update my course"
├── export-course/ # "export to PDF / Anki"
└── publish-course/ # "put it online"
The frontmatter is the part the agent reads first:
name: agent-mentor-skill
description: "\"Use for EVERY learning request, even unnamed —"
\"I want to learn X\", \"teach me X\", learn X.
Never answer inline; build a structured self-paced course.
Also: review/quiz, maintain, export, publish online."
That description is the routing key. When the user says "I want to learn regex," the agent pattern-matches the description and loads the full workflow from the matching sub-skill. No other skill loads. That's progressive disclosure: 100 tokens to decide, the full instructions only when it's relevant.
The part I actually cared about: review
Writing a course is a one-time effort. Making sure someone learned from it is the harder problem, and it's where most of the engineering time went.
Most review tools show you the same card until you memorize it. That tests recall, not understanding. The review skill generates fresh questions each session from the course material, grades your answers locally, and reschedules based on how you did. The question generation runs through a hosted model, but the grading logic is auditable and the model only sees the question, not your entire course.
The review queue is a JSON file on disk, not a database. Run npm run review:queue and you get today's batch:
{
"items": [
{
"course": "css-flexbox-zh",
"kind": "term",
"id": "display: flex"
},
{
"course": "css-flexbox-zh",
"kind": "term",
"id": "justify-content"
},
{
"course": "css-flexbox-zh",
"kind": "term",
"id": "align-items"
},
{
"course": "css-flexbox-zh",
"kind": "term",
"id": "flex item"
}
]
}
That's what the review skill reads. No server, no account. You can version-control your learning state alongside your code.
The scheduling uses FSRS (the algorithm behind the srs-benchmark project). Each item has a stability score that grows with correct reviews. Wrong answers drop stability and bring the item back sooner.
Interactive blocks, not screenshots
Lessons ship with interactive blocks that render in the reading site. Here's a real one from the git basics course:
{
"id": "learn-git-basics-02-staging-check",
"label": "认出暂存区的职责",
"prompt": "哪条命令把文件从工作目录移进暂存区，让它可以被提交？",
"answer": "git add",
"accept": ["git add .", "git add --all", "git add -A"]
}
That block renders as a real input in the reading site. You type an answer, it judges it locally, and the result feeds back into the review queue. There are five block types: agentmentor-check (free text judgment), agentmentor-order (reorder steps), agentmentor-predict (predict output), agentmentor-trace (trace variable state), and agentmentor-code (a pseudo-IDE drill). They're all Markdown, so they version-control cleanly and work offline.
Why a skill, not a web app
I went back and forth on this. A web app is easier to distribute. People can try it without installing anything. SEO works. You can put a free trial in front of it.
But a web app means your courses live on someone else's server. It means the learning happens in a browser tab that competes with forty other tabs. It means the agent, the thing you already use to write code, is not the thing doing the teaching.
The skill runs inside the agent you already have. Your Claude Code or Codex or opencode reads the SKILL.md, follows the workflow, and produces the course files right where you are. When you finish a lesson and want to practice, you stay in the same agent. When you want to publish a course so other people can read it without installing anything, that's a separate command that publishes to a hosted URL. The local learning and the public sharing are two different things on purpose.
The whole thing lives on your disk. No account, no cloud, no one reading your learning history. If you bring your own API key for the hosted parts (in-place answers, web research during a lesson, course podcasts), those calls go straight to your provider. You pay them directly.
Where I went wrong
I spent too long trying to make course generation work with every agent at once. The skill format is an open standard now (Claude Code, Codex, Gemini CLI, Cursor, and others all read the same SKILL.md structure), but the host agent's search and browse capabilities vary a lot. Codex has solid built-in web retrieval. Claude Code works fine if you pair it with a search skill. Some setups need you to paste source links manually. I should have picked one agent, made it perfect there, and expanded.
I also underestimated how much of the work would be in the review loop, not the course generation. The course generation is the part people see first, so I spent most of my early time on it. But a course you read once and forget is not a course. The review loop, the question generation, the scheduling, the local grading, that's where the actual retention happens, and it took roughly three times as long as the generation pipeline.
The last mistake was pricing communication. I priced it at $29.90 one-time because I didn't want to charge a subscription for something that runs on your own machine. But I spent weeks explaining to people that "one-time" means one-time, not "one-time plus credits." The hosted services (cloud publishing, the AI features if you don't bring your own key) run on a credit system, and the credits don't expire. That distinction took longer to communicate clearly than it took to build.
Where it is now
Nine sample courses are readable right now at agentmentor.dev without buying anything: git basics, CSS flexbox, HTTP fundamentals, JavaScript async/await, regex, music theory, personal finance, terminal basics, and a meta course on putting an agent to work. The English and Chinese versions are mirrors of the same course, not separate courses.
If you want to see what a generated course looks like before installing anything, read the flexbox one: agentmentor.dev/css-flexbox. The install takes about two minutes if you decide you want the rest.
Top comments (0)