The problem
I can have a long, dense conversation with Claude about something I’m trying to learn, an auth flow or a database tradeoff, and walk away feeling like I understood it. Feeling like you understood something and being able to reproduce it cold are different things. The conversation ends, the context evaporates, and a week later I couldn’t tell you which parts I actually grasped versus which parts just sounded reasonable in the moment.
It’s worse with confusing code, especially the vibe-coded kind, where a lot of mine is. Concepts get stacked on top of each other, and each layer only makes sense once you hold the one beneath it. When I stare at a chunk I don’t understand, the problem is almost never the thing at the top. It’s a prerequisite three layers down that I never actually grasped, and everything resting on it looks like noise.
So I built a loop inside Claude Code that finds the specific layer I’m missing, tests whether I actually know it, drills the weak spots, and remembers the gaps after the session ends. The hub is a single skill called learn. It hands off to lab-creator and grader when needed, and break-it handles load-measurable system-design concepts on its own. None of them is a command I have to remember. They fire based on what I say.
Find the real gap: learn
The concept you think you’re missing is rarely the one you’re actually missing. You point at the top of the stack and say “I don’t get how this works,” but the real crack is in a prerequisite you’d never think to question.
So learn doesn’t take my word for where the confusion is. I point it at a file, a directory, a URL, a topic, or just the conversation. It builds a dependency stack of load-bearing concepts internally, then probes me one concept at a time, asking me to explain each in my own words. It never shows me the stack or how many concepts there are. That pile is what makes this overwhelming.
When I get something wrong, it doesn’t stop and teach. It drills down into that concept’s prerequisites, hunting for the lowest layer I don’t actually hold. That bottom layer is the real gap. Everything above it was the symptom.
Once it finds the gaps, it pauses and asks for my go-ahead before acting. For each gap, it asks how I want to learn it: walk through how it shows up in my actual code, build a lab, write an exam, or log it as a blind spot for later.
Fan out: walkthroughs, labs, exams, logging
After I approve the plan, learn routes each gap the way I picked:
- walkthrough → it explains, inline, how that concept actually shows up in my code, citing real
file:lineinstead of a generic textbook explanation. - lab → it hands off to
lab-creatorto scaffold a hands-on exercise. - exam → it writes a standalone exam to disk and stops, so I can take it cold later.
- log → it writes the blind spot straight to my skills tracker.
When it writes an exam, the questions go in a QUESTIONS.md and the answer key goes in a separate ANSWER.md. That separation is the whole point. The answers live in a different file, so I can take the exam cold days later instead of right after the conversation that primed me.
Take it cold: grader
Later, I say “grade me” and point it at the exam or lab. grader serves one question at a time and scores each answer against ANSWER.md as green, yellow, or red. The questions aren’t recall prompts. They’re probes designed to make me think rather than recite:
- Predict the failure mode: “Describe a scenario where this breaks. What assumption has to be wrong?”
- Boring version: “Explain it without the jargon, what’s the underlying mechanism?”
- Distinguish from the neighbor: “How is this different from the adjacent concept, and when does the difference matter?”
Anything below green drops into a re-test pool and comes back rephrased. A concept gets three total attempts; if it never goes green, it’s logged as a persistent gap. I can’t fake my way through, because every answer gets pushed on, and the ones I’m shaky on keep returning in new forms until I get them or the system gives up for the day.
For labs, grader also runs a predict-your-score calibration check before grading. Being certain you’d pass and failing is its own kind of blind spot.
Drill the weak spot: lab-creator
For a hands-on gap, learn invokes lab-creator to scaffold an exercise: for code, a stub plus runnable unit tests; for a concept, a set of graded scenarios. I fill it in, then say “grade me” with the lab path, and grader scores it.
Break load limits: break-it
For system-design concepts where the failure mode is measurable under load (connection pools, missing caches, N+1 queries), break-it scaffolds a disposable Go + k6 lab. I predict where it breaks, run it, watch it fail, patch in the pattern, and re-run. The measured threshold gets logged to the skills tracker.
Triggering by conversation, not commands
Wiring these as skills instead of slash commands matters more than it sounds. “Help me learn this file” starts the diagnosis. “Grade me” pulls up the exam. “Give me an exercise on X” jumps straight to a lab. “Break it” starts a load test. I don’t have to remember that a command exists or what flags it takes. I just talk, and the right skill fires.
A command is something you remember to type. A skill is something that fires when you need it. A tool you have to remember is a tool you stop using.
Everything I struggle with also feeds a running skills tracker in the background, so the gaps don’t vanish when the session ends. They show up to bias the next diagnosis toward what I still haven’t locked in.
Why this works
The gap between “I got quizzed” and “I actually learned” is the quality of the feedback. A multiple-choice score tells you which letter you picked. It doesn’t tell you whether you understand why. So the loop never gives me a letter. It finds the layer where my understanding bottoms out, makes me explain it, pushes on the explanation, and drills whatever cracks under pushing.
And separating the question-writing from the grading keeps the test honest. If it quizzed me right after the conversation, I’d be parroting back things still echoing in my head. Questions and answers in different files, taken on different days, means I’m testing understanding, not short-term recall.
Takeaway
The point isn’t to feel productive. It’s to find the specific places where my understanding is thinner than I think it is, and to feel the gap between my confidence and my actual grasp. A conversation makes you feel like you learned something. A probe you can’t answer, a lab you were sure you’d ace and didn’t, those tell you what you actually know.
The skills live in my skills repository. Install with npx skills@latest add devinat1/skills, include setup-devinat1-skills, and run /setup-devinat1-skills once per project so the learning loop knows where your skills tracker lives. The hub skill is at skills/learning/learn/SKILL.md.