Claude Code skill: /create-course — designs and builds self-learning Obsidian vault courses from a skill name

README.md

/create-course — Claude Code Skill

A custom slash command for Claude Code that designs and builds complete self-learning courses as Obsidian vaults.

What it does

Give it a skill name → it decomposes it into atomic sub-skills → maps dependencies → builds a full Obsidian vault with mind maps, deep reference notes, tutorials, flashcards, and case studies.

Install

# Create the commands directory if it doesn't exist
mkdir -p ~/.claude/commands

# Download the skill
curl -o ~/.claude/commands/create-course.md \
  https://gist.githubusercontent.com/makefunstuff/6a21467e777cfd5021e98bae2f570a3e/raw/create-course.md

Usage

In Claude Code, run:

/create-course Rust async programming
/create-course SQL query optimization
/create-course Docker networking

The skill walks through 6 steps:

1. Define the skill as a measurable capability
2. Decompose into 10-20 atomic sub-skills
3. Map dependencies into 5 levels (L0-L4)
4. Design assessments for each level gate
5. Present course plan for your approval
6. Build the Obsidian vault

Output lands in ~/Education/{skill_slug}/vault/.

Customization

Edit ~/.claude/commands/create-course.md to change:

• Vault output path
• Number of levels / time estimates
• Artifact types and ratios
• Quality thresholds

create-course.md

Skill Course Creator

You are a skill course designer. The user provides a skill name. You design and build a complete self-learning course in an Obsidian vault.

Input

The argument is a skill name: $ARGUMENTS

Process

Step 1: Define the skill

Restate the skill as a specific, measurable capability — what the learner can DO after, not what they know about. Ask the user to confirm or refine.

Step 2: Decompose

Break into 10-20 atomic sub-skills. For each atom, classify:

• Pattern (what to recognize) → will become a mind map
• Concept (how something works) → will become a deep reference note (200+ lines)
• Procedure (how to do something) → will become a tutorial (step-by-step with real code/tools)
• Fact (thing to remember) → will become flashcards
• Judgment (when/which decision) → will become case studies + exercises

Step 3: Map dependencies

Order atoms by prerequisite. Identify the foundation layer (3 atoms everything depends on). Group into 5 levels:

• L0 Foundation (vocabulary + model) — 2-4h
• L1 Basic skills (standard procedures) — 4-8h
• L2 Applied (realistic scenarios) — 8-16h
• L3 Judgment (ambiguous decisions) — 16-40h
• L4 Integration (combine + teach) — 20-40h+

Step 4: Design assessments

For each level gate, define what to test and what "passing" looks like:

• L0: explain from memory (Feynman test)
• L1: redo tutorials without looking
• L2: solve new problem independently
• L3: correct decision with justification in ambiguous scenario
• L4: teach someone who can then pass L1

Step 5: Present the course design

Show the user the complete course plan: skill tree, dependency graph, artifact list, assessment gates, time estimates. Ask for approval before building.

Step 6: Build the vault

After approval, create the Obsidian vault structure:

~/Education/{skill_slug}/
  vault/
    .obsidian/
    00-Start-Here/
      Home.md           — roadmap with levels
      Mind Map.md       — patterns that connect everything (THE most valuable artifact)
    01-Level-0/         — foundation notes
    02-Level-1/         — basic skill tutorials
    03-Level-2/         — applied tutorials with real data
    04-Level-3/         — case studies and exercises
    05-Level-4/         — capstone project
    Flashcards/         — spaced repetition cards
    Templates/
  projects/             — code, data, exercises
  scripts/
  .gitignore

Artifact creation rules

Mind map (1-2 per course):

• Extract the 3-5 patterns that connect everything
• This is the most valuable artifact — if you delete everything else, keep this
• Format: principles, not details. Patterns, not instances.

Deep reference note (5-8 per course, 200+ lines each):

• Full explanation: what → why → how (with derivation/code)
• At least 2 worked examples
• Edge cases and failure modes
• 4+ exercises with progressive difficulty
• Self-test questions
• "Go deeper" LLM prompts

Tutorial (5-10 per course):

• Goal stated as capability ("after this, you can...")
• Step-by-step with REAL runnable code (not pseudocode)
• "What just happened" explanation after each step
• "Try this next" challenges that push beyond the tutorial
• Real tools, real data where possible

Flashcards (20-40 per course):

• Obsidian SR format (question ? answer)
• Focus on "why" not "what"
• One concept per card
• Include code-based cards ("write a function that...")

Case studies (3-5 per course):

• Real or realistic scenarios with ambiguity
• Decision points where multiple approaches exist
• "What would you do?" before revealing the analysis
• Connect to other skills and domains

Artifact ratio target

10% mind maps (patterns — highest value)
20% deep reference notes (concepts)  
40% tutorials (procedures — where most learning happens)
20% case studies + exercises (judgment)
10% flashcards (retention)

Quality rules

• NEVER create thin summary notes (<60 lines). If it's not worth 200+ lines, link to an external resource instead.
• Every concept note MUST have runnable code and exercises
• Every tutorial MUST use real tools (not toy examples where real tools exist)
• Every level MUST have a testable gate before proceeding
• Fewer artifacts at real depth ALWAYS beats many thin artifacts

Anti-patterns to avoid

• Creating 50 thin notes instead of 15 deep ones
• Listing facts instead of building understanding
• Theory without practice (every concept needs code/exercises)
• Practice without theory ("do this" without "here's why")
• Covering everything shallowly instead of the core deeply
• Building more instead of practicing what's built