pinion-innovation-content/docs/user-guide.md

# User Guide

## Innovation Content: Educational Content Development Modes & Skills

**Version:** 1.1.0  
**Audience:** Educational Content Developers, Instructional Designers, Content Producers  
**Date:** 2026-04-24

---

## 1. Introduction

### 1.1 What is Innovation Content?

Innovation Content is a specialized suite of **modes** and **skills** for Roo Code that transforms how educational content is created, reviewed, and delivered. Think of it as having six expert colleagues—each specializing in a different aspect of educational content development—working alongside you in your code editor.

### 1.2 Core Concepts

#### Modes

A **mode** is a specialized configuration of Roo Code tailored to a specific role. When you activate a mode, Roo Code adopts the behavior, permissions, and expertise of that role.

| Mode | Role | When to Use |
|------|------|-------------|
| 📝 Curriculum Designer | Educational architect | When designing curricula, learning objectives, and course structures |
| 📖 Instructional Writer | Content author | When writing lesson content, exercises, and learner documentation |
| 🧪 Assessment Developer | Measurement specialist | When creating quizzes, rubrics, and evaluation criteria |
| 🎬 Content Producer | Multimedia creator | When producing video scripts, interactive content, and media assets |
| 🎨 Learning Experience Designer | Engagement specialist | When designing learner journeys, gamification, and microlearning |
| ♿ Accessibility Auditor | Inclusion specialist | When auditing content for WCAG compliance and accessibility |

#### Skills

A **skill** is a reusable capability that modes can invoke. Skills are like specialized tools in a workshop—each one does a specific job well.

For example, the Curriculum Designer mode has these skills:
- `learning-objective-validator` — Checks that objectives use proper Bloom's Taxonomy verbs
- `competency-mapper` — Maps objectives to standards like Common Core or NGSS
- `curriculum-gap-analyzer` — Finds gaps in curriculum coverage

### 1.3 How It Works

```
You provide input → Mode processes it using skills → You get structured output
```

Each mode follows a defined workflow, applies best practices, and communicates with other modes through standardized handoffs.

---

## 2. Getting Started

### 2.1 Your First Session

**Step 1: Choose Your Mode**

Think about what you're trying to accomplish:

- "I need to design a new course" → **Curriculum Designer**
- "I need to write lesson content" → **Instructional Writer**
- "I need to create a quiz" → **Assessment Developer**
- "I need to produce a video" → **Content Producer**
- "I need to design a learning journey" → **LX Designer**
- "I need to check accessibility" → **Accessibility Auditor**

**Step 2: Activate the Mode**

In Roo Code, switch to your chosen mode:

```
Switch to curriculum-designer mode
```

**Step 3: Provide Your Input**

Give the mode context about what you're working on:

```
I need to create a curriculum for a high school biology course on photosynthesis.
The target audience is 9th grade students. The course should align with NGSS standards.
```

**Step 4: Review the Output**

The mode will generate structured output. Review it and provide feedback:

```
The learning objectives look good, but I'd like more emphasis on the light-dependent reactions.
```

### 2.2 The Content Development Workflow

The six modes work together in a pipeline:

```
1. Curriculum Designer defines WHAT to teach
   ↓
2. Instructional Writer creates HOW to teach it
   ↓
3. Assessment Developer creates HOW to measure learning
   ↓
4. Content Producer creates MULTIMEDIA materials
   ↓
5. LX Designer creates ENGAGING experiences
   ↓
6. Accessibility Auditor ensures EVERYONE can access it
```

You can start at any point in the pipeline depending on your role.

---

## 3. Using Modes Effectively

### 3.1 Curriculum Designer Mode

**Best for:** Course architects, curriculum coordinators, instructional designers

**What it does:**
- Validates learning objectives using Bloom's Taxonomy
- Maps objectives to educational standards
- Identifies gaps in curriculum coverage
- Validates prerequisite chains

**How to get the best results:**

1. **Be specific about your audience:**
   ```
   Good: "Create objectives for 10th grade chemistry students"
   Better: "Create 8 measurable objectives for 10th grade chemistry on chemical bonding, aligned to NGSS HS-PS1-2"
   ```

2. **Provide existing standards:**
   ```
   "Align this curriculum to Common Core Math standards for Algebra II, specifically A-SSE, A-APR, and F-IF clusters"
   ```

3. **Ask for gap analysis:**
   ```
   "Analyze this curriculum for gaps. Are there any NGSS performance expectations not covered?"
   ```

