What This Does

This playbook helps you create complete e-learning courses by breaking the process into distinct phases, each with its own Claude Code skill. You plan the curriculum, outline modules, write individual lessons, create assessments, and compile everything into a publishable format. Inspired by a Reddit user who built a full skills-based pipeline for e-learning course creation.

Prerequisites

Claude Code installed and configured
Subject matter expertise or reference materials for your course topic
Optional: An LMS platform (Teachable, Thinkific, etc.) for publishing

The CLAUDE.md Template

Copy this into a CLAUDE.md file in your course project folder:

# E-Learning Course Creator

## Goal
Create comprehensive e-learning courses through a structured multi-phase pipeline. Each phase builds on the previous one to produce polished, pedagogically sound course content.

## Directory Structure
- `brief/` — Course brief and target audience definition
- `curriculum/` — Course outline, module structure, learning objectives
- `lessons/` — Individual lesson content files
- `assessments/` — Quizzes, exercises, and assignments per module
- `assets/` — Supporting materials (diagrams, checklists, templates)
- `output/` — Final compiled course materials ready for publishing
- `reference/` — Source materials and research

## Phase 1: Course Planning
Skill: Curriculum Designer
1. Define target audience, prerequisites, and skill level
2. Establish learning outcomes (what students can DO after the course)
3. Break the course into modules (5-8 modules recommended)
4. Define learning objectives per module (2-4 per module)
5. Save to `curriculum/course-outline.md`

## Phase 2: Module Design
Skill: Module Architect
1. For each module, create a detailed lesson plan
2. Each module has 3-5 lessons
3. Each lesson follows: Concept → Example → Practice → Summary
4. Identify prerequisites and dependencies between lessons
5. Save to `curriculum/module-XX-plan.md`

## Phase 3: Lesson Writing
Skill: Content Writer
1. Write each lesson as a standalone markdown file
2. Include: introduction, key concepts, examples, visual aids (described), key takeaways
3. Use clear headers, bullet points, and callout boxes
4. Target 1,000-2,000 words per lesson
5. Include transition hooks to the next lesson
6. Save to `lessons/module-XX/lesson-XX.md`

## Phase 4: Assessment Creation
Skill: Assessment Designer
1. Create a quiz for each module (5-10 questions)
2. Mix question types: multiple choice, short answer, practical exercises
3. Include answer keys with explanations
4. Create one capstone project or final assessment
5. Save to `assessments/module-XX-quiz.md`

## Phase 5: Review & Polish
Skill: Course Reviewer
1. Check consistency across all modules and lessons
2. Verify learning objectives are addressed
3. Review difficulty progression (easy → hard)
4. Check for gaps, redundancies, and unclear explanations
5. Generate a course summary document
6. Save review notes to `output/review-notes.md`

## Rules
1. Every lesson must map to at least one learning objective
2. Use plain language — aim for 8th grade reading level unless topic requires otherwise
3. Include practical examples for every abstract concept
4. Each module should be completable in 30-60 minutes
5. Assessments should test application, not just recall

## Commands
- "/plan [topic]" — Start Phase 1: create course outline for the given topic
- "/design module [N]" — Run Phase 2 for a specific module
- "/write lesson [module] [lesson]" — Run Phase 3 for a specific lesson
- "/assess module [N]" — Run Phase 4: create assessment for a module
- "/review" — Run Phase 5: full course review
- "/compile" — Package all materials into final output format
- "/status" — Show progress across all phases and modules

Step-by-Step Setup

Step 1: Create the project structure

mkdir -p ~/course-creator/{brief,curriculum,lessons,assessments,assets,output,reference}
cd ~/course-creator

Step 2: Define your course brief

Create brief/course-brief.md:

# Course Brief

## Topic
Introduction to Data Analysis with Python

## Target Audience
Business professionals with no coding experience who want to analyze data

## Prerequisites
- Basic spreadsheet skills (Excel or Google Sheets)
- Comfort with numbers and basic statistics

## Desired Outcome
Students can load, clean, analyze, and visualize business data using Python and pandas

## Duration
6 modules, ~4 hours total

Step 3: Add reference materials (optional)

Place any source materials in the reference/ folder — PDFs, articles, existing course outlines, or expert notes that Claude should reference.

Step 4: Save CLAUDE.md and start planning

cd ~/course-creator
claude

Try: "/plan Introduction to Data Analysis with Python"

Example Usage

Plan the entire course:

"/plan — Read the course brief and create a full course outline with 6 modules, learning objectives for each, and a recommended lesson sequence."

Design a specific module:

"/design module 3 — Create a detailed lesson plan for Module 3 (Data Cleaning). Break it into 4 lessons with specific topics, examples, and exercises."

Write a lesson:

"/write lesson 3 2 — Write Module 3, Lesson 2: Handling Missing Data. Include a real-world business scenario as the running example."

Create assessments:

"/assess module 3 — Create a quiz with 8 questions covering all learning objectives from Module 3. Include a practical exercise using a sample dataset."

Review everything:

"/review — Review all completed modules for consistency, difficulty progression, and coverage of learning objectives. Flag any gaps."

Check progress:

"/status — Show me which modules are planned, which lessons are written, and which assessments are complete."

Tips

Start with outcomes: Define what students should be able to DO, not just KNOW. "Analyze a CSV file" is better than "Understand data analysis."
One concept per lesson: Each lesson should teach one core idea with variations. Don't overload lessons.
Use the phases in order: The pipeline is sequential for a reason. Planning before writing prevents structural rewrites.
Add your expertise: Claude writes the structure and fills in content, but your domain knowledge makes it accurate. Review and correct before publishing.
Batch similar work: Write all lesson plans (Phase 2) before writing any lessons (Phase 3). This catches structural issues early.

Troubleshooting

Problem: Lessons feel too generic or surface-level

Solution: Add more reference materials to the reference/ folder. The more source material Claude can draw from, the more specific and accurate the lessons will be. Also, provide feedback on early lessons to calibrate the depth.

Problem: Modules vary wildly in length or difficulty

Solution: Run the /review command to check consistency. Specify word count targets (1,000-2,000 words per lesson) and time targets (30-60 minutes per module) in your prompts.

Problem: Assessments don't match lesson content

Solution: Always run assessment creation after lesson writing is complete for that module. Point Claude to the specific lesson files when creating quizzes.

E-Learning Course Creator