# 25 PREMIUM AI SYSTEMS FOR E-LEARNING DEVELOPMENT

## Specialized for Instructional Designers Using Articulate, Moodle, & Custom Platforms

---

This file is viewed best with [MarkText](https://marktext.me/) markdown editor (free, for Windows, macOS)

## **HOW TO USE THIS ENTIRE LIBRARY:**

**Each system is a standalone workflow**

1. Read "Why This Matters" (understand the problem)
2. Understand "Strategic Framework" (see the thinking)
3. Copy "The Prompt" section (paste into AI)
4. Follow "Workflow" (when to use this)
5. Use "Checklist" (verify it worked)
6. Study "Real Example" (see it in action)

## Action: Copy the prompt, paste into AI, fill in your situation, get results.

---

# E-LEARNING DEVELOPMENT SYSTEMS (25 Specialized Systems)

---

## SYSTEM 51 (or 1): The Articulate Storyline Project Setup System

**📌 WHY THIS MATTERS:**
Starting wrong in Storyline wastes hours later. This system sets up your project architecture so development is smooth.

**Strategic Framework:**

```
Project Structure → Slide Organization → Naming Convention → Templates → Master Slides
(Proper setup = 30% faster development + 0 rework)
```

**THE PROMPT (Copy this entire text):**

```
I'm starting a new Articulate Storyline project:

Project name: [PROJECT NAME]
Course length: [MINUTES/HOURS]
Number of modules: [NUMBER]
Complexity: [SIMPLE/MODERATE/COMPLEX]
Team size: [1 person / multiple people]

Create a Storyline project setup guide:

1. PROJECT STRUCTURE:
   - Should I use Scenes? (Yes if more than 30 slides)
   - How many Scenes?
   - How to organize by topic/module?

2. SLIDE NAMING CONVENTION:
   - What naming system prevents confusion?
   - Example: "01-Intro-WelcomeSlide" vs. "Slide 1"?
   - Should I include slide type in name?

3. MASTER SLIDE SETUP:
   - What master slides do I need?
   - One master per module? Or universal?
   - How do I set up for branding consistency?

4. TEMPLATE SLIDES:
   - What template slides save time?
   - Content slide template?
   - Quiz template?
   - Scenario template?

5. PLAYER SETUP:
   - What controls should learners have?
   - How many buttons (next/prev/menu)?
   - Mobile compatibility from start?

6. ASSET ORGANIZATION:
   - Where to store media files?
   - File naming for 50+ images?
   - How to link vs. embed?

For each element, provide:
- Specific recommendation
- Why it matters
- Step-by-step setup in Storyline

Return as: Complete Storyline setup checklist.
```

**Workflow: When to Use This**
Use THIS FIRST, before creating ANY slides in Storyline. Prevents hours of rework.

**Implementation Checklist:**

- [ ] Project structure planned?
- [ ] Slide naming convention decided?
- [ ] Master slides created?
- [ ] Template slides built?
- [ ] Player customized for your course?
- [ ] Asset organization system established?
- [ ] Team/stakeholders approve structure?

**Real Example:**
Customer: 2-hour Leadership Course in Storyline

- Structure: 4 Scenes (Module 1-4), each with 15-20 slides
- Naming: "01-Module1-Concept-SlideTitle" (clear, sorts alphabetically)
- Master: 1 master for consistency + module-specific colors
- Templates: Content (standard layout), Quiz (multiple choice), Scenario (decision point)
- Player: Next/Prev/Menu visible, mobile-responsive from start
- Assets: Folder structure: Images/Videos/Audio/Characters (50+ files organized)
- Result: Development 30% faster, zero rework, team stays organized

---

## SYSTEM 52 (or 2): The Interactive Element Planning System

**📌 WHY THIS MATTERS:**
Interactivity = engagement. But wrong type of interaction = confusion and drop-off.
This system chooses the RIGHT interaction for each learning objective.

**Strategic Framework:**

```
Learning Objective → Interaction Type → Complexity Level → Technical Requirements → Testing Strategy
```

**THE PROMPT (Copy this entire text):**

```
I'm building interactive e-learning:

Module topic: [TOPIC]
Learning objectives: [LIST 3-5 OBJECTIVES]
Target audience: [DESCRIBE]
Time constraints: [MINUTES PER MODULE]

Recommend interactive elements:

For EACH learning objective, recommend:

1. IF objective is "Remember" (Bloom's Level 1):
   - Click-and-reveal (simple, fast)
   - Hotspot interactions (identify elements)
   - Sequencing (put steps in order)
   - Complexity: LOW (can build in Storyline without triggers)

2. IF objective is "Understand" (Bloom's Level 2):
   - Tabs or accordion (explore content)
   - Lightboxes (detailed explanations)
   - Clickable process diagram
   - Complexity: MODERATE (needs some triggers)

3. IF objective is "Apply" (Bloom's Level 3):
   - Drag-and-drop scenarios
   - Decision points (consequence branches)
   - Fill-in-the-blank with feedback
   - Complexity: MODERATE (needs variables/triggers)

4. IF objective is "Analyze/Evaluate" (Bloom's Level 4-5):
   - Branching scenarios (multiple paths)
   - Simulations (realistic practice)
   - Case study analysis
   - Complexity: HIGH (needs advanced triggers/variables)

For EACH interaction:
- Learning objective it supports
- Interaction type
- Complexity in Storyline (easy/moderate/advanced)
- Time to build (hours)
- Time for learner to complete (minutes)
- Mobile compatibility? (yes/no/partial)
- Common mistakes to avoid

Return as: Interactive element strategy map (what to build where).
```

**Workflow: When to Use This**
Use during DESIGN phase, before opening Storyline. Prevents building interactions that don't serve learning.

**Implementation Checklist:**

- [ ] Each objective has matching interaction?
- [ ] Interaction complexity matches team skill?
- [ ] Development time estimates realistic?
- [ ] Mobile compatibility verified?
- [ ] Interactions tested for usability?
- [ ] Feedback/consequences clear for learner?

**Real Example:**
Customer: Compliance Training (4 modules)

- Objective: "Remember 5 policy violations"
  
  - Interaction: Click-and-reveal (each violation reveals consequence)
  - Complexity: LOW
  - Build time: 1 hour
  - Learner time: 5 minutes

- Objective: "Apply procedures in realistic scenario"
  
  - Interaction: Decision-point branching (3 choices, different paths)
  - Complexity: MODERATE
  - Build time: 4 hours
  - Learner time: 10 minutes

- Total: 8 interactions across 4 modules, 20 hours build time, mixed complexity

---

## SYSTEM 53 (or 3): The Branching Scenario Logic System

**📌 WHY THIS MATTERS:**
Branching scenarios are the MOST engaging e-learning. But logic mistakes = broken paths.
This system maps all possible branches before building.

**Strategic Framework:**

```
Starting Scenario → Decision Point 1 → Consequence A/B/C → Decision Point 2 → Multiple Endings → Debrief
```

**THE PROMPT (Copy this entire text):**

```
I'm building a branching scenario in Storyline:

Scenario: [DESCRIBE THE SITUATION]
Learning objective: [WHAT SHOULD LEARNER MASTER]
Number of decisions: [1-2 / 2-3 / 3+]
Paths needed: [How many different endings?]

Create a complete scenario logic map:

1. SCENARIO SETUP (Slide 1):
   - What's the realistic situation?
   - What decision must learner make?
   - How many options? (3-4 is ideal)

2. FIRST DECISION POINT:
   - Option A: [What happens if learner chooses this?]
   - Option B: [Consequence?]
   - Option C: [Consequence?]
   - For EACH option:
     - Does it lead to another decision? (or end?)
     - What's the feedback? (immediate or delayed?)

3. SECOND DECISION POINT (if applicable):
   - Does Path A have a 2nd decision?
   - Does Path B have a 2nd decision?
   - Does Path C have a 2nd decision?
   - Map all branches

4. ENDING/DEBRIEF:
   - How many unique endings?
   - What's the learning lesson at each end?
   - How do they loop back? (or course continues?)

5. TECHNICAL MAP:
   - How many slides total?
   - How many layers (overlays)?
   - How many variables needed? (to track path)
   - Triggers needed per slide?

Provide as:
- Visual flowchart (ASCII or description)
- Slide count per path
- Variable/trigger list

Return as: Complete scenario logic ready to build in Storyline.
```

**Workflow: When to Use This**
Use during DESIGN phase. Build this map BEFORE opening Storyline. Will save 5+ hours of confusion.

**Implementation Checklist:**

- [ ] All branches mapped on paper?
- [ ] No broken paths (every branch has ending)?
- [ ] Consequences are realistic/educational?
- [ ] Slide count per path realistic?
- [ ] Variables named clearly?
- [ ] Tested with different path combinations?
- [ ] Debrief explains WHY correct choice was best?

**Real Example:**
Customer: Customer Service Training Scenario

- Setup: "Angry customer complaint. You have 30 seconds to respond. What do you do?"
- Option A: Listen actively, ask clarifying questions
  - Consequence: Customer calms down, problem resolved
  - Decision 2: Offer proactive follow-up? (Yes/No)
  - Ending A1: Customer loyalty + bonus points
  - Ending A2: Customer satisfied, no bonus
- Option B: Defend company position
  - Consequence: Customer gets MORE angry
  - Decision 2: Escalate or try again? (Escalate/Try)
  - Ending B1: Manager has to fix it (bad outcome)
  - Ending B2: Customer still angry (learning: wrong approach)
- Option C: Transfer immediately
  - Consequence: Avoids problem but looks bad
  - No 2nd decision
  - Ending C: Complaint reaches supervisor (feedback: avoidance doesn't help)
- Total: 7 slides (setup + outcomes), 4 variables (path tracker, emotion, resolution, bonus), 12 triggers

---

## SYSTEM 54 (or 4): The Drag-and-Drop Activity System

**📌 WHY THIS MATTERS:**
Drag-and-drop is engaging but can confuse learners if poorly designed.
This system creates clear, intuitive drag-and-drop activities.

**Strategic Framework:**

```
Clear Labels → Obvious Targets → Helpful Feedback → Progressive Difficulty
```

**THE PROMPT (Copy this entire text):**

```
I'm creating a drag-and-drop activity:

Activity type: [Matching / Categorization / Sequencing / Sorting]
Content: [WHAT ARE THEY DRAGGING? DESCRIBE]
Number of items: [HOW MANY ITEMS TO DRAG? Ideal: 5-7]
Complexity: [SIMPLE / MODERATE / COMPLEX]

Design this drag-and-drop activity:

1. SETUP & CLARITY:
   - What's the clear instruction? (one sentence)
   - What should learner do? (drag what to where?)
   - Are labels on draggable items clear?
   - Are drop zones clearly marked?

2. DRAGGABLE ITEMS:
   - What are they dragging? (text / images / both?)
   - How many items? (5 is ideal, 3-7 acceptable)
   - Should items be randomized? (yes, prevents memorization)
   - Are items visually distinct?

3. DROP ZONES:
   - How many drop zones?
   - Is each zone clearly labeled?
   - Can you fit all items? (or incomplete-answer feedback needed?)
   - Are zones large enough (mobile-friendly)?

4. FEEDBACK:
   - Immediate feedback? (yes, tells learner right/wrong instantly)
   - Helpful feedback per wrong match? (e.g., "Not quite. Think about...")
   - What if learner gets it wrong? (allow retry? max attempts?)
   - Success feedback encouraging?

5. PROGRESSION/CHALLENGE:
   - Is this activity a warm-up? (easier)
   - Main learning activity? (moderate)
   - Challenge activity? (harder)
   - Should next activity build on this?

For this activity:
- Exact instructions (copy-paste ready)
- Draggable item list
- Drop zone labels
- Feedback for correct answers
- Feedback for common mistakes

Return as: Drag-and-drop activity brief ready for Storyline development.
```

**Workflow: When to Use This**
Use during DESIGN phase. Provide this brief to your Storyline developer (or reference when building).

**Implementation Checklist:**

- [ ] Instructions crystal clear?
- [ ] 5-7 items (not too many)?
- [ ] Drop zones clearly labeled?
- [ ] Feedback is helpful (not just "wrong")?
- [ ] Mobile-friendly (large touch targets)?
- [ ] Tested for usability?
- [ ] Learning objective met?

**Real Example:**
Customer: Sales Training - Match Features to Benefits

- Instruction: "Drag each product FEATURE on left to its customer BENEFIT on right"
- Draggable items (left, randomized each attempt):
  - "Low price"
  - "Fast customer service"
  - "Customizable"
  - "Cloud-based"
  - "No setup time"
- Drop zones (right):
  - "Saves money"
  - "Saves time"
  - "Meets unique needs"
  - "Access from anywhere"
  - "Personalized support"
- Feedback:
  - Correct: "Perfect! That's why customers choose this feature"
  - Wrong example: "Not quite. Think about what BENEFIT the customer gets from this FEATURE"
- Result: Engaging, teaches sales logic, takes 2-3 minutes

---

## SYSTEM 55 (or 5): The Mobile-First E-Learning Design System

**📌 WHY THIS MATTERS:**
50%+ of e-learning happens on phones/tablets now. Not mobile-friendly = learner drop-off.
This system ensures e-learning works perfectly on small screens.

**Strategic Framework:**

```
Responsive Design → Single Column Layout → Touch-Friendly Buttons → Fast Load Times → Testing on Real Devices
```

**THE PROMPT (Copy this entire text):**

```
I'm designing e-learning that must work on mobile:

Course: [NAME]
Platform: [Articulate / Moodle / Custom]
Target devices: [iPhone / Android / Tablets / All]
Content types: [Video / Text / Interactive / Quizzes]

Create a mobile-first design checklist:

1. LAYOUT & SPACING:
   - Is course single-column? (not side-by-side panels)
   - Are buttons large enough to tap? (minimum 44px)
   - Is text readable on small screen? (font size minimum 14pt)
   - Is padding/spacing adequate?

2. NAVIGATION:
   - How do learners navigate? (swipe / scroll / tap buttons?)
   - Is menu accessible on small screen?
   - Can they go back easily?
   - Are progress indicators clear?

3. MEDIA OPTIMIZATION:
   - Videos: Are they compressed for mobile? (not huge file sizes)
   - Images: Are they optimized? (not huge files = slow load)
   - Are video/images responsive? (scale to screen size)
   - Do videos auto-pause if signal weak?

4. INTERACTIVE ELEMENTS:
   - Are drag-and-drop controls touch-friendly?
   - Can touch replace mouse hover?
   - Are clickable areas large enough for fat fingers?
   - Do interactions break on smaller screens?

5. TEXT INPUT:
   - Are text fields large enough to tap?
   - Does keyboard push content off-screen?
   - Can learner complete forms on phone?

6. TESTING:
   - Test on real iPhone (not just emulator)
   - Test on real Android
   - Test on tablet (landscape + portrait)
   - Slow network (3G) - does it load?
   - Offline mode - what works?

For this course:
- Layout changes needed for mobile?
- Which elements need redesign?
- File size optimization needed?
- Testing plan?

Return as: Mobile-first design checklist.
```

**Workflow: When to Use This**
Use during DESIGN phase. Better to plan mobile now than redesign later.

**Implementation Checklist:**

- [ ] Single-column layout confirmed?
- [ ] Buttons 44px+ (touch-friendly)?
- [ ] Text readable on phone? (14pt+)
- [ ] Videos compressed (<10MB)?
- [ ] Images optimized?
- [ ] Tested on real iPhone?
- [ ] Tested on real Android?
- [ ] Tested on slow connection?

**Real Example:**
Customer: Microlearning Mobile Course

- Desktop: 2-column layout (sidebar + content)
- Mobile: 1-column layout (sidebar collapses to hamburger menu)
- Buttons: 50px minimum height (easy to tap)
- Text: 16pt body, 24pt headings (readable on phone)
- Videos: 2-minute max, MP4 format, 20MB max
- Images: 800px max width (scales to phone screen)
- Tested: iPhone 12, Samsung Galaxy, iPad Pro
- Result: 87% completion on mobile (vs. 62% when not mobile-optimized)

---

## SYSTEM 56 (or 6): The Video Optimization for E-Learning System

**📌 WHY THIS MATTERS:**
Videos that won't load or buffer = learner frustration = abandoned course.
This system optimizes video for reliable playback.

**Strategic Framework:**

```
Video Format → Resolution → File Size → Bitrate → Captions → Player Settings
```

**THE PROMPT (Copy this entire text):**

```
I'm embedding videos in my e-learning course:

Platform: [Articulate Storyline / Moodle / Custom LMS]
Number of videos: [HOW MANY]
Video length: [MINUTES EACH]
Target bandwidth: [Assume learners on 3G / 4G / WiFi?]
Captions needed: [YES / NO]

Create a video optimization strategy:

1. VIDEO FORMAT:
   - Best format for e-learning? (MP4 H.264)
   - Codec recommendations?
   - Frame rate? (24fps / 30fps?)

2. RESOLUTION & FILE SIZE:
   - What resolution target? (1280x720 for desktop? 640x360 for mobile?)
   - Target file size per minute? (3-5MB is good)
   - How do I compress without losing quality?
   - Should I offer multiple resolutions? (adaptive streaming)

3. BITRATE:
   - Audio bitrate? (128kbps is standard)
   - Video bitrate? (calculate based on file size target)
   - Formula for bitrate?

4. CAPTIONS:
   - Required by law? (ADA / WCAG standards)
   - Should captions be burned-in? (or separate .srt file?)
   - How do I generate captions? (automated or manual)

5. PLAYER SETTINGS:
   - Should video auto-play? (no - learner chooses)
   - Should learner be able to skip? (usually yes)
   - Volume controls needed?
   - Playback speed control? (useful for learning)
   - Fullscreen mode available?

6. DELIVERY:
   - Where to host? (on LMS / YouTube private / Vimeo)
   - CDN needed for fast delivery? (if targeting global)
   - Backup if streaming fails?

For EACH video:
- Current size?
- Optimized size target?
- Compression steps?
- Caption plan?

Return as: Video optimization checklist.
```

**Workflow: When to Use This**
Use before uploading videos to course. Optimize BEFORE publishing.

**Implementation Checklist:**

- [ ] Format: MP4 H.264?
- [ ] Resolution optimized for platform?
- [ ] File size <5MB per minute?
- [ ] Bitrate calculated correctly?
- [ ] Captions included?
- [ ] Player controls appropriate?
- [ ] Tested playback on slow connection?

**Real Example:**
Customer: 10 Training Videos for E-Learning

- Original: 1080p, 50-100MB each (way too large)
- Optimized:
  - Resolution: 720p desktop, 360p mobile
  - File size: 15-25MB per 3-minute video
  - Bitrate: 1.5Mbps video, 128kbps audio
  - Captions: Automated + manual review
  - Player: Auto-play OFF, playback controls enabled
  - Result: Smooth playback on 3G + WiFi, accessible with captions

---

## SYSTEM 57 (or 7): The Knowledge Check Question Design System

**📌 WHY THIS MATTERS:**
Boring knowledge checks = learners rush through. Well-designed checks = engagement + learning verification.
This system creates engaging, non-graded knowledge checks.

**Strategic Framework:**

```
Quick Question → Immediate Feedback → Encouragement → No Penalty → Guides Learning Forward
```

**THE PROMPT (Copy this entire text):**

```
I'm creating knowledge check questions (ungraded comprehension checks):

Module topic: [TOPIC]
Key concept: [WHAT MUST THEY UNDERSTAND]
Learner experience: [BEGINNER / INTERMEDIATE / ADVANCED]

Create 3 knowledge check questions:

For EACH question:

1. QUESTION FORMAT:
   - Question type? (multiple choice / true-false / fill-blank)
   - Should it test application or just recall? (application is better)
   - Is question clear and unambiguous?

2. CORRECT ANSWER:
   - What's the right answer?
   - Why is it right? (clear explanation)

3. INCORRECT OPTIONS (for multiple choice):
   - Common misconception? (realistic wrong answer)
   - Almost-right answer? (tests deep understanding)
   - Plausible wrong answer?

4. FEEDBACK:
   - If correct: "Great! Here's why..." (encouraging)
   - If wrong: "Not quite. Here's the right thinking..." (helpful, not punishing)
   - Does feedback point back to content? (or just say "wrong")

5. ENGAGEMENT:
   - Is question interesting? (not boring/obvious)
   - Does it relate to learner's job/life? (relevant)
   - Should there be an image/scenario? (yes = more engaging)

For this module:
- 3 knowledge checks at strategic points
- Questions should take <1 min each
- Not graded (no consequences for wrong answer)
- Helpful feedback guides them to right thinking

Return as: 3 knowledge check questions with complete feedback.
```

**Workflow: When to Use This**
Use during DEVELOPMENT phase. Place 1 check per key concept section.

**Implementation Checklist:**

- [ ] Questions test application, not just memory?
- [ ] Incorrect options are plausible?
- [ ] Feedback is encouraging?
- [ ] Feedback points back to content?
- [ ] Questions are scenario-based (not just text)?
- [ ] Tested for clarity?

**Real Example:**
Customer: Project Management E-Learning

- Module: "Creating Timelines"
- Knowledge check 1:
  - Question: "Your team estimates 5 days per task. What should your timeline be?" (with scenario)
  - Options: a) 5 days (no, doesn't account for delays) b) 7-10 days (yes, buffer) c) 15 days (too conservative)
  - Feedback if correct: "Right! Always add 30-50% buffer for delays"
  - Feedback if wrong: "Underestimating causes delays. Think about what can go wrong..."

---

## SYSTEM 58 (or 8): The Scenario-Based Learning Path System

**📌 WHY THIS MATTERS:**
E-learning scenarios that branch based on learner choices = highest engagement.
This system designs learning paths that adapt to decisions.

**Strategic Framework:**

```
Realistic Scenario → Learner Decision → Consequence Shows → New Scenario → Reinforces Learning
```

**THE PROMPT (Copy this entire text):**

```
I'm building a scenario-based learning path:

Context: [DESCRIBE THE JOB/SITUATION]
Learning goal: [WHAT SHOULD THEY MASTER]
Scenario length: [5 min / 10 min / 15 min total]
Decision points: [1-2 / 2-3 / 3+]

Design a learning path scenario:

1. SCENARIO SELECTION:
   - What's a realistic situation they'll face?
   - Why matters to them? (real consequences)
   - Emotional stakes clear?

2. BRANCHING STRUCTURE:
   - Decision point 1: 3 choices
     - Choice A leads to: [WHAT HAPPENS?]
     - Choice B leads to: [CONSEQUENCE?]
     - Choice C leads to: [CONSEQUENCE?]
   - Decision point 2 (if applicable):
     - Path A has decision? (Y/N)
     - Path B has decision? (Y/N)
     - Path C has decision? (Y/N)

3. CONSEQUENCES (show real outcomes):
   - Compliant choice: Positive outcome (customer happy, problem solved)
   - Mistake choice: Negative but realistic (customer upset, escalation)
   - Gray area choice: Mixed outcome (teaches nuance)

4. LEARNING REINFORCEMENT:
   - After each decision, what's the debrief?
   - What concept was being tested?
   - How does this connect to job reality?

5. ENDING & LOOP:
   - Does learner get a score? (not graded, just tracked)
   - Can they try different path? (yes, increases engagement)
   - What's the overall learning moment?

Design as:
- Opening scenario
- Decision point flowchart
- 3-5 endings with learning debrief
- Slide/branching architecture

Return as: Complete scenario learning path.
```

**Workflow: When to Use This**
Use during DESIGN phase. Complex to build, so plan thoroughly first.

**Implementation Checklist:**

- [ ] Scenario feels realistic?
- [ ] Consequences reflect real outcomes?
- [ ] All paths lead somewhere (no dead ends)?
- [ ] Learning debrief clear for each outcome?
- [ ] Tested for logical flow?
- [ ] Branching architecture matches Storyline capability?

**Real Example:**
Customer: Sales Call Handling Scenario

- Opening: "Customer calls with complaint about late delivery. You have 2 minutes. What do you do?"
- Decision 1:
  - Option A: Listen first, ask questions
    - Decision 2a: Apologize? YES → Path A1: Customer satisfied, learns listening works
    - Decision 2a: Apologize? NO → Path A2: Customer partially satisfied, missed moment
  - Option B: Defend company
    - Consequence: Customer gets angrier, learns defense doesn't help
    - No further decisions
  - Option C: Transfer immediately
    - Consequence: Avoids problem, learns avoidance backfires
- Endings: 3 different outcomes teach 3 approaches
- Slide count: 12 slides total, 8 decision branches

---

## SYSTEM 59 (or 9): The Quiz Question Bank Organization System

**📌 WHY THIS MATTERS:**
Disorganized question banks = impossible to update + inconsistent quality.
This system organizes questions so they're findable and consistent.

**Strategic Framework:**

```
Question Database → Tagging/Categorization → Version Control → Quality Audit → Reuse Ready
```

**THE PROMPT (Copy this entire text):**

```
I'm building a question bank for my e-learning:

Total questions needed: [NUMBER]
Quiz types: [Pre-test / Post-test / Knowledge checks / Final exam]
Difficulty levels: [Easy / Medium / Hard]
Reuse across courses: [YES / NO]

Design a question bank organization system:

1. DATABASE STRUCTURE:
   - Spreadsheet? Excel template? Google Sheets?
   - What columns/fields? (Question ID, Content, Answer, Difficulty, etc.)
   - How do I prevent duplicates?

2. QUESTION TAGGING:
   - By topic? (each tag is a learning objective)
   - By difficulty? (Easy / Medium / Hard)
   - By question type? (MC / T-F / Fill-blank / Essay)
   - By course? (Compliance101 / Sales201?)
   - By Bloom's level? (Remember / Apply / Analyze)

3. NUMBERING SYSTEM:
   - How to number for easy finding?
   - Example: "Q-Compliance-001-MC-Easy" (describes question without opening)
   - Can ID work across multiple courses?

4. VERSIONING:
   - Question v1, v2, v3? (when updated)
   - How do I track changes?
   - What if I use Question v1 in Course A and v2 in Course B?

5. QUALITY AUDIT:
   - Who reviews questions?
   - Checklist for good questions?
   - How do I prevent vague/ambiguous questions?

6. REUSE STRATEGY:
   - Can question appear in multiple quizzes?
   - Randomize question order? (yes, prevents cheating)
   - Question pool: Do I have 150 questions for a 50-question quiz? (yes, better variety)

7. IMPORT/EXPORT:
   - How do I get questions into Storyline/Moodle?
   - Can I bulk import? (vs. type each manually)
   - What file format? (Excel / CSV / GIFT format)

For your question bank:
- Template spreadsheet structure
- Tagging system
- Numbering convention
- Quality checklist
- Import guide for your platform

Return as: Question bank organization system.
```

**Workflow: When to Use This**
Use BEFORE creating any questions. Set up system first, then populate.

**Implementation Checklist:**

- [ ] Database structure chosen (spreadsheet)?
- [ ] Tagging system decided?
- [ ] Numbering convention established?
- [ ] Quality checklist created?
- [ ] Can import into LMS?
- [ ] Team trained on system?

**Real Example:**
Customer: 500-Question Bank for Multiple Compliance Courses

- Structure: Google Sheet with columns: QID | Topic | Type | Difficulty | Bloom's | Course1 | Course2 | Answer | Distractors | Version
- Tagging: Compliance-GDPR-MC-Hard-Analyze
- Numbering: "Q-GDPR-047-MC" (Question #47 about GDPR, Multiple Choice)
- Versioning: Original questions v1, if updated = v2 (but track which courses use which version)
- Quality: 3-point review (subject matter expert + ID + compliance officer)
- Reuse: 150 questions total, Compliance101 pulls 50, Compliance201 pulls different 50
- Import: Bulk import to Moodle via CSV format

---

## SYSTEM 60 (or 10): The Rapid Prototyping System (Click-Through Demo)

**📌 WHY THIS MATTERS:**
Before spending 20 hours building in Storyline, show client a clickable demo.
This system creates rapid prototypes to get feedback early.

**Strategic Framework:**

```
Paper Sketch → Clickable Prototype → Client Feedback → Refinement → Full Build in Storyline
```

**THE PROMPT (Copy this entire text):**

```
I need to create a rapid prototype for client approval:

Course: [NAME]
Purpose: [Show what it'll feel like / Get feedback / Approve interactivity]
Timeframe: [Need demo by WHEN?]
Fidelity: [Simple wireframe / Medium fidelity / High fidelity]

Create a rapid prototyping plan:

1. TOOL SELECTION:
   - Figma (best for UI, interactive)
   - Google Slides (fast, clickable, shares easily)
   - Adobe XD (professional, advanced interactivity)
   - PowerPoint (quick and familiar)
   - Which tool is fastest for your needs?

2. SCOPE (what to show):
   - Full course? (no, too much work)
   - First module only?
   - Key interactions only?
   - How many slides? (target: 10-15 for prototype)

3. PROTOTYPE DESIGN:
   - Navigation: How do they click through?
   - Content sample: Real content? Or placeholder "Lorem ipsum"?
   - Interactivity: Show one interaction example? (drag-drop / branching / etc.)
   - Aesthetic: What should design feel like?

4. FEEDBACK GOALS:
   - What are you asking client to approve?
   - Navigation flow: Does it feel right?
   - Interactivity: Is this the right interaction?
   - Tone: Does it match their brand?
   - Pacing: Is it too fast / too slow?

5. BUILD TIME:
   - How many hours to create prototype?
   - Can you do this THIS WEEK?
   - Who builds? (you / contractor / AI tool?)

6. FEEDBACK LOOP:
   - When do you show client?
   - How long for feedback?
   - How many rounds of revision?

Plan:
- Tool selected
- Scope (what to show)
- Build timeline (hours)
- Feedback questions for client
- Version control (prototype v1, v2, etc.)

Return as: Rapid prototyping action plan.
```

**Workflow: When to Use This**
Use BEFORE full development in Storyline. Creates alignment with client.

**Implementation Checklist:**

- [ ] Tool selected (Figma / Slides / XD)?
- [ ] Scope defined (which parts to show)?
- [ ] Can build in <8 hours?
- [ ] Feedback questions written?
- [ ] Client review scheduled?
- [ ] Feedback incorporated?
- [ ] Full development approved to start?

**Real Example:**
Customer: Onboarding E-Learning Course

- Tool: Google Slides (fast, client can click through easily)
- Scope: First module only (5 sections, 12 slides)
- Interactivity: One drag-and-drop example, one branching scenario example
- Design: Brand colors, placeholder content, rough interactions
- Build time: 6 hours
- Feedback questions: "Does navigation feel intuitive? Is interactivity too much? Does tone match brand?"
- Client review: Thursday at 2pm
- Revisions: 1 round based on feedback
- Full build approved: Friday
- Result: Alignment + confidence + 20 hours of full development saved if client wants changes

---

## SYSTEM 61 (or 11): The Learning Path Sequencing System

**📌 WHY THIS MATTERS:**
Content in wrong order = confusion. Perfect sequence = flow.
This system determines the ideal order for modules/lessons.

**Strategic Framework:**

```
Prerequisite Knowledge → Foundation Concepts → Core Skills → Application → Advanced Topics
```

**THE PROMPT (Copy this entire text):**

```
I'm sequencing my e-learning modules:

Course: [NAME]
Learning goal: [FINAL SKILL LEARNER SHOULD HAVE]
Total modules: [NUMBER]
List all modules: [MODULE 1, MODULE 2, MODULE 3...]

Determine ideal sequence:

For EACH module:
1. What's the learning objective?
2. What prerequisite knowledge is needed?
3. Can this be taught BEFORE prerequisites? (no = must come later)
4. What module depends on THIS module?

Then ask:
- Which module should be FIRST? (prerequisite for others)
- Which module should be SECOND? (builds on #1)
- Which module should be THIRD? (builds on #1-2)
- Etc.

Then build in:
- Review/reinforcement points: Where do learners need to recap?
- Difficulty progression: Is it gradually more complex?
- Motivation: Are there "wins" that keep them going?

Create:
- Ideal sequence (modules in order)
- Why each module is in that position
- Prerequisites for each
- Reinforcement strategy
- Difficulty curve

Return as: Learning path sequence with rationale.
```

**Workflow: When to Use This**
Use during DESIGN phase, after identifying all content/modules.

**Implementation Checklist:**

- [ ] Sequence is logical (builds on prerequisites)?
- [ ] Difficulty gradually increases?
- [ ] No modules depend on later modules?
- [ ] Review points built in?
- [ ] Tested with SME for logic?

**Real Example:**
Customer: Software Training Course

- Module 1: "Getting Started" (foundation - everyone needs this)
- Module 2: "Core Features" (builds on Module 1)
- Module 3: "Advanced Workflows" (depends on Modules 1-2)
- Module 4: "Troubleshooting" (applies Modules 1-3)
- Module 5: "Optimizations" (advanced, depends on all)
- Reinforcement: Review quiz after Module 3 (halfway point)
- Difficulty: Modules 1-2 EASY, Modules 3-4 MEDIUM, Module 5 HARD
- Result: Logical flow, learners build confidence, advanced topics make sense

---

## SYSTEM 62 (or 12): The Accessibility Audit System (E-Learning Specific)

**📌 WHY THIS MATTERS:**
E-learning must be accessible. Not just legal requirement—it's right.
This system audits your Storyline/Moodle course for accessibility.

**Strategic Framework:**

```
Color Contrast → Text Sizing → Captions → Keyboard Navigation → Screen Reader Compatibility
```

**THE PROMPT (Copy this entire text):**

```
I need to audit my e-learning for accessibility:

Platform: [Articulate Storyline / Moodle / Custom]
Course: [NAME]
Current accessibility level: [None / Basic / Trying]

Create an accessibility audit checklist:

1. COLOR & CONTRAST:
   - Text color vs. background: Is contrast sufficient? (WCAG AAA = 7:1 ratio)
   - Is color ONLY way to convey information? (no - use text labels too)
   - Do colorblind learners understand? (test with color-blind simulator)
   - Are you using red + green together? (avoid - colorblind confusion)

2. TEXT & FONTS:
   - Font size: Is it 14pt minimum? (larger for older learners)
   - Line spacing: Is text readable? (not crammed together)
   - Font choice: Sans-serif better (Arial, Verdana) vs. decorative fonts
   - Is text justified? (avoid - harder to read; left-aligned better)

3. CAPTIONS & TRANSCRIPTS:
   - Do ALL videos have captions? (for hearing impaired)
   - Are captions accurate? (not auto-generated without review)
   - Is transcript available? (separate document or document on page)

4. KEYBOARD NAVIGATION:
   - Can learner navigate using ONLY keyboard? (no mouse needed)
   - Is tab order logical? (can follow with TAB key)
   - Are buttons/links keyboard accessible?
   - Can you activate buttons with ENTER key?

5. INTERACTIVE ELEMENTS:
   - Drag-and-drop: Can keyboard-only users do this? (need alternative)
   - Buttons: Are they labeled for screen readers?
   - Form fields: Are they clearly labeled?
   - Links: Is link text descriptive? ("Click here" bad; "Download course syllabus" good)

6. SCREEN READER COMPATIBILITY:
   - Are images described? (alt text for screen readers)
   - Are headings structured? (H1, H2, H3 - not just bold text)
   - Are lists properly formatted? (bulleted lists for screen readers)
   - Is jargon/abbreviations explained? (first use: "PDF (Portable Document Format)")

7. TESTING:
   - Tool: WAVE (web accessibility checker)
   - Tool: Axe DevTools (accessibility scan)
   - Real test: Try navigating with NVDA screen reader
   - Test with real colorblind user
   - Test with keyboard-only navigation

For your course:
- Accessibility issues found?
- Priority fixes (critical vs. nice-to-have)?
- Timeline for remediation?
- Responsibility assignment?

Return as: Detailed accessibility audit report.
```

**Workflow: When to Use This**
Use before course launch. Better to fix now than get lawsuit later.

**Implementation Checklist:**

- [ ] Color contrast verified (7:1 WCAG AAA)?
- [ ] All videos captioned?
- [ ] Keyboard navigation works?
- [ ] Alt text on all images?
- [ ] Headings properly structured?
- [ ] Tested with screen reader?
- [ ] Tested with colorblind simulator?
- [ ] Legal/compliance review complete?

**Real Example:**
Customer: Compliance E-Learning Course Audit

- Issues found:
  - 10 images missing alt text (CRITICAL)
  - Font size 12pt (should be 14pt+) - MEDIUM
  - Video captions auto-generated, not reviewed - MEDIUM
  - Color-only indicators (red = wrong) - HIGH
  - Drag-and-drop not keyboard accessible - HIGH
- Fixes (priority order):
  1. Add alt text (2 hours)
  2. Fix color-only indicators (1 hour)
  3. Increase font size (1 hour)
  4. Review captions manually (3 hours)
  5. Add keyboard alternative to drag-drop (4 hours)
- Timeline: 1 week
- Responsibility: ID + developer + QA
- Result: WCAG 2.1 AA compliant

---

## SYSTEM 63 (or 13): The LMS Integration Testing System

**📌 WHY THIS MATTERS:**  
You build a perfect course in Storyline. You export it. It breaks in the LMS—tracking doesn't work, interactions fail, learners can't progress.
This system verifies everything works in your actual LMS before launch.

**Strategic Framework:**

```
Course Built → Export to LMS → Tracking Verification → Interaction Testing → Edge Cases → Launch Ready
```

**THE PROMPT (Copy this entire text):**

```
I need to test my e-learning course in our LMS:

LMS: [Moodle / Blackboard / Canvas / Custom / Other]
Course: [NAME]
Export format: [SCORM 1.2 / SCORM 2004 / xAPI / AICC]
Test timeline: [Days before launch]

Create a comprehensive LMS integration testing plan:

1. SCORM/TRACKING SETUP:
   - Is SCORM connection configured in LMS?
   - Does LMS accept SCORM files?
   - Test file: Upload simple test course (5 slides)?
   - Does LMS track completion?
   - Does LMS track quiz scores?
   - Are tracking variables correct? (cmi.core.score, cmi.core.lesson_status)?

2. TRACKING VERIFICATION (specific data):
   - Launch tracking: Does LMS record when learner starts?
   - Completion tracking: Does LMS record when learner finishes?
   - Quiz results: Are scores (0-100) recorded correctly?
   - Time tracking: Is time spent recorded?
   - Progress: Does LMS show % complete?
   - Session data: Can learner resume where they left off?

3. INTERACTION TESTING:
   - Can learner click Next/Prev buttons?
   - Can learner access course menu?
   - Do drag-and-drop interactions work?
   - Do branching scenarios follow correct paths?
   - Do knowledge checks register answers?
   - Do videos play smoothly?
   - Do audio/captions work?

4. GRADING & SCORING:
   - Are quiz grades recorded in gradebook?
   - Is passing/failing logic correct?
   - Can instructor see learner scores?
   - Can learner see their own scores?
   - Decimal rounding: Is 89.5% displayed correctly?

5. MOBILE TESTING:
   - Launch on mobile phone (real device).
   - Can learner navigate course?
   - Do interactions work on touch screen?
   - Does course stay in sync (mobile + desktop)?
   - Videos play on mobile?

6. EDGE CASE TESTING:
   - Learner logs out mid-course → logs back in → can resume? (YES)
   - Learner takes quiz, refreshes page → answers still there? (YES)
   - Learner skips ahead → can still answer questions? (check if intended)
   - Course accessed on slow connection → works? (test with 3G)
   - Two learners take course simultaneously → both work? (test concurrent users)

7. BROWSER COMPATIBILITY:
   - Chrome (latest)? 
   - Firefox (latest)?
   - Safari (latest)?
   - Edge (latest)?
   - Mobile Safari (iPhone)?
   - Mobile Chrome (Android)?
   - Test on each: Functionality, display, performance.

8. ERROR LOGGING:
   - LMS browser console: Any JavaScript errors?
   - LMS logs: Any SCORM communication errors?
   - SCORM Cloud test: Does course pass Rustici Software certification?
   - Instructor dashboard: Does data appear immediately or delayed?

9. LAUNCH ISSUES RESOLUTION:
   - If tracking fails: Is it SCORM connection? Manifest? Packaging?
   - If quiz scores don't record: Is LMS receiving data?
   - If interactions fail: Is JavaScript enabled? Browser compatibility?
   - Troubleshooting steps for common issues.

10. SIGN-OFF:
    - All critical items pass? (tracking, completion, quiz results)
    - All interactions functional?
    - All browsers supported?
    - Mobile works?
    - Course ready to launch?
    - Contingency plan if issues found after launch?

Create:
- Testing checklist (all items to verify)
- Test data (sample course to export/upload)
- Results spreadsheet (item / status / notes)
- Troubleshooting guide (common issues + fixes)
- Launch approval sign-off

Return as: Complete LMS integration testing plan.
```

**Workflow: When to Use This**  
Use 1–2 weeks BEFORE launch, after course is built but before rolling out to all learners.  
Do this in a test environment first (not production), then production environment.

**Implementation Checklist:**

- [ ] Course successfully uploaded to test LMS?
- [ ] Tracking configured (SCORM/xAPI)?
- [ ] Completion tracking works?
- [ ] Quiz scores recorded in gradebook?
- [ ] Interactions functional (buttons, drag-drop, branching)?
- [ ] Mobile tested (real phone)?
- [ ] All browsers tested (Chrome, Firefox, Safari, Edge)?
- [ ] Edge cases tested (logout/login, refresh, concurrent users)?
- [ ] Console errors checked (JavaScript errors)?
- [ ] Contingency plan if issues found post-launch?

**Real Example:**  
Customer: Compliance Training Course Launch

Testing checklist:

- ✓ Course exported as SCORM 1.2
- ✓ Uploaded to Moodle test environment
- ✗ Tracking not working: LMS says "no data received"
  - Investigation: SCORM connection not enabled in Moodle
  - Fix: Admin enabled SCORM in Moodle settings
  - Retest: ✓ Now working
- ✓ Quiz scores recorded (25/25 correct = 100%)
- ✓ Completion tracked
- ✓ Mobile works (iPhone + Android tested)
- ✓ All browsers (Chrome, Firefox, Safari, Edge)
- ✓ Edge cases: Logout/login works, resume from where left off
- ✓ Ready to launch

Result: Zero issues on launch day (smooth experience for 500+ learners).

---

## SYSTEM 64 (or 14): The Performance Tracking Setup System

**📌 WHY THIS MATTERS:**  
Without data, you're flying blind. How do you know what works? What engagement is strong? Where do learners drop off?
This system sets up tracking so you have data to improve courses.

**Strategic Framework:**

```
Define Success Metrics → Configure LMS Tracking → Analytics Dashboard → Regular Reporting → Data-Driven Improvements
```

**THE PROMPT (Copy this entire text):**

```
I need to track learning performance:

Course: [NAME]
Business goal: [WHAT SHOULD IMPROVE]
LMS: [Platform]
Audience: [NUMBER OF LEARNERS]
Duration: [COURSE LENGTH]

Design a performance tracking system:

1. ENGAGEMENT METRICS (are learners participating?):
   - Enrollment rate: How many started?
   - Completion rate: How many finished?
   - Time spent: Average hours per learner?
   - Drop-off points: Where do learners quit?
   - Repeat users: Are learners coming back?
   - Active users per week: Growing or shrinking?

2. LEARNING METRICS (did they learn?):
   - Pre-test scores: What's baseline knowledge?
   - Post-test scores: What's improvement?
   - Knowledge check performance: Which concepts are hard?
   - Assessment pass rate: % who pass quiz?
   - Common mistakes: Which questions are most missed?
   - Improvement delta: Pre vs. post (learning gain)?

3. BEHAVIOR METRICS (are they applying learning?):
   - Performance improvements: Sales up? Errors down?
   - Skills demonstration: Can they actually do it?
   - Application rate: % using skill on actual job?
   - Manager observation: Trainers seeing behavior change?
   - Retention: Are improved skills sticking?

4. ENGAGEMENT ANALYTICS:
   - Which course sections are most viewed?
   - Which sections are skipped?
   - How long per section? (ideal = 5-10 min, too long = disengaging)
   - Video completion: % who watch full videos?
   - Interactive element usage: % who try interactions?
   - Help request rate: Who asks questions?

5. DEMOGRAPHICS/SEGMENTS:
   - Performance by role? (managers vs. individual contributors)
   - Performance by team? (sales team A vs. B)
   - Performance by tenure? (new hires vs. veterans)
   - Performance by location? (remote vs. on-site)
   - Any demographic gaps? (training not reaching everyone equally?)

6. TRACKING IMPLEMENTATION:
   - LMS native tracking? (built-in reports)
   - Custom dashboard? (Google Data Studio, Tableau)
   - Manual tracking? (spreadsheet, check weekly)
   - Automated reports? (email summaries)
   - Frequency: Daily / Weekly / Monthly dashboard?

7. DASHBOARD SETUP:
   - What metrics on dashboard? (top 5 most important)
   - Visual format: Graphs? Numbers? Trends?
   - Drill-down capability: Can click to see more detail?
   - Alerts: Notify if completion rate drops below X%?
   - Stakeholder access: Who sees what data?

8. DATA GOVERNANCE:
   - Who owns the data?
   - How often is data updated?
   - Data privacy: Is learner data secure?
   - How long retained? (compliance requirement?)
   - Who has access? (L&D lead? HR? Instructors?)

9. REPORTING CADENCE:
   - Weekly brief: Completion rate, engagement rate, common issues
   - Monthly deep-dive: Performance trends, segment analysis, improvements
   - Quarterly review: Course effectiveness, ROI calculation, next steps
   - Annual assessment: Benchmark vs. prior year, recommendations

10. DATA-DRIVEN IMPROVEMENTS:
    - If completion is low (60%): What's the barrier?
    - If one section is skipped: Is it irrelevant? Too hard?
    - If quiz pass rate is low (50%): Concept unclear? Quiz too hard?
    - If performance by role differs: Need role-specific versions?

Create:
- Tracking metrics list (what to track)
- LMS configuration guide (how to track)
- Dashboard template (what's displayed)
- Reporting schedule (when reports delivered)
- Data interpretation guide (what numbers mean)

Return as: Complete performance tracking system.
```

**Workflow: When to Use This**  
Use during DESIGN phase to plan what will be tracked.  
Configure tracking during LMS setup (before course launch).  
Run reports weekly/monthly to monitor course effectiveness.  
Use data to improve course (monthly improvements, not one-time).

**Implementation Checklist:**

- [ ] Success metrics defined (engagement, learning, behavior)?
- [ ] LMS tracking configured?
- [ ] Dashboard created (displays key metrics)?
- [ ] Access controls set (who sees what)?
- [ ] Reports automated (not manual each time)?
- [ ] Reporting schedule established?
- [ ] Team trained on interpreting data?
- [ ] Improvement process in place (data → action)?

**Real Example:**  
Customer: Sales Training Course

Metrics tracked:

- Enrollment: 245 of 300 salespeople (82%)
- Completion: 198 completed (81% of starters)
- Average time: 3.2 hours (target: 3-4 hours = ✓)
- Quiz pass rate: 87% (target: 80%+ = ✓)
- Drop-off point: Module 3 (30% incomplete) — needs investigation
- Performance by region:
  - East region: 95% completion
  - West region: 68% completion — gap to address

Dashboard (weekly):

- Enrollment progress
- Completion rate (updated daily)
- Quiz pass rate
- Time spent average
- Region comparison

Monthly report:

- "West region slower adoption. Possible cause: manager engagement? Time constraints? Recommend follow-up."
- "Module 3 'Negotiation Skills' has 30% drop-off. Feedback: too long (18 min). Recommend breaking into 2 modules."

Improvements made:

- Week 3: Regional manager coaching sessions (West region)
- Week 5: Module 3 redesigned (2 modules instead of 1)
- Week 6: West region completion jumps to 92%

Result: Data-driven improvements increase effectiveness quarter-over-quarter.

---

## SYSTEM 65 (or 15): The Variable/Trigger Documentation System

**📌 WHY THIS MATTERS:**  
Storyline courses with branching paths, quiz logic, and conditional content = complex.  
If variables and triggers aren't documented, future edits break everything.
This system documents triggers so the course is maintainable.

**Strategic Framework:**

```
Variable Definition → Trigger Mapping → Logic Flowchart → Testing Matrix → Documentation Complete
```

**THE PROMPT (Copy this entire text):**

```
I need to document variables and triggers in my Storyline course:

Course: [NAME]
Complexity: [SIMPLE / MODERATE / COMPLEX]
Variables count: [How many decision points / conditional paths]
Trigger count: [Rough estimate: <50 / 50-100 / 100+]
Team: [Solo developer / Team / Future maintainer needed]

Create variable and trigger documentation:

1. VARIABLE INVENTORY:
   - Variable name: (e.g., "QuizScore", "AttemptCount", "PathChosen")
   - Variable purpose: (What does it track?)
   - Variable type: (Number / Text / True/False)
   - Initial value: (e.g., QuizScore starts at 0)
   - How it changes: (What triggers modify it?)
   - Used in triggers: (Where is it referenced?)

   Format: 
   | Variable Name | Type | Purpose | Initial Value | Modified By | Used In |
   | QuizScore | Number | Tracks quiz points | 0 | Click answer buttons | Show/hide pass/fail slide |

2. TRIGGER MAPPING:
   For EACH trigger:
   - Trigger name: (e.g., "Show Incorrect Feedback")
   - On event: (When does this fire? e.g., "When user clicks Option C")
   - Condition: (If any? e.g., "If QuizScore < 80")
   - Action: (What does it do? e.g., "Set QuizScore = 75, Show layer 'WrongAnswer'")
   - Slide: (Which slide is this on?)

   Format:
   | Trigger Name | Event | Condition | Action | Slide |
   | Show Incorrect | Click Option C | If OptionC = Wrong | Set QuizScore -10, Show WrongFeedback | Q1 |

3. LOGIC FLOWCHART:
   - Sketch decision tree (on paper or in tool like Lucidchart)
   - Show: Start → Decision 1 → Path A/B → Decision 2 → Endings
   - Where variables change (annotate on flowchart)
   - Where conditions matter (if-then-else logic)

4. CONDITIONAL VISIBILITY:
   - Which elements are hidden/shown conditionally?
   - Example: Layer "PremiumContent" shows IF (UserRole = Admin)
   - For each conditional element: What's the condition?

   | Element | Condition | Shows When | Hides When |
   | Layer: Advanced | If SkillLevel ≥ 3 | Score >75 | Score <75 |

5. BRANCHING LOGIC:
   - If course has branching paths:
     - Path A condition: (What determines Path A?)
     - Path B condition: (What determines Path B?)
     - How learner knows which path? (Does UI make it obvious?)
   - Example: IF UserRole = "Manager" → show Manager scenarios, ELSE → show Rep scenarios

6. TESTING MATRIX:
   - For branching: Test all paths (A, B, C, etc.)
   - For conditional triggers: Test condition TRUE and FALSE
   - Example:
     | Scenario | Variable Set | Expected Behavior | Actual Behavior | Pass? |
     | Path A Chosen | PathChoice=A | Show Path A slides | Shows Path A | ✓ |
     | Path B Chosen | PathChoice=B | Show Path B slides | Shows Path B | ✓ |
     | Quiz fail | QuizScore=60 | Show remedial, block advance | Shows remedial | ✓ |

7. COMMON MISTAKES LOG:
   - Document issues found during testing
   - Solution applied
   - How to prevent next time
   - Example: "Variable QuizScore not resetting on retake → Add trigger to reset on slide entry"

8. MAINTENANCE GUIDE:
   - If someone else edits this course:
     - Start here (variable list)
     - Check logic flowchart before changing
     - Edit trigger, then test that path
     - Update documentation after change
   - Red flags (don't do these):
     - Don't rename variables (breaks all triggers)
     - Don't change logic without testing all paths
     - Don't add triggers without documenting

Create:
- Complete variable inventory (spreadsheet)
- Trigger mapping document
- Logic flowchart
- Conditional visibility rules
- Testing matrix (all paths tested)
- Maintenance guide

Return as: Complete variable/trigger documentation (ready to maintain).
```

**Workflow: When to Use This**  
Use DURING DEVELOPMENT as you build triggers.  
Document as you go (not afterward—too many to remember).  
Before handing off to someone else, ensure documentation is complete.

**Implementation Checklist:**

- [ ] All variables defined (name, type, purpose)?
- [ ] All triggers documented (event, condition, action)?
- [ ] Logic flowchart created?
- [ ] Conditional visibility rules listed?
- [ ] Testing matrix complete (all paths tested)?
- [ ] Common issues documented?
- [ ] Maintenance guide written?
- [ ] Someone else can maintain this course (from docs)?

**Real Example:**  
Customer: Complex Sales Scenario Course

Variable inventory:

- SalesRep_Name (Text): Learner's name
- CompetitorPrice (Number): Dynamic price variable = 1000-5000
- UserRole (Text): "Sales" or "Manager" (changes content shown)
- QuizAttempts (Number): How many times learner took quiz
- PathChosen (Text): "Negotiation" vs. "CutPrice" vs. "AddValue"

Trigger example:

- Name: "Evaluate Price Response"
- Event: User clicks "Accept $4,500" button
- Condition: IF CompetitorPrice < 4500 (learner beat competitor)
- Action: Set PathScore = 10, Show "Great negotiation" feedback, Jump to PathA-Success
- Slide: Scenario-PriceNegotiation

Logic flowchart (ASCII):

```
Start Scenario
  ↓
Competitor Price = RANDOM(1000-5000)
  ↓
Learner Chooses Strategy
  ├─ Option A: Negotiate (go to Negotiation path)
  ├─ Option B: Cut Price (go to CutPrice path)
  └─ Option C: Add Value (go to AddValue path)
      ↓
   Each path has 2 decision points
      ↓
   Final score calculated
      ↓
Debrief (which strategy worked best)
```

Testing matrix:

- Scenario 1: CompPrice=900, Choose Negotiate, Beat it → Score +10 ✓
- Scenario 2: CompPrice=4800, Choose CutPrice, Lose → Score 0 ✓
- Scenario 3: CompPrice=3000, Choose AddValue, Win → Score +15 ✓
- Attempt retake: QuizAttempts increments → ✓

Result: Course is fully documented, maintainable, anyone can edit without breaking logic.

---

## SYSTEM 66 (or 16): The Animation Timing System

**📌 WHY THIS MATTERS:**  
Animations that are too fast = missed content. Animations too slow = learners get bored.
This system times animations so they support learning without distracting.

**Strategic Framework:**

```
Purposeful Animation → Duration Calibrated → Tested with Learners → Distracting Content Removed
```

**THE PROMPT (Copy this entire text):**

```
I'm using animations in my Storyline course:

Course: [NAME]
Animation count: [Rough estimate]
Audience: [WHO IS WATCHING]
Pacing: [Fast-paced content / Reflective content]

Create an animation timing and best practices guide:

1. ANIMATION PURPOSE:
   - Why are you animating THIS element?
     - Draw attention? (good use case)
     - Reveal content progressively? (good)
     - Entertain? (probably skip, distracting)
     - Support understanding of a process? (excellent)
   - Remove animations that don't serve learning.

2. ENTRANCE ANIMATIONS (element appears):
   - Wipe/Fade: 0.5-1 second (smooth appearance)
   - Bounce/Flash: Only for emphasis (rare)
   - Appear: Instant (no animation)
   - Guideline: 1 second max for entrance animation

3. EMPHASIS ANIMATIONS (already visible, needs highlighting):
   - Pulse/Glow: 0.5 seconds (draws eye)
   - Spin: Only for loading states (not learning)
   - Color change: 0.5 seconds (highlights change)
   - Guideline: Keep to 0.5 seconds max

4. EXIT ANIMATIONS (element disappears):
   - Fade out: 0.5 seconds (natural exit)
   - Wipe: 1 second (clear exit)
   - Guideline: 1 second max for exit

5. SEQUENCE/PROCESS ANIMATIONS (showing steps):
   - Animate ONE step at a time
   - Pause between steps (let learner process)
   - Example: Step 1 animates in (1s), pause (2s), Step 2 animates in (1s), pause (2s)
   - Total: 6 seconds for 2-step process (reasonable)
   - Guideline: No animation should be >2 seconds for individual step

6. TESTING WITH LEARNERS:
   - Test speed with actual learners
   - Too slow? They get bored/frustrated
   - Too fast? They miss content
   - Ask: "Could you follow what happened?"

7. ANIMATION CHECKLIST (before approval):
   - Does this animation SERVE learning? (not just decorative)
   - Is timing comfortable for reading/processing?
   - Is it distracting? (ask learner)
   - Does it work on slow computers? (test playback)
   - Does it work on mobile? (some animations break on mobile)

8. COMMON MISTAKES TO AVOID:
   - Multiple simultaneous animations (confusing)
   - Animations longer than 2 seconds per element
   - Too many animations (fatiguing)
   - Animation blocks learner interaction (frustrating)
   - "Whimsical" animations unrelated to content (unprofessional)

Create:
- Animation timing guide (duration per animation type)
- Storyboard (show when animations occur)
- Testing feedback (learner comments on timing)
- Animation removal list (cuts we're making)

Return as: Animation timing and best practices document.
```

**Workflow: When to Use This**  
Use during DEVELOPMENT when adding animations.  
Review BEFORE publishing (don't publish and then test).  
Test with sample learners to verify timing feels right.

**Implementation Checklist:**

- [ ] Each animation serves a learning purpose (not decorative)?
- [ ] Entrance animations ≤1 second?
- [ ] Emphasis animations ≤0.5 seconds?
- [ ] No animations >2 seconds per element?
- [ ] Tested with actual learners?
- [ ] Tested on slow computer?
- [ ] Tested on mobile?
- [ ] Multiple animations don't overlap (confusing)?

**Real Example:**  
Customer: Process Training Course

Animation review:

- Process diagram (5 steps): Animate each step one-by-one (1s entrance, 2s pause between)
  
  - Total: ~12 seconds (reasonable for 5-step process)
  - ✓ Serves learning (helps understand sequence)

- Decorative background animation (constantly swirling)
  
  - ✗ Removed (distracting, doesn't serve learning)

- Quiz result feedback (confetti falls on correct answer)
  
  - Δ Modified: Keep simple fade-in (0.5s) for pass, remove confetti (too playful)

- Error message shake animation (0.3s)
  
  - ✓ Keep (draws attention to mistake, helpful)

Result: Animations removed = faster course performance, fewer distractions, better learning experience.

---

## SYSTEM 67 (or 17): The Course Templating System

**📌 WHY THIS MATTERS:**  
Build a course from scratch = 40 hours. Build from template = 10 hours.
This system creates reusable templates so you develop faster.

**Strategic Framework:**

```
Master Template → Modular Components → Content Swap → Rapid Deployment
```

**THE PROMPT (Copy this entire text):**

```
I want to create a Storyline template for reuse:

Template purpose: [E.g., "Standard Compliance Module", "Skills Training", "Product Knowledge"]
Module length: [MINUTES / HOURS]
Key components: [Content slides / Quizzes / Interactions / etc.]
Reuse frequency: [Will this template be used 2 times? 10 times?]

Design a reusable template system:

1. TEMPLATE ARCHITECTURE:
   - Master slide design (locked, consistent branding)
   - Slide layouts (title slide, content, interaction, quiz, etc.)
   - Placeholder content areas (where SME will add content)
   - Locked vs. editable elements (what can be customized?)

2. COMPONENT LIBRARY:
   - Slide templates (5-10 standard layouts)
   - Interaction templates (drag-drop, branching, scenario)
   - Quiz templates (multiple choice, true-false, ordering)
   - Feedback templates (correct/incorrect messages)
   - Which are locked (can't change) vs. editable (can customize)?

3. NAMING/ORGANIZATION:
   - Consistent naming convention (so people can find what they need)
   - Folder structure (Interactions / Templates / Assets / etc.)
   - Clear labels ("Template: Do not edit" vs. "Customize this section")

4. INSTRUCTIONS FOR USE:
   - Step-by-step: How to use the template
   - What to customize (content areas only)
   - What NOT to customize (locked sections)
   - Common customizations (find-and-replace guide)
   - Where to get help?

5. VARIABLES/TRIGGERS SETUP:
   - Are baseline variables already configured?
   - Are standard triggers pre-built?
   - Can person using template understand the logic?
   - Documentation included?

6. QUALITY ASSURANCE:
   - Template tested for:
     - SCORM export/import works?
     - No broken interactions?
     - Consistent branding?
     - Mobile compatible?
   - Before releasing template, verify it's polished

7. TEMPLATE VARIATIONS:
   - Do you need multiple template versions?
   - Example: "Compliance Template v1.0" (standard), "Compliance Template-Mobile" (mobile-optimized)
   - How many variations? Too many = confusing

8. RAPID DEPLOYMENT PROCESS:
   - Step 1: Get template file
   - Step 2: Replace placeholder content
   - Step 3: Customize colors/branding? (optional)
   - Step 4: Export and test
   - Step 5: Launch
   - Timeline: How long should this take? (target: 4-8 hours per course)

9. VERSION CONTROL:
   - Template v1.0 (original)
   - Template v1.1 (fixes, improvements)
   - How to notify users of template updates?
   - Should old courses be updated? (depends)

10. FEEDBACK LOOP:
    - After using template, feedback: "What was hard? What's missing?"
    - Template improvements based on feedback
    - Annual template refresh (keep it current)

Create:
- Master template file (Storyline SLSX ready to use)
- Instructions for use (step-by-step guide)
- Customization checklist (what can be changed)
- Quality assurance report (template tested)
- Version control log

Return as: Complete reusable template system.
```

**Workflow: When to Use This**  
Use to build templates AFTER you've built 1-2 courses successfully.  
Don't template until you see the pattern (what's always same vs. always different).  
Use template for future courses to dramatically speed development.

**Implementation Checklist:**

- [ ] Master template created?
- [ ] Slide layouts designed (5-10 key layouts)?
- [ ] Component library built (interactions, quizzes)?
- [ ] Instructions written (clear, step-by-step)?
- [ ] Locked vs. editable elements clearly marked?
- [ ] Testing done (template works end-to-end)?
- [ ] Quality standards met?
- [ ] Version control established?

**Real Example:**  
Customer: Building 20 Product Training Courses

Template design:

- Standard module: Title slide → 3 content slides → 1 interaction → 1 quiz slide → conclusion
- Locked: Master slides, branding, interaction triggers
- Editable: Content text, images, quiz questions
- Time to build from template: ~6 hours (vs. 40 hours from scratch)
- Result: 20 courses × 6 hours = 120 hours (vs. 800 hours without template)
- Savings: 680 hours = 34,000+ at 50/hour

---

## SYSTEM 68 (or 18): The Narration Script Timing System

**📌 WHY THIS MATTERS:**  
You write a 2-minute narration script. You record it. It takes 3 minutes to say aloud.
This system ensures your script matches your animation timeline.

**Strategic Framework:**

```
Script Written → Word Count → Spoken Duration Calculated → Recording Timed → Synchronized with Visuals
```

**THE PROMPT (Copy this entire text):**

```
I'm creating narration for my Storyline course:

Module: [NAME]
Slides with narration: [HOW MANY]
Animation sequence: [BRIEF DESCRIPTION]
Pacing: [SLOW/MEDIUM/FAST]
Voice talent: [Professional / In-house / AI voice]

Create a narration timing system:

1. WORDS-PER-MINUTE (WPM) GUIDANCE:
   - Conversational pace: 130-150 WPM (natural, easy to follow)
   - Brisk pace: 150-170 WPM (for impatient learners)
   - Slow, deliberate: 100-130 WPM (for complex concepts or ESL learners)

   For YOUR pacing, target: [130-150 WPM recommended for most courses]

2. TIMING CALCULATION:
   - Script word count ÷ 150 WPM = minutes needed
   - Example: 300-word script ÷ 150 = 2 minutes needed
   - Build in pauses? (yes, for processing, aim for 110-140 WPM with pauses)

3. SCRIPT FORMAT:
   - Format script with pauses marked: [PAUSE 2 seconds]
   - Emphasis: BOLD key terms (voice emphasis)
   - Pronunciation: Note unusual words (how to pronounce)
   - Slide-by-slide: Link script to slide number

4. ANIMATION ALIGNMENT:
   - When animation 1 starts: Narration begins
   - When animation 2 appears (3 seconds in): Narration refers to it
   - Narration shouldn't get ahead of animation (confusing)
   - Narration shouldn't lag behind animation (feels slow)

5. TESTING SCRIPT TIMING:
   - Read script aloud (don't just count words)
   - Time yourself
   - Result matches calculation?
   - Is pacing comfortable? (not rushed, not dragging)
   - Do pauses feel right?

6. VOICE TALENT BRIEF:
   - Give voice talent the script + timing
   - Provide guidance: "This should be 2:15 total"
   - "Key phrases should be emphasized"
   - "Tone: professional but warm"
   - "Pace: 140 WPM"

7. RECORDING & EDITING:
   - Record narration
   - Time actual recording (may differ from script calculation)
   - If recording is too fast/slow, re-record or trim
   - Edit: Remove filler words (ums, ahs), add pauses if needed
   - Final timing should match animation timeline exactly

8. SYNC WITH ANIMATION:
   - Narration starts → Animation 1 starts
   - Narration at 3 seconds → "This is step 2" → Animation 2 appears
   - Narration ends → Animation ends (or pause before next)
   - No gaps (narration ends early) or overlaps (narration still going after animation)

9. QUALITY CHECKS:
   - Audio clarity? (no background noise, no peaks/clipping)
   - Pronunciation correct? (no mispronunciations)
   - Pacing consistent? (no sudden speed changes)
   - Emphasis appropriate? (not over-the-top)
   - Tone matches course? (formal for compliance, friendly for onboarding)

Create:
- Narration script (with timing marks)
- WPM calculation guide
- Animation-narration sync chart
- Voice talent brief
- Recording checklist

Return as: Complete narration timing system.
```

**Workflow: When to Use This**  
Use during DEVELOPMENT after animations are finalized.  
Time script BEFORE recording (don't waste voice talent time).  
Sync narration with animation during post-production.

**Implementation Checklist:**

- [ ] Script written with pauses marked?
- [ ] Word count calculated?
- [ ] Target WPM determined (130-150)?
- [ ] Script timed (read aloud)?
- [ ] Animation timeline documented?
- [ ] Voice talent brief written?
- [ ] Recording timed (actual duration)?
- [ ] Narration synced with animation?
- [ ] Audio quality approved?

**Real Example:**  
Customer: 5-Minute Software Training Video

Script timing:

- Target: 5 minutes = 300 seconds
- WPM target: 140 (conversational)
- Word count: 700 words
- Calculation: 700 ÷ 140 = 5 minutes ✓
- Includes pauses: [PAUSE 1s after key point] × 3 pauses

Voice talent recording:

- Actual time: 5:12 (too long by 12 seconds)
- Adjustment: Remove 1 pause, re-record section
- New time: 5:04 (close enough, acceptable)

Animation sync:

- 0:00-0:30: Intro animation + narration intro
- 0:30-1:15: Feature 1 animation appears, narration explains
- 1:15-2:00: Feature 2 animation, narration continues
- 2:00-2:45: Feature 3 animation, narration
- 2:45-5:00: Demo + Q&A overlay
- 5:00: End

Result: Narration perfectly synced with animation, feels natural, takes exactly 5 minutes.

---

## SYSTEM 69 (or 19): The Screen Recording/Demo System

**📌 WHY THIS MATTERS:**  
"Click here, then here, then here." Learners can't follow if you describe it.
Screen recordings show exactly what to do. This system creates clear, helpful demos.

**Strategic Framework:**

```
Realistic Scenario → Clean Screen Setup → Recorded Demo → Annotated Clearly → Mobile Viewable
```

**THE PROMPT (Copy this entire text):**

```
I'm creating screen recording demos:

Software: [WHAT APP ARE WE TRAINING]
Task: [WHAT SHOULD LEARNER LEARN TO DO]
Audience: [WHO IS WATCHING]
Demo length target: [2 min / 5 min / etc.]

Create a screen recording demo guide:

1. SCENARIO SETUP:
   - What's the realistic scenario? (not artificial demo data)
   - Example: "You're onboarding a new customer in CRM. Do this..."
   - Learner should see EXACTLY what they'll see at their desk
   - Use realistic data? (better) vs. dummy data (less effective)

2. SCREEN PREPARATION:
   - Clean desktop (no personal files visible)
   - Close unnecessary windows/apps
   - Zoom level: Is text readable? (120% zoom minimum)
   - Resolution: Record in 1920x1080 (scales to mobile later)
   - Hide notifications (turn off Slack, email, etc.)
   - Clear cache/history if recording login process

3. RECORDING SETUP:
   - Tool: Camtasia / SnagIt / OBS / Articulate Peek
   - Frame rate: 30fps (smooth, not jerky)
   - Cursor visibility: Show cursor (so learner sees where to click)
   - Cursor highlight: Optional (circle cursor, makes it more visible)
   - System audio: On (keyboard clicks can help)
   - Microphone: High quality (USB mic, not laptop mic)

4. RECORDING TECHNIQUE:
   - Move SLOW (give learner time to see where you're clicking)
   - Pause between major steps (let it sink in)
   - Pause before important action (draw attention)
   - Don't skip ahead (even if obvious to you, learner might miss)
   - Example: "Click here [pause 1s], then enter data [pause 2s], then click Save [pause 1s]"

5. ANNOTATION (during or after):
   - Highlight where to click (arrow, circle, highlight box)
   - Label important areas ("This is the..." text overlay)
   - Use arrows to show flow (→ direction)
   - Color coding: Green = correct, Red = common mistakes
   - Keep annotations clean (not cluttered)

6. NARRATION:
   - Keep narration clear and slower than normal speech
   - Explain what's happening and WHY
   - Example: "I'm entering customer name here because CRM requires it for tracking"
   - Point out common mistakes: "Notice I don't use special characters—system doesn't allow them"
   - Use pauses (let action complete before explaining next step)

7. DEMO LENGTH:
   - Too long (>5 min): Learner gets lost
   - Too short (<1 min): Feels rushed
   - Target: 2-3 minutes per concept
   - If task is complex: Break into 2-3 shorter demos

8. RECORDING CHECKLIST:
   - Did I move slowly enough?
   - Did I pause between steps?
   - Is cursor visible?
   - Is screen readable (large enough)?
   - Did I explain WHY, not just HOW?
   - Did I show one common mistake?

9. POST-PRODUCTION:
   - Edit: Cut dead air, trim pauses
   - Zoom: Enlarge screen if text is small
   - Caption: Add captions (for accessibility)
   - Test playback: Watch full video, verify it's clear

10. MOBILE COMPATIBILITY:
    - Video optimized for mobile viewing?
    - Screen text readable on phone? (if showing small text, zoom in)
    - Video file size optimized? (<50MB total)

Create:
- Demo script (what you'll record)
- Recording checklist
- Annotation guide (what to highlight)
- Post-production checklist

Return as: Screen recording demo guidelines.
```

**Workflow: When to Use This**  
Use for software/system training (CRM, project management, etc.).  
Create AFTER finalizing what to teach.  
Record in one sitting if possible (consistency).

**Implementation Checklist:**

- [ ] Realistic scenario chosen?
- [ ] Screen prepared (clean, readable)?
- [ ] Recording tool selected and tested?
- [ ] Demo recorded slowly and clearly?
- [ ] Cursor visible and annotated?
- [ ] Narration clear and explains WHY?
- [ ] Demo length appropriate (2-3 min)?
- [ ] Captions added?
- [ ] Tested on mobile?

**Real Example:**  
Customer: Salesforce CRM Training

Demo: "Create a new sales opportunity"

Setup:

- Logged into Salesforce sandbox (realistic)
- Ready on Opportunities page
- Sample company data: "Acme Corp", standard scenario

Recording (3:15 total):

- Intro: "We're creating a sales opportunity for new customer" (narration)
- Click Opportunities tab [pause]
- Click "New" button [annotate with green arrow]
- Fill form: Account Name, Amount, Close Date [pause after each]
- Narration explains: "Amount is required so we can forecast revenue"
- Show common mistake: "See—I tried to leave Amount blank, system won't let me" [red highlight]
- Click Save [pause]
- Show success: Opportunity created, displays in list
- Outro: "You can now create opportunities. Practice with your own customers"

Result: Clear, realistic demo, learners can follow and replicate.

---

## SYSTEM 70 (or 20): The Localization/Multi-Language System

**📌 WHY THIS MATTERS:**  
Global companies need training in multiple languages. Simply translating text isn't enough.
This system handles translation, cultural adaptation, and deployment.

**Strategic Framework:**

```
Content Audit → String Extraction → Translation Management → Cultural Adaptation → Testing → Deployment
```

**THE PROMPT (Copy this entire text):**

```
I need to localize my e-learning course:

Course: [NAME]
Source language: [English / other]
Target languages: [Spanish / French / Mandarin / etc.]
Audience: [Where are learners located]
Timeline: [When needed]

Design a localization system:

1. CONTENT AUDIT:
   - What needs translation? (Slides, videos, PDFs, help text)
   - What stays same? (Logos, some screenshots, external links)
   - Total words to translate: (rough estimate)
   - Are there images with text? (need re-creation, not just translation)

2. STRING EXTRACTION:
   - Text in slides: Extract all learner-facing text
   - UI text: Button labels, menus, help text
   - Video narration: Full scripts
   - Quiz questions and feedback: All assessment text
   - Handouts/PDFs: All documents
   - Format: Excel spreadsheet with all strings

3. TRANSLATION MANAGEMENT:
   - Professional translator? (better for technical/compliance content)
   - Translation service? (faster, but more expensive)
   - Machine translation (Google Translate)? (cheapest, but lower quality)
   - In-house bilingual staff? (depends on team)
   - Recommendation: Professional for critical content, machine for secondary

4. CULTURAL ADAPTATION:
   - Are examples culturally relevant? (adjust for target region)
   - Date formats: US = MM/DD/YY, EU = DD/MM/YYYY
   - Currency: USD vs. EUR vs. local currency
   - Colors: Green = positive in Western cultures, but different elsewhere
   - Idioms/metaphors: May not translate; use universal phrasing
   - Business practices: May differ by region
   - Examples to change: Customer names, company scenarios, references

5. VIDEO LOCALIZATION:
   - Full re-record with local talent? (expensive, best quality)
   - Dubbed audio? (cheaper, acceptable)
   - Subtitles only? (cheapest, learners can read)
   - Cost-benefit for each language

6. LMS CONFIGURATION:
   - Can LMS auto-detect language? (browser language)
   - Manual selection: Learner chooses language on login
   - Separate course instance per language? (simpler)
   - Single course with language switching? (more complex)

7. TESTING (in target language):
   - Grammar/spelling reviewed by native speaker
   - Context checks: Does term mean what you intended?
   - Screenshots with translated text: Do they fit?
   - Video subtitles: Are they accurate/readable?
   - Quiz: Does question translate unambiguously?
   - Navigation: Are menus/buttons readable in new language?

8. QUALITY ASSURANCE:
   - Glossary of terms (consistency across translations)
   - Native speaker review (not just machine translation)
   - Testing with actual learners in target language
   - Report: Any issues found, corrections made

9. DEPLOYMENT:
   - All versions tested? (yes)
   - LMS configured for language selection? (yes)
   - Help/support available in target language? (yes)
   - Communication to learners: Course now available in [language]
   - Phased rollout (one language at a time) or simultaneous?

10. MAINTENANCE:
    - If you update English course, do you update translations?
    - Process for keeping translations in sync
    - Quarterly review (any terminology changes?)

Create:
- String extraction list (what to translate)
- Translation brief (guidelines for translators)
- Cultural adaptation checklist
- Testing plan (how verify translations)
- Deployment checklist

Return as: Complete localization plan.
```

**Workflow: When to Use This**  
Use AFTER English course is finalized.  
Plan localization early (don't add last minute).  
Budget significant time/money (translation isn't cheap).

**Implementation Checklist:**

- [ ] Content audit complete (what needs translation)?
- [ ] Strings extracted into spreadsheet?
- [ ] Translation vendor selected?
- [ ] Cultural adaptation planned?
- [ ] Native speaker review scheduled?
- [ ] Video strategy decided (dub, subtitle, or re-record)?
- [ ] LMS configuration ready for language selection?
- [ ] Testing plan with native speakers?

**Real Example:**  
Customer: Global Compliance Training (English → Spanish, French, German)

Scope:

- 10 modules, 50 slides each
- 3 videos (5 min each)
- 2 quizzes per module
- Total: ~5,000 words + video scripts

Translation:

- Professional translator for English → Spanish (high risk content)
- Professional for English → French
- Professional for English → German
- Cost: ~0.15/word = 750 per language = $2,250 total
- Timeline: 2 weeks per language (overlap = 3 weeks total)

Cultural adaptation:

- Examples: Change names, company scenarios
- Date formats: European format in Spain/France/Germany
- Screenshots: Re-do any with English text
- Video: Subtitles only (cost-effective, acceptable for global audience)

Testing:

- Native speakers review translations (HR reps from each region)
- Test in LMS: Select Spanish → verify all text translated
- Quiz testing: Questions clear in target language
- Video subtitles: Reviewed for accuracy

Deployment:

- LMS language selection on login
- 4 course instances (English, Spanish, French, German)
- Announcement: "Course now available in your language"

Result: 4 regions trained in native language, compliance verified globally.

---

## SYSTEM 71 (or 21): The Course Metadata System

**📌 WHY THIS MATTERS:**  
LMS needs to know: What's this course? Who should take it? How long is it? Where does it fit?
This system captures metadata so LMS can organize, track, and report on courses.

**Strategic Framework:**

```
Define Metadata → Create SCORM Manifest → LMS Configuration → Catalog Listing → Tracking Enabled
```

**THE PROMPT (Copy this entire text):**

```
I need to set up metadata for my e-learning course:

Course: [NAME]
LMS: [Platform]
Launch date: [When]
Target audience: [WHO]

Define course metadata:

1. BASIC INFORMATION:
   - Course ID: (unique identifier, e.g., "COMP-101-v1")
   - Course title: (official name)
   - Course description: (2-3 sentences, what learners will do)
   - Subject/Category: (where in catalog? Compliance / Skills / etc.)
   - Version number: (v1.0, or later v1.1, v2.0)

2. AUDIENCE INFORMATION:
   - Target role(s): (Sales, Manager, All employees)
   - Required prerequisites: (must complete Course X first?)
   - Recommended audience: (ideal learner profile)
   - Exclusions: (who should NOT take this?)

3. DURATION & PACING:
   - Estimated duration: (3 hours, 2.5 hours)
   - Number of sessions: (1 sitting, or spread over 5 days?)
   - Completion deadline: (must finish by [date]?)
   - Can be paused/resumed? (yes/no)

4. LEARNING OBJECTIVES:
   - Course-level objectives: (3-5 main learning outcomes)
   - By completing this course, learner can...
   - Use Bloom's taxonomy (Remember / Apply / Evaluate)

5. ASSESSMENT INFORMATION:
   - Is course graded? (yes, final quiz / no, just completion)
   - Passing score: (80%+, or just completion)
   - Number of attempts: (1, 3, unlimited?)
   - Assessment type: (multiple choice quiz, project, observation?)

6. COMPLIANCE INFORMATION:
   - Compliance requirement: (GDPR, HIPAA, ISO, etc.)
   - Regulatory body: (FDA, OSHA, etc.)
   - Required frequency: (annual, one-time, biennial)
   - Documentation needed: (completion certificate, transcript)

7. TECHNICAL METADATA:
   - Export format: (SCORM 1.2, SCORM 2004, xAPI, Tin Can)
   - Platform compatibility: (Windows, Mac, iOS, Android)
   - Browser requirements: (Chrome, Firefox, Safari, Edge)
   - Accessibility: (WCAG 2.1 Level AA compliant? Yes/No)
   - Mobile compatible: (Yes / No / Partial)

8. CONTENT STRUCTURE:
   - Number of modules: (5 modules)
   - Module titles: (list all)
   - Estimated module duration: (30 min, 1 hour)
   - Is it linear? (must do Module 1 before 2, or can skip?)

9. MEDIA INFORMATION:
   - Contains video? (yes / no / hours)
   - Contains interactive elements? (yes / no / types)
   - Includes downloadable resources? (yes / no / what?)
   - Captions included? (yes / no)
   - Transcript available? (yes / no)

10. ORGANIZATIONAL INFORMATION:
    - Department owner: (L&D, Compliance, Sales)
    - Content expert/SME: (contact for questions)
    - Developer: (who built this?)
    - Last updated: (date)
    - Next review date: (when to update again?)

11. CATALOG/DISCOVERABILITY:
    - Keywords: (search terms so people find this)
    - Example: "GDPR, privacy, data protection, compliance"
    - Related courses: (what other courses is this related to?)
    - Display in catalog: (visible / hidden / restricted)

12. SCORM MANIFEST (technical file):
    - Organization structure
    - Resource references
    - Tracking parameters
    - Scoring rules
    - (Usually auto-generated by Articulate when publishing)

Create:
- Metadata spreadsheet (all above information)
- SCORM manifest file (if required)
- LMS configuration document (how to set up in your LMS)
- Catalog description (what displays to learners)

Return as: Complete course metadata system.
```

**Workflow: When to Use This**  
Use BEFORE launching course in LMS.  
Complete metadata ensures proper tracking and discoverability.

**Implementation Checklist:**

- [ ] Course ID assigned (unique)?
- [ ] Title and description clear?
- [ ] Target audience defined?
- [ ] Duration estimated?
- [ ] Learning objectives listed (3-5)?
- [ ] Assessment info specified (graded or not)?
- [ ] Compliance info documented?
- [ ] Technical specs (format, browsers, mobile)?
- [ ] SCORM manifest created/verified?
- [ ] Catalog description written?

**Real Example:**  
Customer: Compliance Training Course

Metadata:

- Course ID: GDPR-101-v1.0
- Title: "GDPR Data Protection Fundamentals"
- Description: "Learn EU data protection regulations and how to handle customer data safely. 2.5 hours."
- Target roles: All employees
- Prerequisites: None
- Duration: 2.5 hours
- Passing score: 80% on final quiz
- Compliance: GDPR (EU regulation)
- Completion deadline: December 31, 2025
- Accessibility: WCAG 2.1 AA compliant
- Mobile compatible: Yes
- Learning objectives:
  - Define personal data under GDPR
  - Apply data protection principles to job responsibilities
  - Identify breach reporting procedures
- Keywords: "GDPR, privacy, data protection, compliance, EU regulation"

SCORM manifest:

- Format: SCORM 1.2
- Tracking: Completion + quiz score
- Passing: cmi.core.score ≥ 80
- Manifest maps 5 modules + final quiz

Result: LMS properly configured, course discoverable, tracking enabled.

---

## SYSTEM 72 (or 22): The Course Launch Communications System

**📌 WHY THIS MATTERS:**  
Great course = nobody knows it exists = zero completion.
This system markets the course so people actually enroll and complete it.

**Strategic Framework:**

```
Stakeholder Alignment → Email Campaign → Kickoff Meeting → FAQ Support → Enrollment & Completion
```

**THE PROMPT (Copy this entire text):**

```
I'm launching a new e-learning course:

Course: [NAME]
Target audience: [NUMBER, ROLE]
Launch date: [WHEN]
Completion deadline: [ANY?]
Communication channels: [Email, LMS, Slack, meeting, etc.]

Create a launch communications plan:

1. PRE-LAUNCH (2-4 weeks before):

   ANNOUNCEMENT EMAIL (to all stakeholders):
   - What is this course?
   - Who needs to take it? (all employees? only managers?)
   - Why does it matter? (business impact, compliance, career benefit)
   - Launch date
   - How to enroll
   - Target completion date
   - Contact for questions

   MANAGER BRIEFING (for supervisors):
   - Overview of course
   - Why their team needs this
   - How much time it takes (so they can plan workload)
   - How to support learners
   - How they'll see learner progress
   - Q&A

2. LAUNCH DAY (when course goes live):

   LAUNCH EMAIL:
   - "Course is now live!"
   - Direct enrollment link (make it easy to click and start)
   - Estimated completion time (so people know commitment)
   - Why this matters (motivational message)
   - Reminder: Deadline is [date] (if applicable)

   POST IN COMPANY CHANNELS (Slack, Teams, intranet):
   - "New course available: [Name]"
   - Emoji, engaging tone
   - Link to course

3. ONGOING (during launch period):

   REMINDER EMAILS (weekly, 2-4 weeks):
   - "Have you started yet?"
   - Highlight who's already completed (show progress)
   - "30 min to complete" (show how easy it is)
   - Link to course
   - FAQ: "Common questions answered"

   ENGAGEMENT TACTICS:
   - Success stories: "Sarah completed this course and learned how to..."
   - Tips: Share one learning from course
   - Leaderboard: "Top teams by completion" (friendly competition)
   - "One week left!" urgency reminder

4. FAQ DOCUMENT:
   - What is this course about?
   - Who should take it?
   - How long does it take?
   - How do I enroll?
   - I already know this material—do I have to take it?
   - Can I take it on my phone?
   - What if I don't finish by deadline?
   - Can I retake the quiz?
   - How do I get a certificate?
   - I'm having technical problems. Help!

5. SUPPORT & HELP:
   - Who to contact if they have questions? (email, Slack, phone)
   - Technical support: IT help desk link
   - Course content questions: Email to [contact]
   - Accommodations (need more time, different format): Contact HR
   - Response time guarantee: "We'll respond within 24 hours"

6. INCENTIVES (optional, optional):
   - Certificate upon completion?
   - Public recognition (email shout-out)?
   - Early completion bonus (first 50 to finish get recognized)?
   - Career growth: "This skill builds toward promotion"
   - Competitive: Team with highest completion gets [small prize]

7. MEASUREMENT:
   - Enrollment rate: % who started by week 1
   - Completion rate: % who finished by deadline
   - Time to completion: Average time to finish
   - Engagement: % who took quiz, passed, etc.
   - Feedback: What did learners think? (survey)

8. MESSAGING THEMES:
   - If mandatory: "Required for compliance/role. Here's why it matters."
   - If optional: "Invest in your skill development. Here's what you'll learn."
   - If career-linked: "This unlocks certification/promotion path."
   - If skill-based: "Learn from experts. See real-world applications."

Create:
- Email templates (announcement, launch, reminders)
- Manager briefing slides
- FAQ document
- Social media/chat posts
- Support information
- Measurement/tracking plan

Return as: Complete launch communications system.
```

**Workflow: When to Use This**  
Use 4-6 weeks BEFORE course launch.  
Plan communications while course is being finalized.  
Execute launch plan on schedule (don't wait until last minute).

**Implementation Checklist:**

- [ ] Launch date confirmed?
- [ ] Announcement email drafted and approved?
- [ ] Manager briefing scheduled?
- [ ] FAQ document completed?
- [ ] Support contact assigned?
- [ ] Enrollment link tested (works)?
- [ ] Reminder email schedule planned?
- [ ] Success stories prepared?
- [ ] Measurement plan in place?

**Real Example:**  
Customer: Annual Compliance Training Launch

Timeline:

- Week -4: Announce course coming (preview)
- Week -2: Manager briefing
- Week 0: Launch day (course live, big announcement)
- Week +1: Reminder email + FAQ
- Week +2: Success story email ("John completed it in 45 min")
- Week +3: Urgent reminder ("1 week left!")
- Week +4: Deadline

Email example (launch):

- Subject: "🚀 New Required Training: Annual Compliance"
- "Hi all, Your annual compliance course is now live! Complete by December 15."
- "⏱️ 2.5 hours (flexible schedule, take anytime)"
- "Why: Keep our company secure and compliant"
- "[Enroll Now]"
- "Questions? [compliance@company.com](mailto:compliance@company.com)"

Results:

- Week 1 enrollment: 92% (vs. 60% typical)
- Final completion: 98% by deadline (vs. 75% typical)
- Feedback: "Knew what to expect, had time to plan, easy to enroll"

---

## SYSTEM 73 (or 23): The Feedback Loop System (Post-Launch)

**📌 WHY THIS MATTERS:**  
After launch, real learners show you what's broken or confusing. You can fix it.
This system captures feedback and uses it to improve courses.

**Strategic Framework:**

```
Feedback Collection → Issue Analysis → Prioritization → Fix Implementation → Retest → Deploy Improvement
```

**THE PROMPT (Copy this entire text):**

```
I want to collect and act on learner feedback:

Course: [NAME]
Launch date: [WHEN]
Audience: [NUMBER, ROLE]
Feedback channels: [Post-course survey / Discussion forum / Support emails / etc.]

Design a feedback loop system:

1. FEEDBACK COLLECTION:

   POST-COURSE SURVEY (immediately after):
   - "Course clarity: 1-5 stars"
   - "Content relevance: 1-5 stars"
   - "Would you recommend? Yes/No"
   - "What was most helpful?"
   - "What confused you?"
   - "How will you use this?"
   - Open-ended: "Any other feedback?"
   - Goal: 50%+ completion of survey

   DISCUSSION FORUM (during course):
   - "What questions do you have?"
   - "Anyone confused on Module 3?"
   - Monitor for common issues (multiple people asking same question = signal)

   SUPPORT EMAILS:
   - Track all support requests
   - Categorize: Technical / Content / Access / Other
   - Pattern: If 5+ people email about same issue, it's a problem

2. ISSUE CATEGORIZATION:
   - Critical (breaks course, prevents completion): Fix ASAP
   - High (confusing, learners struggling): Fix within 1 week
   - Medium (could be clearer, but not blocking): Fix within 2 weeks
   - Low (nice-to-have, minor cosmetic): Fix in next version

   Examples:
   - Critical: Quiz won't submit (blocks completion)
   - High: Module 3 explanation is confusing (learner says "I still don't get it")
   - Medium: Typo on slide 5 (doesn't impact learning)
   - Low: Background color could be lighter (aesthetic)

3. ANALYSIS:
   - What's the pattern? (is this a one-time issue or systematic?)
   - Root cause: Why is learner confused?
   - Solution: What do we change?
   - Impact: How many learners affected?

4. PRIORITIZATION:
   - Frequency: How many people reported this?
   - Severity: Does it block learning or just minor?
   - Effort: How hard to fix? (1 hour vs. 1 day)
   - Impact: How much will fix improve experience?

   Formula: High frequency + High severity + Low effort = Fix first

5. FIX IMPLEMENTATION:
   - Make the change (rewrite content, fix interaction, etc.)
   - Document what changed (version notes)
   - Testing: Verify fix works, doesn't break anything else
   - Re-deploy: Push new version to LMS

6. COMMUNICATION:
   - Announce the improvement: "Based on feedback, we improved [X]"
   - Show you listened: Learners feel heard
   - Transparency: "3 people reported this, we fixed it"

7. MEASUREMENT:
   - Did satisfaction improve? (re-survey after fix)
   - Did confusion reduce? (fewer support emails on that topic)
   - Did completion improve? (more people finishing)

8. FEEDBACK TRACKING:
   - Spreadsheet: Feedback date, issue, category, status, fix date
   - Prevents losing issues (everything tracked)
   - Shows progress (visual evidence of improvements)

9. CONTINUOUS IMPROVEMENT CYCLE:
   - Week 1-2 post-launch: Gather initial feedback
   - Week 3: Analyze, prioritize, fix critical issues
   - Week 4: Re-deploy with improvements
   - Month 2-3: Continue gathering feedback, make smaller improvements
   - Month 6: Major revision if needed based on accumulated feedback

10. LONG-TERM IMPROVEMENTS:
    - Every 3-6 months: Review all feedback collected
    - Pattern recognition: "Module 2 always gets complaints"
    - Major redesign: If systematic issues, redesign that section
    - Version 2.0: Released with improvements based on 6 months feedback

Create:
- Survey template (questions to ask)
- Issue tracking spreadsheet
- Prioritization matrix (which to fix first)
- Fix implementation process
- Version notes (what changed in v1.1, v1.2, etc.)

Return as: Complete feedback loop system.
```

**Workflow: When to Use This**  
Set up BEFORE launch (so you're ready to collect feedback day 1).  
Implement continuous improvement cycle (don't fix everything at once).  
Balance quick fixes (high priority) with long-term improvements.

**Implementation Checklist:**

- [ ] Survey created and tested?
- [ ] Multiple feedback channels active (survey + forum + email)?
- [ ] Tracking spreadsheet ready?
- [ ] Prioritization criteria defined?
- [ ] Support contact monitoring for issues?
- [ ] Fix process established (who approves, who deploys)?
- [ ] Re-testing process in place?
- [ ] Learners notified of improvements?

**Real Example:**  
Customer: Skills Training Course (Week 1 feedback)

Issues collected:

- "Module 2 video won't play" (5 emails) → CRITICAL
- "Quiz question unclear" (3 forum posts) → HIGH
- "Layout looks weird on mobile" (4 survey comments) → HIGH
- "Button text says 'Submit' but should say 'Check'?" (1 email) → LOW
- "Intro animation too slow" (2 survey responses) → MEDIUM

Fix priority (order):

1. Video won't play (blocks 5 people from completing)
2. Quiz question reworded (5 people confused)
3. Mobile layout fixed (4 people on phones)
4. Animation timing adjusted (2 people annoyed)
5. Button text updated (low impact, cosmetic)

Timeline:

- Day 1: Video issue identified and escalated to tech support
- Day 2: Video reposted, tested, deployed
- Day 3: Quiz question reworded, new version published
- Day 4: Mobile CSS fixed, tested on iPhone/Android
- Day 5: Animation timing adjusted
- Week 2: Button text updated (lower priority)
- Week 2 announcement: "Based on your feedback, we've made these improvements"

Results:

- Support emails drop from 5+ per day to <1 per day
- Week 2 survey satisfaction improves: 4.1/5 → 4.5/5 stars
- Completion rate: Still strong (no loss of momentum from Week 1 issues)
- Learner comment: "Great! You listened to feedback and fixed it fast"

---

## SYSTEM 74 (or 24): The Course Update Strategy System

**📌 WHY THIS MATTERS:**  
Courses get outdated. Regulations change. Software updates. You can't rebuild from scratch each time.
This system manages ongoing course updates without massive rework.

**Strategic Framework:**

```
Content Audit → Update Planning → Prioritization → Rapid Iteration → Version Management → Redeployment
```

**THE PROMPT (Copy this entire text):**

```
I need to keep my course current and updated:

Course: [NAME]
Release date: [WHEN]
Update frequency: [Annually / Quarterly / As needed]
Change types: [Content updates / Legal changes / Process changes / Tool updates]

Design a course update strategy:

1. CONTENT AUDIT (annual):
   - Is this content still accurate?
   - Any regulations changed?
   - Any processes changed?
   - Is it still relevant to learners?
   - Any feedback suggesting improvements?
   - Result: List of changes needed

2. CATEGORIZE CHANGES:
   - Cosmetic: Typo, outdated screenshot, style refresh (quick fix)
   - Content: Concept explanation, example, case study (moderate rewrite)
   - Process: Step-by-step how to do something (significant change)
   - Regulatory: Legal requirement change (critical, must be done)
   - Structural: Remove/add entire module (major redesign)

3. PRIORITIZATION:
   - CRITICAL (do immediately): Regulatory changes, broken interactivity, legal risk
   - HIGH (do this quarter): Content outdated, compliance gap, frequently asked question
   - MEDIUM (do this year): Cosmetic improvements, better examples, UI refresh
   - LOW (consider for next major version): "Nice to have" improvements

4. UPDATE PLANNING:
   - What to update: Specific sections/modules
   - Why: What's the change driver
   - How: Rewrite slide? Replace example? Redo video?
   - Timeline: How long will update take?
   - Testing: What needs verification after change?
   - Deployment: How notify learners of update?

5. RAPID UPDATE PROCESS:
   - Keep course modular (so you can update one module without touching others)
   - Master copy: Always update the original, never just one LMS instance
   - Version control: Track changes (v1.0 → v1.1 → v1.2)
   - Testing: Verify the updated section works
   - Redeployment: Push new version to all users

6. COMMUNICATIONS:
   - Learners already enrolled: "Course updated, new content available"
   - New learners: Enroll in latest version (no outdated material)
   - Change log: Document what changed (optional, if major)

7. VERSION NUMBERING:
   - Cosmetic fix: v1.1 (minor)
   - Content update: v1.5 (moderate)
   - Major redesign: v2.0 (new version)
   - Example timeline: v1.0 (launch) → v1.1 (quick fix) → v1.2 (feedback improvements) → v1.5 (annual update) → v2.0 (major redesign)

8. TRACKING UPDATES:
   - Spreadsheet: Update date, version, what changed, why, who did it
   - Prevents forgotten updates (all tracked)
   - Shows timeline of improvements
   - Useful for regulatory compliance (proof of keeping course current)

9. KEEPING MASTER COPY SAFE:
   - Backup: Before any update, backup previous version
   - Cloud storage: Master file always on OneDrive / Google Drive
   - Access control: Only authorized people edit master
   - Change log: Track every change made (who, when, what)

10. ANNUAL MAINTENANCE SCHEDULE:
    - January: Content audit (what needs updating?)
    - February-March: Plan updates, prioritize
    - April-May: Execute updates
    - June: Testing, get feedback
    - July: Deploy updated version
    - Aug-Dec: Monitor usage, gather feedback
    - Repeat cycle

Create:
- Content audit checklist (annually)
- Change prioritization matrix
- Update planning template
- Version control spreadsheet
- Testing checklist
- Communication templates

Return as: Complete course update strategy.
```

**Workflow: When to Use This**  
Establish maintenance plan at launch (not after).  
Schedule annual content audit (same time each year).  
Build updates into schedule (not ad-hoc when problems arise).

**Implementation Checklist:**

- [ ] Annual audit schedule set?
- [ ] Change categorization defined?
- [ ] Prioritization criteria clear?
- [ ] Master copy organized and backed up?
- [ ] Version numbering system established?
- [ ] Testing process defined?
- [ ] Communication templates ready?
- [ ] Tracking spreadsheet in place?

**Real Example:**  
Customer: Compliance Course (Ongoing maintenance)

v1.0 (Launch, Jan 2024):

- Full course: 5 modules, 25 slides, 2 quizzes

v1.1 (Mar 2024):

- Fixed typo on slide 7
- Updated screenshot (new UI version)
- Clarified one quiz question
- Time to update: 2 hours
- Reason: Feedback from learners

v1.2 (May 2024):

- One video had audio issue, re-recorded
- Added FAQ document (based on support questions)
- Updated example company names (more relevant)
- Time to update: 4 hours
- Reason: Quality improvement

v1.5 (Aug 2024):

- Annual audit: Content still accurate (yes)
- New regulation requirement: Updated Module 3 content
- Refreshed all screenshots (new tool version released)
- Replaced 2 outdated case studies with current examples
- Time to update: 12 hours
- Reason: Annual maintenance + regulatory change

v2.0 (planned for Jan 2025):

- Major redesign: Add interactive scenarios (not in v1.x)
- Redesign all visuals (brand refresh)
- Add micro-learning version (5-min modules)
- Time to update: 40+ hours
- Reason: Significant feature/design improvement

Tracking:
| Version | Date | Changes | Hours | Reason |
| v1.1 | Mar | Typo, screenshot, quiz clarity | 2 | Feedback |
| v1.2 | May | Video, FAQ, examples | 4 | Quality |
| v1.5 | Aug | Regulation update, screenshots, cases | 12 | Annual audit |

Result: Course stays current, issues fixed quickly, learners see improvements, compliance maintained.

---

## SYSTEM 75 (or 25): The Advanced Storytelling System (Narrative Design)

**📌 WHY THIS MATTERS:**  
Courses that just deliver facts = forgettable. Courses that tell stories = remembered for years.
This system uses narrative design to make e-learning engaging and memorable.

**Strategic Framework:**

```
Character → Emotional Arc → Meaningful Choices → Consequences Matter → Transformation → Memorable Learning
```

**THE PROMPT (Copy this entire text):**

```
I want to use storytelling to make my e-learning more engaging:

Course topic: [TOPIC]
Learning goal: [WHAT SHOULD LEARNER UNDERSTAND]
Audience: [WHO]
Tone: [Professional / Casual / Inspiring]

Design an engaging narrative:

1. CHARACTER DEVELOPMENT:
   - Who is the protagonist? (main character)
   - What's their situation? (why do they need to learn this?)
   - What's their problem/goal? (what are they trying to accomplish?)
   - Relatable? (does audience see themselves in character?)

   Example: "Sarah is a new manager. She's promoted but unsure how to lead. Her goal: become confident leader."
   - Audience (managers) sees themselves in Sarah
   - Makes learning personal, not abstract

2. EMOTIONAL ARC (journey):
   - Act 1 - Setup: Character in comfortable situation, problem arises
   - Act 2 - Complication: Character tries approaches, some work, some fail
   - Act 3 - Climax: Major decision point, make or break moment
   - Act 4 - Resolution: Character learns lesson, transforms
   - Audience feels journey (not just learning facts)

3. MEANINGFUL CHOICES (learner agency):
   - Learner is NOT passive observer
   - Character faces decision, learner decides what to do
   - Different choices → different consequences
   - Consequence is realistic, not punishing (if wrong, show why)

   Example:
   - Scenario: Sarah's team member is missing deadlines
   - Learner choice: Listen & coach / Give deadline / Reassign task
   - Consequence: Each leads to different outcome (shown, not told)

4. LEARNING THROUGH CONSEQUENCES:
   - Learner's choice leads to consequence
   - Consequence teaches lesson (not lecture)
   - Example: "You chose to reassign task. Sarah's team member feels unvalued, quits. Cost: Replacement, knowledge loss"
   - Learned implicitly: Reassigning without coaching doesn't solve problem
   - Much more memorable than slide saying "Coaching is important"

5. TRANSFORMATION:
   - Character grows/changes by end
   - Learner sees transformation (before/after)
   - Learner realizes they could transform similarly

   Example:
   - Sarah (start): "I just got promoted, I'm overwhelmed"
   - Sarah (end): "I understand how to lead. My team trusts me"
   - Learner feels: "I can do that too"

6. BRANCHING NARRATIVE:
   - Multiple paths through story (different choices = different paths)
   - All paths lead to learning (right or wrong approach both teach)
   - Can play through different paths to see all outcomes
   - Increases engagement (replay value)

7. REALISTIC SCENARIOS:
   - Story problems = real job problems
   - Not fictional fantasy, but true to learner's world
   - Stakeholders recognize themselves in scenarios

   Example (Sales): "You're closing a big deal. Customer says price is too high. What do you do?"
   - Sales reps face this daily
   - Story is their life

8. DIALOGUE & AUTHENTICITY:
   - Characters talk like real people (not robots)
   - Dialogue reveals character, advances story
   - Tone matches your organization (professional but warm?)

   Example:
   - Bad: "The data clearly indicates that proactive communication facilitates positive outcomes."
   - Better: "Talking early prevents fires later. Trust me on this."

9. VISUAL STORYTELLING:
   - Consistent character appearances (same person throughout story)
   - Visual cues (colors, settings) show emotional tone
   - Animation shows time passage, emotion
   - "Show, don't tell" (learner infers lesson from story, not narrator explaining)

10. PACING & REFLECTION:
    - Story moves, but learner has time to reflect
    - "What would you do?" pauses (learner thinks)
    - Debrief: "Here's what we learned from this story"
    - Not too fast (confusing), not too slow (boring)

11. MULTIPLE STORYTELLING APPROACHES:

    SINGLE CHARACTER ARC:
    - One character throughout (Sarah's journey)
    - Learner follows same person, sees transformation

    MULTIPLE SCENARIOS:
    - Different characters, different situations
    - Each teaches different angle of same lesson
    - Richer understanding

    CHOICE-DRIVEN NARRATIVE:
    - Learner choices determine story path
    - Multiple endings based on choices
    - Higher engagement

    BRANCHING STORY:
    - Main story trunk, branches off at decision points
    - Can replay, see all outcomes

Create:
- Story outline (character, arc, key scenes)
- Storyboard (visual story progression)
- Choice points (where learner decides)
- Consequence matrix (what happens if X choice made)
- Dialogue examples (character voices)
- Pacing guide (when to pause for reflection)

Return as: Complete narrative design for engaging e-learning.
```

**Workflow: When to Use This**  
Use during DESIGN phase (design narrative before building in Storyline).  
Work with writer (if possible) to craft compelling story.  
Storyboard the narrative before developing interactions.  
Test story with sample learners (does it engage? Is it clear?).

**Implementation Checklist:**

- [ ] Character defined (relatable, realistic)?
- [ ] Emotional arc sketched (setup → complication → climax → resolution)?
- [ ] Meaningful choices embedded (learner makes decisions)?
- [ ] Consequences realistic (shown, not told)?
- [ ] Character transformation clear?
- [ ] Multiple paths work (choices lead somewhere)?
- [ ] Dialogue authentic?
- [ ] Tested with sample learners?

**Real Example:**  
Customer: Leadership Training with Narrative Design

Story: "Meet Raj"

ACT 1 - SETUP (2 min):

- Raj is promoted to team lead
- He's excited but nervous ("I've never managed people")
- His team: 5 people, mixed experience levels
- Goal: "I want to be a great leader"
- Audience (managers) feels: "That's me when I was promoted"

ACT 2 - COMPLICATIONS (7 min):

- Scenario 1: Team member missing deadlines
  
  - Choice A: Assign work to someone else
  - Choice B: Sit down and ask what's wrong (coaching approach)
  - Consequence A: "You reassigned, but original person feels unvalued, quits"
  - Consequence B: "You learned she had personal issue, coached her through it, now high performer"

- Scenario 2: Team disagrees in meeting
  
  - Choice A: You decide and move on (authoritarian)
  - Choice B: Facilitate discussion, get consensus (collaborative)
  - Consequence A: "Decision made fast, but team feels unheard"
  - Consequence B: "Takes longer, but team buys in and executes better"

ACT 3 - CLIMAX (3 min):

- Raj's manager says "I'm promoting one of your people. Who would you recommend?"
- This is learner's choice (no wrong answer, all teach lesson)
- Choice A: "Promote the high performer" (obvious)
- Choice B: "Promote the person I coached (team member who struggled but grew)"
- Consequence: Choice B shows that investing in people creates leaders
- Learning: Development and coaching create culture

ACT 4 - RESOLUTION (2 min):

- 6 months later: Raj's team has lowest turnover, highest engagement
- New leader (promoted from team) is thriving
- Raj reflects: "I learned that good leadership is about developing people, not just decisions"
- Audience feels: "I can do that too. I'll invest in my team."

BRANCHING: Learner can replay, make different choices, see different outcomes

Result:

- Completion rate: 96% (vs. 70% for non-narrative course)
- Learner comments: "I saw myself in Raj. Made me want to be a better leader"
- Measurable behavior change: Managers report more coaching conversations
- Memorable: Learners remember Raj's story months later

---

## COMPLETE SYSTEMS LIBRARY

**You now have:**

- 50 base AI Systems (general instructional design)
- 25 e-learning specialized systems (Storyline, Moodle, interactive design)
- **TOTAL: 75 complete, professional AI systems**

---

## REMINDER: **HOW TO USE THIS ENTIRE LIBRARY:**

**Each system is a standalone workflow**

1. Read "Why This Matters" (understand the problem)
2. Understand "Strategic Framework" (see the thinking)
3. Copy "The Prompt" section (paste into AI)
4. Follow "Workflow" (when to use this)
5. Use "Checklist" (verify it worked)
6. Study "Real Example" (see it in action)

## Action: Copy the prompt, paste into AI, fill in your situation, get results.

This file is viewed best with [MarkText](https://marktext.me/) markdown editor (free, for Windows, macOS)