**Pro tip:** Start with the end in mind. Tell the Curriculum Designer what students should be able to DO after completing the course, and it will work backward to design the curriculum.

### 3.2 Instructional Writer Mode

**Best for:** Content writers, subject matter experts, teachers

**What it does:**
- Analyzes content readability (Flesch-Kincaid, SMOG)
- Ensures tone consistency across lessons
- Designs active learning exercises
- Evaluates explanation quality

**How to get the best results:**

1. **Specify your audience's reading level:**
   ```
   "Write this lesson for 8th grade reading level (Flesch-Kincaid grade 8)"
   ```

2. **Provide the learning objectives:**
   ```
   "Write a lesson that helps students achieve this objective: 'Students will be able to explain the process of photosynthesis'"
   ```

3. **Request active learning:**
   ```
   "Include 3 active learning exercises: one individual, one pair, and one group activity"
   ```

**Pro tip:** Use the Hook-Define-Example-Elaborate-Check structure for explanations. The Instructional Writer will follow this pattern automatically if you ask for "well-structured explanations."

### 3.3 Assessment Developer Mode

**Best for:** Assessment designers, test developers, evaluators

**What it does:**
- Validates assessment alignment to objectives
- Performs item analysis (difficulty, discrimination)
- Generates rubrics with performance descriptors
- Detects bias in assessment items

**How to get the best results:**

1. **Provide the learning objectives:**
   ```
   "Create 10 multiple-choice questions that assess this objective: 'Students will be able to solve quadratic equations'"
   ```

2. **Specify difficulty distribution:**
   ```
   "Include 3 easy, 5 medium, and 2 difficult questions"
   ```

3. **Request bias review:**
   ```
   "Review these assessment items for gender, cultural, and socioeconomic bias"
   ```

**Pro tip:** Always ask for a rubric when creating performance assessments. The rubric-generator skill creates analytic rubrics with clear performance descriptors for each level.

### 3.4 Content Producer Mode

**Best for:** Video producers, multimedia designers, e-learning developers

**What it does:**
- Validates storyboards against objectives
- Manages multimedia assets
- Packages content for SCORM/xAPI LMS delivery
- Creates H5P interactive content

**How to get the best results:**

1. **Provide the storyboard or script:**
   ```
   "Create a 5-minute explainer video storyboard about the water cycle for middle school students"
   ```

2. **Specify accessibility requirements:**
   ```
   "Ensure all video content includes captions and transcripts"
   ```

3. **Request SCORM packaging:**
   ```
   "Package this content as a SCORM 2004 package for Moodle LMS"
   ```

**Pro tip:** Keep videos under 6 minutes for optimal engagement. The Content Producer will automatically suggest breaking longer content into micro-videos.

### 3.5 Learning Experience Designer Mode

**Best for:** UX designers, engagement specialists, learning technologists

**What it does:**
- Maps learner journeys and pathways
- Analyzes engagement patterns
- Designs gamification elements
- Architects microlearning structures

**How to get the best results:**

1. **Provide the content package:**
   ```
   "Design a learner journey for this 8-module course on data science. Each module takes about 30 minutes"
   ```

2. **Specify engagement goals:**
   ```
   "Include gamification elements that motivate completion without relying on extrinsic rewards"
   ```

3. **Request microlearning structure:**
   ```
   "Break this 2-hour module into microlearning units of 5-15 minutes each"
   ```

**Pro tip:** Focus on intrinsic motivation. The gamification-designer skill prefers badges and achievement systems that recognize mastery over points and leaderboards.

### 3.6 Accessibility Auditor Mode

**Best for:** Accessibility specialists, QA testers, content reviewers

**What it does:**
- Audits WCAG 2.1/2.2 compliance at A, AA, AAA levels
- Simulates screen reader experience
- Analyzes color contrast ratios
- Provides remediation guidance

**How to get the best results:**

1. **Provide the content to audit:**
   ```
   "Audit this lesson page for WCAG 2.1 AA compliance"
   ```

2. **Specify the target level:**
   ```
   "Check this content against WCAG 2.2 AA success criteria"
   ```

3. **Request remediation guidance:**
   ```
   "For each issue found, provide specific remediation steps with code examples"
   ```

**Pro tip:** Run the Accessibility Auditor early and often. It's easier to fix accessibility issues during creation than after publication.

---

## 4. Optimizing Your Workflow

### 4.1 Time-Saving Strategies

