- Getting Started
- Starting a New Learning Project
- Resuming Your Learning
- Daily Learning Workflow
- How Teaching Works
- End-of-Session Reflection
- Skills Reference
- How Agents Work Behind the Scenes
- Using BodhiKit with Books and Courses
- Learner Profile
- Understanding Your Progress
- How Spaced Repetition Works
- Example Project
- Tips for Effective Learning
- Philosophy
Install BodhiKit:
/plugin marketplace add https://codeberg.org/AnjanJ/bodhikit.git
/plugin install bodhikit@bodhikit
Restart Claude Code after installing.
Context tip: BodhiKit loads 15 knowledge bases. To keep other projects lean, enable it only where you need it. Add to your learningWithBodhi/.claude/settings.json:
{
"enabledPlugins": {
"bodhikit@bodhikit": true
}
}And disable it in projects where you do not need it via .claude/settings.local.json:
{
"enabledPlugins": {
"bodhikit@bodhikit": false
}
}Start your first learning project:
/bodhikit:learn python
BodhiKit will ask you questions to understand your background, goals, and current skill level. Then it will create a personalized learning plan and give you your first exercise.
Use /bodhikit:learn <topic> to start learning anything:
/bodhikit:learn react
/bodhikit:learn rust
/bodhikit:learn system design
/bodhikit:learn web development
/bodhikit:learn zig
- Topic Discovery — BodhiKit asks clarifying questions about what you want to learn, why, and your timeline
- Skill Assessment — A series of adaptive questions to understand where you stand (not a test, an exploration)
- Plan Generation — A personalized learning plan with phases, modules, exercises, and spaced review checkpoints
- Project Setup — Creates a
learningWithBodhi/<project-name>/folder with tracking files - First Exercise — You get something to DO immediately, not just something to read
You can have as many learning projects as you want. Each lives in its own folder under learningWithBodhi/. One session should focus on one project at a time.
Use /bodhikit:continue to pick up where you left off:
/bodhikit:continue # Auto-detect or choose from active projects
/bodhikit:continue react-fundamentals # Resume a specific project
BodhiKit will:
- Show a quick status check (project, module, streak, concepts due)
- Find your active projects and show where you left off
- Check if any concepts are due for spaced review
- Offer options: continue current module, practice, or something else
- Auto-invoke
/teachwhen you continue with the next module - Auto-invoke
/reflectwhen you say goodbye
This works across sessions. Your progress is saved in .bodhi/ files.
A typical learning session with /bodhikit:continue:
- Status: Quick 3-line check-in (auto)
- Review: Spaced review of due concepts (auto, if any are due)
- Teach: Guided teaching of the next concept (auto, when you choose to continue)
- Practice: Hands-on exercise on the concept you just learned (auto, within /teach)
- Quiz: Quick retention check (auto, within /teach)
- Reflect: End-of-session reflection (auto, when you say goodbye)
You can also invoke any skill directly at any time. The auto-invocation just means /continue handles the full flow for you.
You do not need to follow this exact order. Use whatever skills feel right for your session.
When you choose to continue with the next module (or run /bodhikit:teach directly), BodhiKit follows the Gradual Release of Responsibility model:
-
I Do (Modeling) — BodhiKit explains the concept with analogies, concrete code examples, and connects it to what you already know. It shows WHY the concept matters, not just what it does.
-
We Do (Guided Practice) — You and BodhiKit work through a problem together. It asks guiding questions: "How would you start? What data structure fits here?" You make the decisions, it keeps you on track.
-
You Do (Independent Practice) — BodhiKit gives you an exercise calibrated to your level. Beginners get starter files with TODO comments. Advanced learners get a problem statement only. You solve it yourself.
-
Verify — Quick retention check: 2-3 questions to confirm the concept stuck. Concepts are added to spaced repetition tracking.
The key rule: BodhiKit never lectures for more than 5 minutes without interaction. It is a conversation, not a presentation.
When you say goodbye, BodhiKit auto-invokes /reflect to run a brief metacognitive reflection. This takes 3-5 minutes and multiplies the value of the entire session.
It asks:
- What felt hardest today? — Identifies concepts that need more time
- Was anything easier than expected? — Calibrates your self-assessment
- Confidence rating (1-10) — Low confidence concepts get scheduled for review sooner
- What would you do differently? — Builds strategic thinking about learning itself
Why this matters: research shows learners who reflect on their learning process retain 20-30% more. Your confidence rating feeds directly into the spaced repetition system, so concepts you are unsure about get reviewed sooner.
Start a new learning project. Creates a personalized plan based on your assessment.
Resume from where you left off. Auto-invokes /status, /teach, and /reflect for a complete guided session. Works across sessions.
Proactive guided teaching. Walks you through a concept step by step: explains it, demonstrates with code, works through a problem together, gives you an exercise, then verifies retention. Auto-invoked by /continue.
Standalone skill assessment. Get your Bloom's taxonomy level for any topic without starting a full project.
Educational code review. Analyzes what your code reveals about your understanding. Works with local files, GitHub, GitLab, and Codeberg URLs.
Quick knowledge check. 5-7 adaptive questions. Updates spaced repetition tracking. Uses active recall.
Manage your learning plan. View current state, adjust modules, or regenerate from scratch.
View your progress dashboard. Module completion, Bloom's levels, streaks, spaced review health.
Find verified free resources, add your own materials (books, courses), or list what you have.
Deep-dive using the Feynman technique. BodhiKit explains simply, then asks you to explain back. Identifies and fills gaps.
Get a hands-on exercise calibrated to your level. Beginners get starter files, advanced learners get problem statements.
Comprehensive evaluation of your entire learning journey. Compares where you started to where you are now.
End-of-session metacognitive reflection. Asks what was hardest, what surprised you, and your confidence rating. Feeds data back into spaced repetition scheduling. Auto-invoked by /continue when you say goodbye.
Quick 3-line check-in: current project, module, streak, and concepts due today. Auto-invoked by /continue at session start.
Career and learning path guidance. Uses the GROW model (Goal, Reality, Options, Will) and Kram's mentoring theory. Reads your learner profile and all learning projects to map your skill landscape against your career goals. Presents 2-3 concrete learning path options and lets you choose. Honest about what an AI cannot do (sponsorship, networking). Auto-invoked by /evaluate when you complete a major milestone.
Example: After finishing your React project, run /bodhikit:mentor and it will assess your full-stack readiness, suggest whether to learn Node.js, Rails, or go deeper in React, and offer to start the next project.
Pair programming with BodhiKit as your partner. Three research-backed modes:
- strong-style (beginners): BodhiKit describes what to build, you type it. Forces explicit communication. Based on Falco's coaching method.
- ping-pong (intermediate): BodhiKit writes a failing test, you make it pass. Then you write the next test. Teaches TDD naturally.
- navigate (advanced): You describe the approach, BodhiKit follows your lead and asks strategic questions.
Mode auto-selects based on your Bloom's level, or you can choose. Auto-invoked by /teach during guided practice. After 15-20 minutes, roles reverse to exercise both tactical and strategic thinking.
Scientific debugging that teaches the process, not just the fix. Based on Zeller's TRAFFIC method: reproduce the bug, form a hypothesis, insert a probe (not a fix), evaluate the result, isolate the root cause, then correct. BodhiKit never fixes bugs for you. It catches novice anti-patterns (random code changes, print statements without hypothesis, ignoring error messages) and redirects to systematic investigation.
Example: Your todo delete button does not work. Instead of looking at the code, BodhiKit asks "What did you expect? What happened? What is your theory?" Then guides you to add a targeted probe, trace the data upstream, and find the real cause yourself. Auto-invoked by /practice and /teach when your code has bugs.
BodhiKit maintains a cross-project learner profile at learningWithBodhi/.bodhi-profile.json. This stores:
- Your career goals and learning motivations
- Overall Bloom's levels across all topics
- Cumulative stats (total sessions, concepts mastered, longest streak)
- Learning style preferences discovered over time
The profile is created when you start your first learning project and updated as you progress. It allows BodhiKit to personalize guidance across different projects and power the /mentor skill.
BodhiKit uses three specialized AI agents that handle complex tasks. You never invoke agents directly. Skills launch them automatically when needed.
Used by: /learn, /assess, /evaluate, /plan (regenerate mode)
When BodhiKit needs to understand your skill level, it launches the skill-assessor agent. This agent runs in a separate context so it does not clutter your main conversation. It asks 8-12 adaptive questions, starting at Bloom's Level 3 and adjusting up or down based on your answers. It classifies your level per sub-topic with a confidence rating (HIGH/MEDIUM/LOW) and returns a structured assessment.
Example: When you run /bodhikit:learn react, the skill-assessor takes over for Phase 2. It asks you about JSX, components, state, hooks. If you answer the components question easily, it escalates to a harder one. If you struggle with hooks, it de-escalates. After 8-10 questions, it returns: "JSX: Level 2, Components: Level 3, Props: Level 1, State: Level 0, Hooks: Level 0" with confidence ratings. This shapes your entire learning plan.
Used by: /review, /practice (review loop), /teach (after exercises)
When BodhiKit reviews your code, it launches the code-reviewer agent. This is NOT a production code review. The agent analyzes what your code reveals about your understanding: what concepts you demonstrate mastery of, what misconceptions are visible, what patterns you are ready to learn next, and where your Zone of Proximal Development sits.
Example: You complete a React exercise and the code works. The code-reviewer notices you used a for loop where map would be idiomatic, and that you mutated state directly instead of using spread syntax. Instead of saying "use map and spread," it returns Socratic questions: "What do you know about array methods like map?" and graduated hints if needed.
Used by: /resources (find mode)
When you need learning materials, the resource-finder agent searches the web for verified, community-recommended free resources. It prioritizes official documentation, interactive platforms (Exercism, freeCodeCamp), and structured courses over random blog posts. It verifies each link is live and returns resources with title, type, difficulty level, and estimated time.
Example: You run /bodhikit:resources find rust. The agent searches for Rust learning materials, verifies links, and returns: The Rust Book (official docs), Rustlings (interactive exercises), Exercism Rust Track (practice problems), and a few curated tutorials, ranked by interactivity and community reputation.
BodhiKit works as a teaching assistant alongside your existing learning materials:
/bodhikit:resources add "Eloquent JavaScript"
/bodhikit:resources add https://www.udemy.com/course/your-course
BodhiKit will:
- Analyze the material's structure (chapters, syllabus)
- Map it to your learning plan modules
- Ask how you want to use it: as primary material, supplement, or reference
If you are following a book or course, BodhiKit can:
- Explain concepts from the book in different ways (when the book's explanation does not click)
- Quiz you on what you read/watched
- Give you extra practice exercises on the same topics
- Review your code from the book's exercises
- Fill gaps the material does not cover
BodhiKit tracks your skill level per concept using Bloom's Taxonomy:
| Level | Name | What It Means |
|---|---|---|
| 1 | Remember | You have heard of this but cannot use it yet |
| 2 | Understand | You understand the idea but need practice applying it |
| 3 | Apply | You can use this with some guidance |
| 4 | Analyze | You can work with this independently and debug issues |
| 5 | Evaluate | You can evaluate approaches and make design decisions |
| 6 | Create | You can design novel solutions and teach others |
A concept is considered mastered when:
- Bloom's Level 4 or higher
- 3 consecutive correct quiz answers
- Spaced repetition Box 4 or 5
- Can explain it to someone else (Feynman check)
BodhiKit uses a virtual Leitner box system to schedule concept reviews:
| Box | Review After | Meaning |
|---|---|---|
| 1 | 1 day | New or forgotten |
| 2 | 3 days | Recalled once |
| 3 | 7 days | Building retention |
| 4 | 14 days | Strong retention |
| 5 | 30 days | Long-term mastery |
- Get a concept right: it moves up one box (reviewed less often)
- Get it wrong: it drops back to Box 1 (reviewed tomorrow)
- When you run
/continue, BodhiKit checks what is due for review
This is automatic. You do not need to manage it.
Want to see what a learning project looks like after a few sessions? Check out docs/example-project/ in the BodhiKit repository.
It contains realistic .bodhi/ tracking files for a "React Fundamentals" learner who has completed 5 sessions:
state.json— 5 sessions, 3-day streak, working on Module 2.1 (State and Hooks)spaced-review.json— 8 concepts across different Leitner boxes (Box 1 through Box 4)progress.md— 3 completed modules, 1 in progress, with Bloom's levels and mastery percentagesplan.md— 3-phase learning plan with 9 modulesassessment.md— Initial assessment and a quiz recordresources.md— 3 curated resources (React docs, freeCodeCamp, Exercism)
This gives you a clear picture of what to expect before you start your own learning project.
- Consistency beats intensity. 30 minutes daily is better than 5 hours once a week.
- Struggle is learning. If it feels hard, you are growing. If it feels easy, you are reviewing.
- Explain what you learn. The Feynman technique is your best tool. If you cannot explain it simply, you do not understand it yet.
- Do not skip reviews. Spaced repetition only works if you do the reviews when they are due.
- Write the code yourself. Do not copy from BodhiKit or from examples. Type it. Change it. Break it. Fix it.
- Take breaks. Your brain does important work during rest. After focused learning, walk away for a few minutes.
- Trust the process. Some days will feel unproductive. Growth is often invisible. Keep showing up.
BodhiKit is built on a simple belief: everyone can learn to code, and the best way to learn is by doing, with a wise guide by your side.
The plugin does not write code for you. It asks questions, gives hints, creates exercises, and reviews your work. The goal is not to be needed forever. The goal is to help you reach the point where you do not need it anymore.
"The obstacle is the path."