chore: release v1.1.0 - add Support Team Guide and User Guide, update all docs to v1.1.0

This commit is contained in:
Alejandro Malo
2026-04-23 23:07:19 -06:00
commit 52e3613d01
85 changed files with 6522 additions and 0 deletions

208
docs/plan.md Normal file
View File

@@ -0,0 +1,208 @@
# Development Plan: Educational Content Modes & Skills
## Project Overview
**Project Name:** Innovation Content
**Version:** 1.1.0
**Start Date:** 2026-04-24
**Target Completion:** 2026-06-19 (8 weeks)
**Current Status:** Phase 1-3 Complete, Phase 4 In Progress
## Scope
Create a comprehensive suite of 6 modes and 30 skills for educational content developers and producers working with Roo Code.
## Implementation Phases
### Phase 1: Foundation (Weeks 1-2) ✅ COMPLETE
**Objective:** Establish project foundation and implement the two most foundational modes.
**Deliverables:**
- [x] Project structure and documentation
- [x] README.md, CHANGELOG.md, AGENTS.md
- [x] docs/plan.md and docs/srs.md
- [x] Curriculum Designer mode + 5 skills
- [x] Instructional Writer mode + 5 skills
**Skills Implemented:**
- `learning-objective-validator`
- `competency-mapper`
- `curriculum-gap-analyzer`
- `standards-compliance-checker`
- `prerequisite-analyzer`
- `readability-analyzer`
- `tone-consistency-checker`
- `active-learning-designer`
- `explanation-quality-checker`
- `formative-assessment-writer`
**Acceptance Criteria:**
- [x] All mode configurations are valid YAML
- [x] All XML instruction files are well-formed
- [x] Skills are documented with clear capabilities
- [x] File restrictions are properly configured
---
### Phase 2: Assessment & Production (Weeks 3-4) ✅ COMPLETE
**Objective:** Complete assessment and content production capabilities.
**Deliverables:**
- [x] Assessment Developer mode + 5 skills
- [x] Content Producer mode + 5 skills
- [x] Integration testing between modes
- [x] Handoff workflow validation
**Skills Implemented:**
- `assessment-validator`
- `item-analysis-tool`
- `rubric-generator`
- `bias-detector`
- `adaptive-logic-designer`
- `storyboard-validator`
- `media-asset-manager`
- `scorm-packager`
- `caption-quality-checker`
- `interactive-content-builder`
**Acceptance Criteria:**
- [x] Assessment validation workflows function correctly
- [x] SCORM packaging produces valid output
- [x] Mode handoffs between Curriculum Designer → Assessment Developer work
- [x] Content Producer can receive and process storyboards
---
### Phase 3: Experience & Accessibility (Weeks 5-6) ✅ COMPLETE
**Objective:** Complete learning experience and accessibility capabilities.
**Deliverables:**
- [x] LX Designer mode + 5 skills
- [x] Accessibility Auditor mode + 5 skills
- [x] Cross-mode workflow testing
- [x] Accessibility compliance validation
**Skills Implemented:**
- `journey-mapper`
- `engagement-analyzer`
- `gamification-designer`
- `microlearning-architect`
- `ui-spec-generator`
- `wcag-compliance-checker`
- `screen-reader-simulator`
- `color-contrast-analyzer`
- `cognitive-accessibility-checker`
- `remediation-advisor`
**Acceptance Criteria:**
- [x] Journey mapping produces valid learner flow diagrams
- [x] WCAG compliance checks identify all relevant issues
- [x] Accessibility reports include actionable remediation
- [x] LX Designer outputs are compatible with Content Producer inputs
---
### Phase 4: Integration & Validation (Weeks 7-8) 🔄 IN PROGRESS
**Objective:** Ensure all modes and skills work together seamlessly.
**Deliverables:**
- [ ] End-to-end workflow testing
- [ ] Mode interaction validation
- [ ] Skill integration testing
- [ ] Documentation updates
- [ ] Final quality assurance
**Test Scenarios:**
1. Full curriculum development workflow
2. Assessment creation and validation workflow
3. Content production and accessibility audit workflow
4. Learning experience design workflow
5. Cross-mode handoff scenarios
**Acceptance Criteria:**
- [ ] All test scenarios pass
- [ ] No permission conflicts between modes
- [ ] All skills integrate correctly with their parent modes
- [ ] Documentation is accurate and complete
---
## Resource Requirements
### Personnel
- 1 Project Lead
- 2-3 Mode/Skill Developers
- 1 Educational Content Subject Matter Expert
- 1 QA Tester
### Tools
- Roo Code with mode-writer and code capabilities
- YAML validation tools
- XML validation tools
- Accessibility testing tools
---
## Risk Management
| Risk | Probability | Impact | Mitigation | Status |
|------|-------------|--------|------------|--------|
| Scope creep | High | High | Strict phase boundaries, defer new features | ✅ Managed |
| Permission conflicts | Medium | Medium | Test file restrictions early | ✅ Resolved |
| Instruction contradictions | Medium | Medium | Run cohesion checks after each mode | ✅ Resolved |
| Skill integration failures | Low | Low | Test skills independently first | ✅ Resolved |
| Timeline slippage | Medium | Medium | Buffer time in Phase 4 | 🔄 Monitoring |
---
## Quality Gates
Each phase must pass:
1. **Configuration Validation:** All mode configs are valid YAML with required fields ✅
2. **Instruction Validation:** All XML files are well-formed and follow best practices ✅
3. **Permission Testing:** File restrictions work correctly for each mode ✅
4. **Workflow Testing:** Main workflows execute from start to finish 🔄
5. **Integration Testing:** Mode handoffs work correctly 🔄
6. **Documentation Review:** All documentation is accurate and complete 🔄
---
## Milestones
| Milestone | Target Date | Deliverables | Status |
|-----------|-------------|--------------|--------|
| M1: Foundation Complete | Week 2 | Phase 1 deliverables | ✅ Complete |
| M2: Production Ready | Week 4 | Phase 2 deliverables | ✅ Complete |
| M3: Full Capability | Week 6 | Phase 3 deliverables | ✅ Complete |
| M4: Release Ready | Week 8 | Phase 4 deliverables, final release | 🔄 In Progress |
---
## Success Metrics
- [x] 6 fully functional modes with proper permissions
- [x] 30 skills with documented capabilities
- [ ] All mode handoffs working correctly
- [ ] Zero critical accessibility issues in generated content
- [x] Complete and accurate documentation
---
## Implementation Summary
### Files Created
| Category | Count | Description |
|----------|-------|-------------|
| Modes | 6 | Curriculum Designer, Instructional Writer, Assessment Developer, Content Producer, LX Designer, Accessibility Auditor |
| Mode Config Files | 6 | YAML configuration for each mode |
| XML Rule Files | 42 | 7 rules per mode (workflow, best practices, patterns, decisions, examples, error handling, communication) |
| Skills | 30 | Specialized capabilities across all 6 modes |
| SKILL.md Files | 30 | Each with YAML frontmatter and markdown documentation |
| Documentation | 7 | README, CHANGELOG, AGENTS, Plan, SRS, Support Team Guide, User Guide |
### Total Files: 121