| Strategy | Description | Time Saved |
|----------|-------------|------------|
| **Batch similar tasks** | Group all objective writing, then all lesson writing, then all assessment creation | 20-30% |
| **Use mode handoffs** | Let modes pass work to each other automatically | 15-25% |
| **Leverage skills directly** | Invoke specific skills when you only need one capability | 10-20% |
| **Template your inputs** | Create reusable input templates for common tasks | 25-35% |

### 4.2 Input Templates

**Curriculum Design Template:**
```
Role: Curriculum Designer
Task: Create curriculum for [subject] at [level]
Audience: [target audience, age, prior knowledge]
Standards: [educational standards to align to]
Duration: [course length, session length]
Objectives: [number of objectives desired]
Output format: [curriculum document, objective list, etc.]
```

**Lesson Writing Template:**
```
Role: Instructional Writer
Task: Write lesson on [topic]
Audience: [target audience, reading level]
Objectives: [learning objectives this lesson addresses]
Length: [estimated word count or duration]
Activities: [types of activities to include]
Tone: [formal, conversational, etc.]
```

**Assessment Creation Template:**
```
Role: Assessment Developer
Task: Create assessment for [topic/objective]
Type: [multiple choice, essay, performance, etc.]
Items: [number of items]
Difficulty: [distribution: easy/medium/hard]
Rubric: [yes/no, type of rubric]
Bias review: [yes/no]
```

### 4.3 Cross-Mode Collaboration

**Scenario: Creating a Complete Course**

1. **Start with Curriculum Designer:**
   ```
   "Design a 6-module curriculum on Python programming for beginners.
   Align to CSTA standards. Each module should have 3-5 measurable objectives."
   ```

2. **Hand off to Instructional Writer:**
   ```
   "Pass this curriculum to the Instructional Writer. Write lesson content
   for Module 1: Variables and Data Types. Target reading level: grade 10."
   ```

3. **Hand off to Assessment Developer:**
   ```
   "Pass the Module 1 lesson to the Assessment Developer. Create a 15-item
   quiz with 5 easy, 7 medium, 3 difficult questions. Include a rubric for
   the coding exercise."
   ```

4. **Hand off to Content Producer:**
   ```
   "Pass the lesson and assessment to the Content Producer. Create a 5-minute
   explainer video storyboard and 2 H5P interactive activities."
   ```

5. **Hand off to LX Designer:**
   ```
   "Pass the complete Module 1 package to the LX Designer. Design the learner
   journey with a progress checkpoint and a badge for completion."
   ```

6. **Hand off to Accessibility Auditor:**
   ```
   "Pass all Module 1 content to the Accessibility Auditor. Audit for WCAG
   2.1 AA compliance and provide remediation guidance for any issues."
   ```

### 4.4 Common Pitfalls and How to Avoid Them

| Pitfall | Impact | Prevention |
|---------|--------|------------|
| Vague objectives | Content misalignment | Use `learning-objective-validator` before proceeding |
| Skipping accessibility | Excluded learners | Run `wcag-compliance-checker` at every stage |
| Inconsistent tone | Confusing content | Use `tone-consistency-checker` across all lessons |
| Unaligned assessments | Invalid measurement | Use `assessment-validator` to check alignment |
| Over-long videos | Learner disengagement | Keep videos under 6 minutes; use `microlearning-architect` |
| Extrinsic gamification | Short-term motivation | Use `gamification-designer` with intrinsic motivation focus |

---

## 5. Advanced Usage

### 5.1 Customizing Mode Behavior

Each mode can be customized by providing additional context in your prompts:

```
"As Curriculum Designer, prioritize project-based learning over direct instruction.
Design objectives that emphasize creation and evaluation levels of Bloom's Taxonomy."
```

```
"As Instructional Writer, use a Socratic questioning approach. Include reflection
prompts after each major concept."
```

### 5.2 Combining Skills

You can invoke multiple skills in sequence for comprehensive analysis:

```
"First, use readability-analyzer to check this lesson's reading level.
Then, use tone-consistency-checker to ensure it matches our style guide.
Finally, use explanation-quality-checker to evaluate the explanations."
```

### 5.3 Iterative Refinement

Modes support iterative refinement. After receiving output, you can ask for changes:

```
"The objectives are good, but make them more specific to the NGSS performance expectations.
Add two more objectives at the 'Create' level of Bloom's Taxonomy."
```

```
"The lesson is too technical. Simplify the language to grade 8 reading level
and add more concrete examples."
```

### 5.4 Quality Checks

Before finalizing any content, run these quality checks:

| Check | Skill | When to Use |
|-------|-------|-------------|
| Objective quality | `learning-objective-validator` | After curriculum design |
| Readability | `readability-analyzer` | After lesson writing |
| Assessment alignment | `assessment-validator` | After assessment creation |
| Bias review | `bias-detector` | Before publishing assessments |
| WCAG compliance | `wcag-compliance-checker` | Before publishing any content |
| Storyboard alignment | `storyboard-validator` | Before video production |

---

## 6. Frequently Asked Questions

### Q: Can I use multiple modes in one session?
**A:** Yes. You can switch between modes as needed. The modes are designed to hand off work to each other, so you can start in one mode and continue in another.

### Q: How do I know which mode to use?
**A:** Refer to the mode table in Section 1.2. If you're unsure, start with Curriculum Designer—it's the foundation for all other work.

### Q: Can I customize the skills?
**A:** Skills are designed to be self-contained. If you need to modify a skill's behavior, refer to the Support Team Guide for instructions on extending skills.

### Q: What if the output doesn't meet my needs?
**A:** Provide specific feedback and ask for revisions. Modes support iterative refinement. For example: "The objectives are too broad. Make them more specific and measurable."

### Q: How do I ensure consistency across a large project?
**A:** Use the `tone-consistency-checker` skill across all written content, and run the `standards-compliance-checker` on the full curriculum. The Accessibility Auditor can also ensure consistency across all published content.

### Q: Can I use these modes for non-educational content?
**A:** While designed for educational content, many skills (like `readability-analyzer`, `tone-consistency-checker`, and `wcag-compliance-checker`) are applicable to any content creation.

---

## 7. Quick Reference

### Mode Selection Guide

| If you need to... | Use this mode | Key skill |
|-------------------|---------------|-----------|
| Define what students should learn | Curriculum Designer | `learning-objective-validator` |
| Write lesson content | Instructional Writer | `explanation-quality-checker` |
| Create a quiz or test | Assessment Developer | `assessment-validator` |
| Produce a video | Content Producer | `storyboard-validator` |
| Design a learning path | LX Designer | `journey-mapper` |
| Check accessibility | Accessibility Auditor | `wcag-compliance-checker` |
| Check reading level | Instructional Writer | `readability-analyzer` |
| Create a rubric | Assessment Developer | `rubric-generator` |
| Package for LMS | Content Producer | `scorm-packager` |
| Add gamification | LX Designer | `gamification-designer` |

### Bloom's Taxonomy Quick Reference

| Level | Key Verbs | Example |
|-------|-----------|---------|
| Remember | list, define, identify, recall | "List the parts of a cell" |
| Understand | explain, describe, summarize | "Explain how photosynthesis works" |
| Apply | use, solve, demonstrate | "Use the formula to solve the problem" |
| Analyze | compare, contrast, differentiate | "Compare mitosis and meiosis" |
| Evaluate | judge, critique, justify | "Justify your answer with evidence" |
| Create | design, construct, produce | "Design an experiment to test..." |

### WCAG 2.1 Quick Reference

| Principle | What it means | Key check |
|-----------|---------------|-----------|
| Perceivable | Users can perceive content | Alt text, captions, color contrast |
| Operable | Users can interact with content | Keyboard navigation, no time limits |
| Understandable | Users can understand content | Clear language, consistent navigation |
| Robust | Content works with assistive tech | Valid HTML, ARIA labels |

---

## 8. Further Resources

- **Support Team Guide:** See `docs/support-team-guide.md` for installation and extension instructions
- **Development Plan:** See `docs/plan.md` for the project roadmap
- **Requirements Specification:** See `docs/srs.md` for detailed requirements
- **Agent Configuration:** See `AGENTS.md` for agent behavior guidelines

---

## 9. Glossary

| Term | Definition |
|------|------------|
| **Bloom's Taxonomy** | A framework for classifying learning objectives by cognitive level (Remember, Understand, Apply, Analyze, Evaluate, Create) |
| **Mode** | A specialized configuration of Roo Code for a specific role |
| **Skill** | A reusable capability that modes can invoke |
| **WCAG** | Web Content Accessibility Guidelines—international standards for web accessibility |
| **SCORM** | Sharable Content Object Reference Model—a standard for packaging e-learning content |
| **xAPI** | Experience API (Tin Can API)—a specification for tracking learning experiences |
| **NGSS** | Next Generation Science Standards—US science education standards |
| **CSTA** | Computer Science Teachers Association—computing education standards |
| **H5P** | HTML5 Package—a standard for creating interactive web content |
| **Microlearning** | Breaking content into small units (5-15 minutes) for better retention |