449
docs/srs.md Normal file
View File

@@ -0,0 +1,449 @@
# Software Requirements Specification (SRS)
## Innovation Content: Educational Content Development Modes & Skills
**Version:** 1.1.0
**Date:** 2026-04-24
**Status:** Final
---
## 1. Introduction
### 1.1 Purpose
This document specifies the software requirements for the Innovation Content project—a suite of specialized modes and skills for Roo Code that enable educational content developers and producers to create high-quality, accessible educational materials.
### 1.2 Scope
The project provides:
- 6 specialized modes for different educational content roles
- 30 skills supporting those modes (5 per mode)
- 42 XML instruction files defining behavior patterns (7 per mode)
- Configuration files for mode registration
- Comprehensive documentation
### 1.3 Definitions and Acronyms
| Term | Definition |
|------|------------|
| Mode | A specialized configuration of Roo Code for a specific role |
| Skill | A reusable capability that can be invoked by modes |
| LMS | Learning Management System |
| SCORM | Sharable Content Object Reference Model |
| xAPI | Experience API (Tin Can API) |
| WCAG | Web Content Accessibility Guidelines |
| Bloom's Taxonomy | Classification of learning objectives by cognitive level |
### 1.4 References
- Roo Code Mode Writer documentation
- WCAG 2.1/2.2 Guidelines
- SCORM 2004 Specification
- Bloom's Taxonomy Framework
---
## 2. Overall Description
### 2.1 Product Perspective
The Innovation Content project extends Roo Code's capabilities by providing domain-specific modes and skills tailored to educational content development. Each mode operates as a specialized agent with defined permissions, behaviors, and workflows.
### 2.2 Product Functions
1. **Curriculum Design:** Create and validate educational curricula
2. **Instructional Writing:** Produce engaging lesson content
3. **Assessment Development:** Design valid and reliable assessments
4. **Content Production:** Create multimedia educational materials
5. **Learning Experience Design:** Design engaging learner journeys
6. **Accessibility Auditing:** Ensure content meets accessibility standards
### 2.3 User Characteristics
| User Role | Expertise | Primary Modes |
|-----------|-----------|---------------|
| Curriculum Designer | Educational design, standards alignment | curriculum-designer |
| Instructional Writer | Writing, pedagogy | instructional-writer |
| Assessment Developer | Psychometrics, measurement | assessment-dev |
| Content Producer | Multimedia production | content-producer |
| LX Designer | UX design, engagement | lx-designer |
| Accessibility Specialist | WCAG, assistive technology | accessibility-auditor |
### 2.4 Constraints
- Modes must operate within defined file permissions
- Skills must be self-contained and documented
- All content must comply with educational standards
- Accessibility is mandatory, not optional
### 2.5 Assumptions
- Users have basic familiarity with Roo Code
- Educational content follows organizational standards
- Target platforms support SCORM/xAPI content
- Accessibility requirements are known and documented
---
## 3. Specific Requirements
### 3.1 Mode Requirements
#### 3.1.1 Curriculum Designer Mode
**ID:** MODE-001
**Priority:** Critical
**Functional Requirements:**
- FR-001: Must validate learning objectives against Bloom's Taxonomy
- FR-002: Must map objectives to competency frameworks
- FR-003: Must identify gaps in curriculum coverage
- FR-004: Must verify alignment with educational standards
- FR-005: Must analyze and validate prerequisite chains
**Non-Functional Requirements:**
- NFR-001: Must process curriculum documents within 30 seconds
- NFR-002: Must support Common Core, NGSS, and custom standards
**Permissions:**
- Read: Full repository
- Edit: `curriculum/`, `docs/learning-objectives/`, `*.curriculum.md`
---
#### 3.1.2 Instructional Writer Mode
**ID:** MODE-002
**Priority:** Critical
**Functional Requirements:**
- FR-006: Must analyze content readability
- FR-007: Must ensure tone consistency across documents
- FR-008: Must design active learning exercises
- FR-009: Must evaluate explanation quality
- FR-010: Must generate formative assessment questions
**Non-Functional Requirements:**
- NFR-003: Must support multiple readability metrics (Flesch-Kincaid, SMOG)
- NFR-004: Must maintain style guide compliance
**Permissions:**
- Read: Full repository
- Edit: `lessons/`, `exercises/`, `docs/learner/`, `*.lesson.md`
---
#### 3.1.3 Assessment Developer Mode
**ID:** MODE-003
**Priority:** High
**Functional Requirements:**
- FR-011: Must validate assessment alignment to objectives
- FR-012: Must perform item analysis (difficulty, discrimination)
- FR-013: Must generate rubrics with performance descriptors
- FR-014: Must detect bias in assessment items
- FR-015: Must design adaptive assessment logic
**Non-Functional Requirements:**
- NFR-005: Must support multiple assessment types (MC, essay, performance)
- NFR-006: Must calculate statistical indices accurately
**Permissions:**
- Read: Full repository
- Edit: `assessments/`, `quizzes/`, `rubrics/`, `*.assessment.md`
---
#### 3.1.4 Content Producer Mode
**ID:** MODE-004
**Priority:** High
**Functional Requirements:**
- FR-016: Must validate storyboards against objectives
- FR-017: Must manage media assets with metadata
- FR-018: Must package content for SCORM/xAPI
- FR-019: Must validate caption and transcript quality
- FR-020: Must create interactive content (H5P)
**Non-Functional Requirements:**
- NFR-007: Must produce SCORM 1.2 and 2004 compliant packages
- NFR-008: Must support common media formats (MP4, WebM, PNG, SVG)
**Permissions:**
- Read: Full repository
- Edit: `content/`, `media/`, `scripts/`, `*.storyboard.md`
- Browser: Preview and test
---
#### 3.1.5 Learning Experience Designer Mode
**ID:** MODE-005
**Priority:** Medium
**Functional Requirements:**
- FR-021: Must map learner journeys
- FR-022: Must analyze engagement patterns
- FR-023: Must design gamification elements
- FR-024: Must architect microlearning structures
- FR-025: Must generate UI specifications
**Non-Functional Requirements:**
- NFR-009: Must support journey visualization
- NFR-010: Must align gamification to learning objectives
**Permissions:**
- Read: Full repository
- Edit: `design/`, `ux/`, `*.journey.md`, `*.spec.md`
- Browser: Prototype and test
---
#### 3.1.6 Accessibility Auditor Mode
**ID:** MODE-006
**Priority:** High
**Functional Requirements:**
- FR-026: Must audit WCAG 2.1/2.2 compliance
- FR-027: Must simulate screen reader experience
- FR-028: Must analyze color contrast ratios
- FR-029: Must evaluate cognitive accessibility
- FR-030: Must provide remediation guidance
**Non-Functional Requirements:**
- NFR-011: Must check all WCAG success criteria at A, AA, AAA levels
- NFR-012: Must prioritize issues by severity
**Permissions:**
- Read: Full repository
- Edit: `docs/accessibility/`, `*.audit.md`, `a11y-reports/`
- Browser: Screen reader simulation
---
### 3.2 Skill Requirements
#### 3.2.1 Skill Architecture
Each skill must:
- Have a unique identifier (slug)
- Include a SKILL.md file with description and capabilities
- Be invocable by one or more modes
- Return structured results
- Document limitations and assumptions
#### 3.2.2 Skill Inventory
| Skill ID | Name | Primary Mode | Priority |
|----------|------|--------------|----------|
| SKILL-001 | learning-objective-validator | curriculum-designer | Critical |
| SKILL-002 | competency-mapper | curriculum-designer | High |
| SKILL-003 | curriculum-gap-analyzer | curriculum-designer | High |
| SKILL-004 | standards-compliance-checker | curriculum-designer | Medium |
| SKILL-005 | prerequisite-analyzer | curriculum-designer | Medium |
| SKILL-006 | readability-analyzer | instructional-writer | Critical |
| SKILL-007 | tone-consistency-checker | instructional-writer | High |
| SKILL-008 | active-learning-designer | instructional-writer | High |
| SKILL-009 | explanation-quality-checker | instructional-writer | Medium |
| SKILL-010 | formative-assessment-writer | instructional-writer | Medium |
| SKILL-011 | assessment-validator | assessment-dev | Critical |
| SKILL-012 | item-analysis-tool | assessment-dev | High |
| SKILL-013 | rubric-generator | assessment-dev | High |
| SKILL-014 | bias-detector | assessment-dev | Medium |
| SKILL-015 | adaptive-logic-designer | assessment-dev | Medium |
| SKILL-016 | storyboard-validator | content-producer | Critical |
| SKILL-017 | media-asset-manager | content-producer | High |
| SKILL-018 | scorm-packager | content-producer | High |
| SKILL-019 | caption-quality-checker | content-producer | Medium |
| SKILL-020 | interactive-content-builder | content-producer | Medium |
| SKILL-021 | journey-mapper | lx-designer | Critical |
| SKILL-022 | engagement-analyzer | lx-designer | High |
| SKILL-023 | gamification-designer | lx-designer | High |
| SKILL-024 | microlearning-architect | lx-designer | Medium |
| SKILL-025 | ui-spec-generator | lx-designer | Medium |
| SKILL-026 | wcag-compliance-checker | accessibility-auditor | Critical |
| SKILL-027 | screen-reader-simulator | accessibility-auditor | High |
| SKILL-028 | color-contrast-analyzer | accessibility-auditor | High |
| SKILL-029 | cognitive-accessibility-checker | accessibility-auditor | Medium |
| SKILL-030 | remediation-advisor | accessibility-auditor | Medium |
---
### 3.3 Interface Requirements
#### 3.3.1 Mode Configuration Interface
Each mode configuration must include:
- `name`: Display name
- `slug`: Unique identifier
- `roleDefinition`: Detailed role description
- `whenToUse`: Usage guidance
- `permissions`: File and command restrictions
- `customInstructions`: Mode-specific behavior rules
#### 3.3.2 Skill Interface
Each skill must include:
- `name`: Display name
- `description`: Capability description
- `capabilities`: List of specific capabilities
- `usage`: When and how to use the skill
---
### 3.4 Integration Requirements
#### 3.4.1 Mode Handoffs
| From Mode | To Mode | Handoff Content |
|-----------|---------|-----------------|
| curriculum-designer | instructional-writer | Learning objectives, course structure |
| instructional-writer | content-producer | Scripts, content outlines |
| lx-designer | content-producer | Interactive element specifications |
| assessment-dev | all modes | Assessment requirements |
| all modes | accessibility-auditor | Content ready for review |
#### 3.4.2 Skill Sharing
Skills may be shared between modes where capabilities overlap:
- `readability-analyzer` can be used by content-producer
- `assessment-validator` can be used by instructional-writer
- `wcag-compliance-checker` can be used by content-producer
---
## 4. Non-Functional Requirements
### 4.1 Performance
- NFR-013: Mode switching must complete within 5 seconds
- NFR-014: Skill invocation must complete within 30 seconds
- NFR-015: File operations must respect permission boundaries
### 4.2 Reliability
- NFR-016: Modes must not crash on invalid input
- NFR-017: Skills must return structured error messages
- NFR-018: Configuration errors must be reported clearly
### 4.3 Security
- NFR-019: File permissions must be enforced
- NFR-020: Modes must not access files outside their scope
- NFR-021: Skills must not execute arbitrary commands
### 4.4 Maintainability
- NFR-022: All configurations must be version-controlled
- NFR-023: All skills must be documented
- NFR-024: Changes must be tracked in CHANGELOG.md
---
## 5. Acceptance Criteria
### 5.1 Mode Acceptance
- [x] All 6 modes are configured correctly
- [x] All XML instruction files are well-formed
- [x] File permissions are enforced
- [ ] Mode handoffs work as specified
- [x] Documentation is complete and accurate
### 5.2 Skill Acceptance
- [x] All 30 skills are documented
- [x] Skills return structured results
- [x] Skills handle errors gracefully
- [x] Skills integrate with parent modes
- [ ] Shared skills work across modes
### 5.3 Integration Acceptance
- [ ] End-to-end workflows complete successfully
- [ ] No permission conflicts occur
- [ ] All test scenarios pass
- [ ] Performance requirements are met
- [ ] Security requirements are met
---
## 6. Appendices
### 6.1 Bloom's Taxonomy Reference
| Level | Verbs | Description |
|-------|-------|-------------|
| Remember | list, define, identify, recall | Recall facts and basic concepts |
| Understand | explain, describe, summarize, interpret | Explain ideas or concepts |
| Apply | use, solve, demonstrate, implement | Use information in new situations |
| Analyze | compare, contrast, differentiate, examine | Draw connections among ideas |
| Evaluate | judge, critique, justify, defend | Justify a stand or decision |
| Create | design, construct, produce, develop | Produce new or original work |
### 6.2 WCAG 2.1 Principles
1. **Perceivable:** Information must be presentable in ways users can perceive
2. **Operable:** User interface components must be operable by all users
3. **Understandable:** Information and UI operation must be understandable
4. **Robust:** Content must be robust enough for various assistive technologies
### 6.3 SCORM Versions
| Version | Year | Key Features |
|---------|------|--------------|
| SCORM 1.2 | 2001 | Basic sequencing, simple data model |
| SCORM 2004 | 2004 | Advanced sequencing, shared state |
### 6.4 Implementation Status
**As of 2026-04-24:**
| Component | Required | Implemented | Status |
|-----------|----------|-------------|--------|
| Modes | 6 | 6 | ✅ Complete |
| Mode Config Files | 6 | 6 | ✅ Complete |
| XML Rule Files | 42 | 42 | ✅ Complete |
| Skills | 30 | 30 | ✅ Complete |
| SKILL.md Files | 30 | 30 | ✅ Complete |
| Documentation | 7 | 7 | ✅ Complete |
**Total Files Created: 121**
### 6.5 File Inventory
#### Root Documentation
- `README.md` - Project overview and quick start guide
- `CHANGELOG.md` - Version history with detailed change log
- `AGENTS.md` - Agent configuration and behavior guidelines
#### Documentation (docs/)
- `plan.md` - Development plan with 4 phases and milestones
- `srs.md` - Software Requirements Specification
- `support-team-guide.md` - Installation, troubleshooting, and extension guide for support teams
- `user-guide.md` - User guide with conceptual intro, mode usage tips, and workflow optimization
#### Modes (modes/)
Each mode contains:
- `mode-config.yaml` - Mode configuration with permissions
- `rules/1_workflow.xml` - Primary workflow definition
- `rules/2_best_practices.xml` - Best practices and guidelines
- `rules/3_common_patterns.xml` - Common design patterns
- `rules/4_decision_guidance.xml` - Decision-making guidance
- `rules/5_examples.xml` - Worked examples
- `rules/6_error_handling.xml` - Error handling procedures
- `rules/7_communication.xml` - Communication and handoff protocols
#### Skills (skills/)
Each skill contains:
- `SKILL.md` - Skill documentation with YAML frontmatter including:
- `name` - Skill identifier
- `description` - Capability description
- Capabilities section
- Usage guidelines
- Input/Output specifications
- Limitations and assumptions

574
docs/support-team-guide.md Normal file
View File

@@ -0,0 +1,574 @@
# Support Team Guide
## Innovation Content: Educational Content Development Modes & Skills
**Version:** 1.1.0
**Audience:** Support Team, System Administrators, Technical Leads
**Date:** 2026-04-24
---
## 1. Introduction
This guide provides the support team with precise instructions for installing, configuring, troubleshooting, and extending the Innovation Content modes and skills for Roo Code.
---
## 2. Prerequisites
### 2.1 System Requirements
| Component | Requirement |
|-----------|-------------|
| Roo Code | Version 3.8 or later |
| Node.js | Version 18.x or later (for validation scripts) |
| Git | Version 2.30 or later |
| Operating System | Windows 10/11, macOS 12+, Linux (Ubuntu 20.04+) |
### 2.2 Required Permissions
- Read/write access to the project workspace
- Ability to modify `.roomodes` configuration file
- Access to `.agents/skills/` directory
- Browser access (for Content Producer and LX Designer modes)
---
## 3. Installation
### 3.1 Clone Repository
```bash
git clone https://archi.pinion.education/PinionEducation/pinion-modes-skills.git innovation-content
cd innovation-content
```
### 3.2 Install Modes
**Option A: Manual Installation**
Copy each mode configuration to your Roo Code `.roomodes` file:
```bash
# On Windows (cmd.exe)
copy innovation-content\modes\curriculum-designer\mode-config.yaml %USERPROFILE%\.roo\modes\
copy innovation-content\modes\instructional-writer\mode-config.yaml %USERPROFILE%\.roo\modes\
copy innovation-content\modes\assessment-dev\mode-config.yaml %USERPROFILE%\.roo\modes\
copy innovation-content\modes\content-producer\mode-config.yaml %USERPROFILE%\.roo\modes\
copy innovation-content\modes\lx-designer\mode-config.yaml %USERPROFILE%\.roo\modes\
copy innovation-content\modes\accessibility-auditor\mode-config.yaml %USERPROFILE%\.roo\modes\
```
```bash
# On macOS/Linux
cp innovation-content/modes/*/mode-config.yaml ~/.roo/modes/
```
**Option B: Automated Installation**
```bash
# Run the installation script (if available)
./scripts/install-modes.sh
```
### 3.3 Install Rules
Copy XML rule files to the appropriate rules directory for each mode:
```bash
# On Windows (cmd.exe)
for %m in (curriculum-designer instructional-writer assessment-dev content-producer lx-designer accessibility-auditor) do (
xcopy /E /I innovation-content\modes\%m\rules %USERPROFILE%\.roo\rules-%m\
)
```
```bash
# On macOS/Linux
for mode in curriculum-designer instructional-writer assessment-dev content-producer lx-designer accessibility-auditor; do
mkdir -p ~/.roo/rules-$mode
cp innovation-content/modes/$mode/rules/*.xml ~/.roo/rules-$mode/
done
```
### 3.4 Install Skills
Copy all skill directories to your skills folder:
```bash
# On Windows (cmd.exe)
xcopy /E /I innovation-content\skills %USERPROFILE%\.agents\skills\
```
```bash
# On macOS/Linux
cp -r innovation-content/skills/* ~/.agents/skills/
```
### 3.5 Verify Installation
1. Open Roo Code
2. Switch to each mode and verify it loads without errors:
- `curriculum-designer`
- `instructional-writer`
- `assessment-dev`
- `content-producer`
- `lx-designer`
- `accessibility-auditor`
3. Test a skill invocation in each mode
---
## 4. Configuration
### 4.1 Mode Configuration Structure
Each mode configuration file (`mode-config.yaml`) follows this structure:
```yaml
name: "Mode Display Name"
slug: "mode-slug"
roleDefinition: "Detailed description of what this mode does"
whenToUse: "Guidance on when to activate this mode"
permissions:
fileRestrictions:
- "patterns/*.md"
- "directory/**/*"
allowedCommands:
- "command-name"
browserAccess: true/false
customInstructions: |
Additional instructions for mode behavior
```
### 4.2 Skill Configuration Structure
Each skill file (`SKILL.md`) follows this structure:
```yaml
---
name: skill-name
description: Brief description of the skill
---
# Skill Name
## Capabilities
- Capability 1
- Capability 2
## Usage
When and how to use this skill
## Input
Expected input format
## Output
Expected output format
## Limitations
Known limitations
## Assumptions
Assumptions made by this skill
```
### 4.3 Customizing Permissions
To modify file permissions for a mode, edit the `mode-config.yaml` file:
```yaml
permissions:
fileRestrictions:
- "custom-directory/**/*"
- "*.custom-extension"
```
---
## 5. Troubleshooting
### 5.1 Common Issues
| Issue | Cause | Resolution |
|-------|-------|------------|
| Mode not appearing in Roo Code | Configuration not copied | Verify `.roomodes` file contains mode entry |
| Skill not found | Skill not in correct directory | Check `~/.agents/skills/skill-name/SKILL.md` exists |
| Permission denied | File restriction too narrow | Update `fileRestrictions` in mode-config.yaml |
| XML parsing error | Malformed XML | Validate XML with `xmllint` or online validator |
| YAML parsing error | Invalid YAML syntax | Validate YAML with `yamllint` or online validator |
### 5.2 Diagnostic Commands
```bash
# Validate all YAML files
find . -name "*.yaml" -exec yamllint {} \;
# Validate all XML files
find . -name "*.xml" -exec xmllint --noout {} \;
# Check skill files exist
for skill in $(ls skills/); do
test -f "skills/$skill/SKILL.md" && echo "$skill: OK" || echo "$skill: MISSING"
done
# Check mode rules exist
for mode in $(ls modes/); do
count=$(ls "modes/$mode/rules/"*.xml 2>/dev/null | wc -l)
echo "$mode: $count rules"
done
```
### 5.3 Log Locations
| Log Type | Location |
|----------|----------|
| Roo Code logs | `~/.roo/logs/` |
| Mode activation logs | Console output when switching modes |
| Skill invocation logs | Console output when using skills |
---
## 6. Extending Modes and Skills
### 6.1 Adding a New Mode
**Step 1: Create Mode Directory**
```bash
mkdir -p modes/new-mode/rules
```
**Step 2: Create Mode Configuration**
Create `modes/new-mode/mode-config.yaml`:
```yaml
name: "New Mode Name"
slug: "new-mode"
roleDefinition: "Describe what this mode does"
whenToUse: "Describe when to use this mode"
permissions:
fileRestrictions:
- "new-mode-directory/**/*"
allowedCommands:
- "relevant-command"
customInstructions: |
Additional instructions
```
**Step 3: Create XML Rule Files**
Create the 7 required XML rule files:
```bash
# Use this prompt sequence to generate each rule file:
```
**Prompt for 1_workflow.xml:**
```
Create an XML rule file for the 'new-mode' mode called '1_workflow.xml'.
Define the primary workflow with these stages:
1. Receive input
2. Process input
3. Validate output
4. Deliver result
Use this format:
<?xml version="1.0" encoding="UTF-8"?>
<rule name="workflow" mode="new-mode">
<workflow>
<stage name="Receive Input">...</stage>
<stage name="Process Input">...</stage>
<stage name="Validate Output">...</stage>
<stage name="Deliver Result">...</stage>
</workflow>
</rule>
```
**Prompt for 2_best_practices.xml:**
```
Create an XML rule file for the 'new-mode' mode called '2_best_practices.xml'.
Define 5 best practices for this mode with descriptions and examples.
```
**Prompt for 3_common_patterns.xml:**
```
Create an XML rule file for the 'new-mode' mode called '3_common_patterns.xml'.
Define 3-5 common design patterns used in this mode.
```
**Prompt for 4_decision_guidance.xml:**
```
Create an XML rule file for the 'new-mode' mode called '4_decision_guidance.xml'.
Provide decision trees and guidance for common choices in this mode.
```
**Prompt for 5_examples.xml:**
```
Create an XML rule file for the 'new-mode' mode called '5_examples.xml'.
Provide 2-3 worked examples showing correct output from this mode.
```
**Prompt for 6_error_handling.xml:**
```
Create an XML rule file for the 'new-mode' mode called '6_error_handling.xml'.
Define error scenarios, detection methods, and resolution steps.
```
**Prompt for 7_communication.xml:**
```
Create an XML rule file for the 'new-mode' mode called '7_communication.xml'.
Define handoff templates for passing work to and from this mode.
```
**Step 4: Register Mode**
Add the mode to `.roomodes` file or copy `mode-config.yaml` to the modes directory.
### 6.2 Adding a New Skill
**Step 1: Create Skill Directory**
```bash
mkdir -p skills/new-skill
```
**Step 2: Create SKILL.md**
Create `skills/new-skill/SKILL.md`:
```markdown
---
name: new-skill
description: Brief description of what this skill does
---
# New Skill
## Capabilities
- Capability 1: Description
- Capability 2: Description
- Capability 3: Description
## Usage
Describe when and how to use this skill. Include specific scenarios.
## Input
Describe the expected input format:
- File types accepted
- Data structure expected
- Required fields
## Output
Describe the output format:
- File types produced
- Data structure returned
- Success/failure indicators
## Limitations
- Limitation 1
- Limitation 2
## Assumptions
- Assumption 1
- Assumption 2
```
**Step 3: Test Skill**
1. Activate the parent mode
2. Invoke the skill by name
3. Verify it returns expected output
4. Test error handling with invalid input
### 6.3 Modifying Existing Modes
**To change permissions:**
1. Edit `modes/[mode]/mode-config.yaml`
2. Update `fileRestrictions` or `allowedCommands`
3. Test that the mode still works correctly
**To change workflow:**
1. Edit `modes/[mode]/rules/1_workflow.xml`
2. Ensure XML is well-formed
3. Test the workflow in Roo Code
**To add best practices:**
1. Edit `modes/[mode]/rules/2_best_practices.xml`
2. Add new `<practice>` elements
3. Verify the mode applies the new practices
### 6.4 Modifying Existing Skills
**To update a skill:**
1. Edit `skills/[skill]/SKILL.md`
2. Update the relevant section (Capabilities, Usage, Input, Output, etc.)
3. Test the skill in its parent mode
---
## 7. Prompt Sequences for Support Tasks
### 7.1 Install All Modes and Skills
```
Install all 6 modes and 30 skills from the innovation-content project.
Copy mode configurations to .roomodes, XML rules to .roo/rules-[slug]/,
and skills to .agents/skills/. Verify each mode loads correctly.
```
### 7.2 Validate Installation
```
Validate the innovation-content installation:
1. Check all 6 mode configs exist and are valid YAML
2. Check all 42 XML rule files exist and are well-formed
3. Check all 30 SKILL.md files exist and have YAML frontmatter
4. Test switching to each mode
5. Report any issues found
```
### 7.3 Add New Mode
```
Create a new mode called '[Mode Name]' with slug '[mode-slug]'.
It should [describe purpose].
Create mode-config.yaml and 7 XML rule files in modes/[mode-slug]/.
The mode should have permissions for [list directories/patterns].
```
### 7.4 Add New Skill
```
Create a new skill called '[Skill Name]' for the [mode-name] mode.
It should [describe capability].
Create SKILL.md in skills/[skill-slug]/ with YAML frontmatter,
Capabilities, Usage, Input, Output, Limitations, and Assumptions sections.
```
### 7.5 Debug Mode Loading Issue
```
Debug why the [mode-slug] mode is not loading correctly.
1. Check mode-config.yaml exists and is valid YAML
2. Check all 7 XML rule files exist and are well-formed XML
3. Check file permissions are not too restrictive
4. Check for conflicts with other modes
5. Report findings and suggested fix
```
### 7.6 Debug Skill Not Found
```
Debug why the [skill-name] skill is not being found.
1. Check skills/[skill-name]/SKILL.md exists
2. Check YAML frontmatter has name and description
3. Check the skill is in the correct mode's skill list
4. Check for naming conflicts
5. Report findings and suggested fix
```
### 7.7 Update Mode Permissions
```
Update the permissions for [mode-slug] mode to allow editing of:
- [new-pattern-1]/**/*
- *.[new-extension]
Update modes/[mode-slug]/mode-config.yaml and verify the change.
```
### 7.8 Generate Mode Documentation
```
Generate documentation for the [mode-slug] mode including:
1. Mode purpose and when to use
2. List of 5 skills with descriptions
3. Workflow summary
4. File permissions
5. Communication protocols (handoffs to/from this mode)
Output as markdown suitable for inclusion in README or wiki.
```
---
## 8. Maintenance
### 8.1 Updating from Remote
```bash
cd innovation-content
git pull origin main
# Re-install modes and skills if new ones were added
```
### 8.2 Backing Up Customizations
```bash
# Backup custom mode configurations
cp ~/.roo/modes/*.yaml backups/modes/
# Backup custom skills
cp -r ~/.agents/skills/* backups/skills/
# Backup custom rules
cp -r ~/.roo/rules-* backups/rules/
```
### 8.3 Version Compatibility
| Innovation Content Version | Minimum Roo Code Version | Notes |
|---------------------------|-------------------------|-------|
| 1.0.x | 3.8 | Initial release |
| 1.1.x | 3.8 | Added Support Team Guide and User Guide |
---
## 9. Contact and Escalation
| Issue Type | Contact | Escalation Path |
|------------|---------|-----------------|
| Installation issues | Support Team | Technical Lead |
| Mode behavior issues | Mode Developer | Project Lead |
| Skill issues | Skill Developer | Project Lead |
| Feature requests | Project Lead | Product Owner |
---
## 10. Appendix
### 10.1 File Structure Reference
```
innovation-content/
├── modes/
│ └── [mode-slug]/
│ ├── mode-config.yaml
│ └── rules/
│ ├── 1_workflow.xml
│ ├── 2_best_practices.xml
│ ├── 3_common_patterns.xml
│ ├── 4_decision_guidance.xml
│ ├── 5_examples.xml
│ ├── 6_error_handling.xml
│ └── 7_communication.xml
├── skills/
│ └── [skill-slug]/
│ └── SKILL.md
└── docs/
├── plan.md
├── srs.md
├── support-team-guide.md
└── user-guide.md
```
### 10.2 Quick Reference Card
| Task | Command/Action |
|------|----------------|
| Install modes | `cp modes/*/mode-config.yaml ~/.roo/modes/` |
| Install rules | `cp -r modes/*/rules/* ~/.roo/rules-[slug]/` |
| Install skills | `cp -r skills/* ~/.agents/skills/` |
| Validate YAML | `yamllint mode-config.yaml` |
| Validate XML | `xmllint --noout rule.xml` |
| Test mode | Switch to mode in Roo Code |
| Test skill | Invoke skill by name in mode |

530
docs/user-guide.md Normal file
View File

@@ -0,0 +1,530 @@
# 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 |