Agent Skills Framework Extension

Educational Content Patterns Skill

When to Use This Skill

Use this skill when implementing educational content patterns patterns in your codebase.

How to Use This Skill

1. Review the patterns and examples below
2. Apply the relevant patterns to your implementation
3. Follow the best practices outlined in this skill

Multi-level educational content generation with pedagogical frameworks and learning science.

Core Capabilities

1. Multi-Level Content - Beginner to advanced progression
2. Learning Objectives - Clear, measurable outcomes
3. Pedagogical Patterns - Evidence-based teaching methods
4. Progressive Disclosure - Scaffolded learning
5. Assessments - Knowledge checks and exercises
6. Learning Paths - Structured curriculum design

Content Structure Template

Module Template:

# [Topic] - [Level] Level

## Learning Objectives
By the end of this module, learners will be able to:
- [ ] [Bloom's verb] [specific outcome] (remember/understand)
- [ ] [Bloom's verb] [specific outcome] (apply/analyze)
- [ ] [Bloom's verb] [specific outcome] (evaluate/create)

## Prerequisites
- [ ] [Prior knowledge required]
- [ ] [Completed modules]
- [ ] [Tools/environment needed]

## Estimated Time: [X] hours

---

## 1. Introduction (10% of time)
- Why this matters
- Real-world context
- What you'll build/achieve

## 2. Core Concepts (30% of time)
- Concept A with analogy
- Concept B with visual
- Concept C with example

## 3. Guided Practice (30% of time)
- Step-by-step walkthrough
- Code examples (if applicable)
- Common mistakes to avoid

## 4. Independent Practice (20% of time)
- Exercise 1: [Scaffolded - hints provided]
- Exercise 2: [Moderate - partial solution]
- Exercise 3: [Challenge - minimal guidance]

## 5. Assessment (10% of time)
- Knowledge check questions
- Self-evaluation rubric
- Links to next module

---

## Summary
- Key takeaway 1
- Key takeaway 2
- Key takeaway 3

## Additional Resources
- [Further reading]
- [Video explanation]
- [Practice exercises]

Bloom's Taxonomy Quick Reference:

Level	Verbs	Skill Level	Assessment Type
Remember	List, define, identify, recall	Beginner	Multiple choice
Understand	Explain, describe, summarize	Beginner	Short answer
Apply	Use, implement, solve, demonstrate	Intermediate	Coding exercises
Analyze	Compare, differentiate, examine	Intermediate	Case studies
Evaluate	Judge, critique, justify, assess	Advanced	Code review
Create	Design, construct, develop, produce	Advanced	Projects

Content Complexity by Level:

Level	Vocabulary	Examples	Exercises	Time/Module
Beginner	Plain language, no jargon	Visual analogies	Fill-in-blank, guided	30-60 min
Intermediate	Technical terms (defined)	Code snippets	Build feature	1-2 hours
Advanced	Domain terminology	Production code	Design system	2-4 hours
Expert	Research terminology	Research papers	Novel solution	4+ hours

Quick Decision: Content Type

What's the learning goal?
├── New concept introduction → Tutorial (beginner, guided)
├── Skill acquisition → Workshop (intermediate, hands-on)
├── Knowledge application → Project (advanced, open-ended)
├── Reference material → Documentation (all levels, searchable)
├── Quick refresher → Cheat sheet (condensed, visual)
└── Deep understanding → Course (multi-module, progressive)

Multi-Level Content Generator

# scripts/multi-level-content.py
from dataclasses import dataclass
from typing import List, Dict
from enum import Enum

class SkillLevel(Enum):
    BEGINNER = "beginner"
    INTERMEDIATE = "intermediate"
    ADVANCED = "advanced"
    EXPERT = "expert"

@dataclass
class LearningObjective:
    level: SkillLevel
    objective: str
    blooms_level: str  # remember, understand, apply, analyze, evaluate, create

@dataclass
class ContentModule:
    title: str
    level: SkillLevel
    objectives: List[LearningObjective]
    content: str
    examples: List[str]
    exercises: List[str]
    estimated_time: int  # minutes

class MultiLevelContentGenerator:
    """Generate content for multiple skill levels"""

    def generate(
        self,
        topic: str,
        levels: List[SkillLevel] = None
    ) -> Dict[SkillLevel, ContentModule]:
        """Generate content for all levels"""
        if levels is None:
            levels = [SkillLevel.BEGINNER, SkillLevel.INTERMEDIATE, SkillLevel.ADVANCED]

        modules = {}
        for level in levels:
            modules[level] = self._generate_for_level(topic, level)

        return modules

    def _generate_for_level(self, topic: str, level: SkillLevel) -> ContentModule:
        """Generate content for specific level"""
        objectives = self._create_objectives(topic, level)
        content = self._write_content(topic, level)
        examples = self._create_examples(topic, level)
        exercises = self._create_exercises(topic, level)

        return ContentModule(
            title=f"{topic} - {level.value.title()} Level",
            level=level,
            objectives=objectives,
            content=content,
            examples=examples,
            exercises=exercises,
            estimated_time=self._estimate_time(content, examples, exercises)
        )

    def _create_objectives(self, topic: str, level: SkillLevel) -> List[LearningObjective]:
        """Create learning objectives using Bloom's Taxonomy"""
        objectives = []

        if level == SkillLevel.BEGINNER:
            objectives.append(LearningObjective(
                level=level,
                objective=f"Understand what {topic} is and why it's important",
                blooms_level="understand"
            ))
            objectives.append(LearningObjective(
                level=level,
                objective=f"Apply basic {topic} concepts in simple scenarios",
                blooms_level="apply"
            ))

        elif level == SkillLevel.INTERMEDIATE:
            objectives.append(LearningObjective(
                level=level,
                objective=f"Analyze different {topic} approaches and trade-offs",
                blooms_level="analyze"
            ))
            objectives.append(LearningObjective(
                level=level,
                objective=f"Create production-ready {topic} implementations",
                blooms_level="create"
            ))

        elif level == SkillLevel.ADVANCED:
            objectives.append(LearningObjective(
                level=level,
                objective=f"Evaluate {topic} design patterns for specific use cases",
                blooms_level="evaluate"
            ))
            objectives.append(LearningObjective(
                level=level,
                objective=f"Design custom {topic} solutions for complex systems",
                blooms_level="create"
            ))

        return objectives

    def _write_content(self, topic: str, level: SkillLevel) -> str:
        """Write level-appropriate content"""
        if level == SkillLevel.BEGINNER:
            return f"""## Introduction to {topic}

{topic} is a fundamental concept in software development. Let's start with the basics.

### What is {topic}?

{topic} helps developers solve common problems by providing proven solutions.

### Why Learn {topic}?

- Improves code quality
- Increases development speed
- Follows industry best practices"""

        elif level == SkillLevel.INTERMEDIATE:
            return f"""## Intermediate {topic}

Now that you understand the basics, let's explore more advanced concepts.

### Advanced Patterns

{topic} includes several patterns for different scenarios:

1. Pattern A - For use case X
2. Pattern B - For use case Y
3. Pattern C - For use case Z

### Trade-offs

Each pattern has strengths and weaknesses..."""

        else:  # ADVANCED
            return f"""## Advanced {topic}

At this level, we'll examine the theory, implementation details, and edge cases.

### Theoretical Foundation

{topic} is based on [theoretical concepts]...

### Performance Optimization

Critical performance considerations:

- Memory efficiency
- CPU utilization
- Scalability patterns"""

    def _create_examples(self, topic: str, level: SkillLevel) -> List[str]:
        """Create level-appropriate examples"""
        if level == SkillLevel.BEGINNER:
            return [
                f"// Simple {topic} example\nfunction basic_example() {{\n  return 'hello';\n}}"
            ]
        elif level == SkillLevel.INTERMEDIATE:
            return [
                f"// Production-ready {topic}\nclass Production_{topic} {{\n  // Implementation\n}}"
            ]
        else:
            return [
                f"// Advanced {topic} with optimization\nclass Optimized_{topic} {{\n  // Complex implementation\n}}"
            ]

    def _create_exercises(self, topic: str, level: SkillLevel) -> List[str]:
        """Create level-appropriate exercises"""
        if level == SkillLevel.BEGINNER:
            return [
                f"Exercise 1: Implement a simple {topic}",
                f"Exercise 2: Use {topic} in a basic scenario"
            ]
        elif level == SkillLevel.INTERMEDIATE:
            return [
                f"Exercise 1: Design a production {topic} system",
                f"Exercise 2: Optimize {topic} for performance"
            ]
        else:
            return [
                f"Exercise 1: Architect a distributed {topic} solution",
                f"Exercise 2: Handle edge cases in {topic}"
            ]

    def _estimate_time(self, content: str, examples: List[str], exercises: List[str]) -> int:
        """Estimate learning time in minutes"""
        reading_time = len(content.split()) // 200 * 60  # seconds
        example_time = len(examples) * 10  # 10 min per example
        exercise_time = len(exercises) * 15  # 15 min per exercise

        return (reading_time + example_time + exercise_time) // 60  # Convert to minutes

# Usage
generator = MultiLevelContentGenerator()

modules = generator.generate("Async Programming")

for level, module in modules.items():
    print(f"\n{module.title}")
    print(f"Time: {module.estimated_time} minutes")
    print(f"Objectives: {len(module.objectives)}")

Progressive Disclosure Framework

// scripts/progressive-disclosure.ts
interface ConceptLayer {
  depth: number;
  title: string;
  content: string;
  prerequisites: string[];
  followUp: string[];
}

class ProgressiveDisclosureManager {
  /**
   * Structure content in progressive layers
   */
  createLayers(topic: string): ConceptLayer[] {
    return [
      {
        depth: 1,
        title: `${topic}: The Big Picture`,
        content: 'High-level overview without details...',
        prerequisites: [],
        followUp: [`${topic} Core Concepts`]
      },
      {
        depth: 2,
        title: `${topic}: Core Concepts`,
        content: 'Essential concepts explained...',
        prerequisites: [`${topic}: The Big Picture`],
        followUp: [`${topic}: Implementation`]
      },
      {
        depth: 3,
        title: `${topic}: Implementation`,
        content: 'How to implement in practice...',
        prerequisites: [`${topic}: Core Concepts`],
        followUp: [`${topic}: Advanced Patterns`]
      },
      {
        depth: 4,
        title: `${topic}: Advanced Patterns`,
        content: 'Advanced techniques and edge cases...',
        prerequisites: [`${topic}: Implementation`],
        followUp: []
      }
    ];
  }

  /**
   * Check if learner is ready for next layer
   */
  isReadyFor(layer: ConceptLayer, completedTopics: string[]): boolean {
    return layer.prerequisites.every(prereq =>
      completedTopics.includes(prereq)
    );
  }
}

// Usage
const disclosure = new ProgressiveDisclosureManager();
const layers = disclosure.createLayers('Async Programming');

console.log(`Total layers: ${layers.length}`);

Learning Path Designer

# scripts/learning-path.py
from dataclasses import dataclass
from typing import List, Dict

@dataclass
class LearningModule:
    id: str
    title: str
    level: SkillLevel
    estimated_hours: int
    prerequisites: List[str]

@dataclass
class LearningPath:
    title: str
    description: str
    modules: List[LearningModule]
    total_hours: int

class LearningPathDesigner:
    """Design complete learning paths"""

    def design_path(
        self,
        topic: str,
        goal: str,
        current_level: SkillLevel = SkillLevel.BEGINNER
    ) -> LearningPath:
        """Design personalized learning path"""

        modules = self._create_modules(topic, current_level)
        total_hours = sum(m.estimated_hours for m in modules)

        return LearningPath(
            title=f"{topic} Learning Path",
            description=f"Master {topic} to {goal}",
            modules=modules,
            total_hours=total_hours
        )

    def _create_modules(
        self,
        topic: str,
        start_level: SkillLevel
    ) -> List[LearningModule]:
        """Create module sequence"""
        modules = []

        # Always start with fundamentals
        modules.append(LearningModule(
            id=f"{topic}-fundamentals",
            title=f"{topic} Fundamentals",
            level=SkillLevel.BEGINNER,
            estimated_hours=4,
            prerequisites=[]
        ))

        # Intermediate modules
        if start_level in [SkillLevel.BEGINNER, SkillLevel.INTERMEDIATE]:
            modules.append(LearningModule(
                id=f"{topic}-intermediate",
                title=f"Intermediate {topic}",
                level=SkillLevel.INTERMEDIATE,
                estimated_hours=8,
                prerequisites=[f"{topic}-fundamentals"]
            ))

        # Advanced modules
        modules.append(LearningModule(
            id=f"{topic}-advanced",
            title=f"Advanced {topic}",
            level=SkillLevel.ADVANCED,
            estimated_hours=12,
            prerequisites=[f"{topic}-intermediate"]
        ))

        # Capstone project
        modules.append(LearningModule(
            id=f"{topic}-capstone",
            title=f"{topic} Capstone Project",
            level=SkillLevel.ADVANCED,
            estimated_hours=16,
            prerequisites=[f"{topic}-advanced"]
        ))

        return modules

# Usage
designer = LearningPathDesigner()

path = designer.design_path(
    topic="Machine Learning",
    goal="build production ML systems",
    current_level=SkillLevel.BEGINNER
)

print(f"{path.title} - {path.total_hours} hours")
for module in path.modules:
    print(f"  - {module.title} ({module.estimated_hours}h)")

Usage Examples

Multi-Level Content

Apply educational-content-patterns skill to generate beginner, intermediate, and advanced modules for async programming

Progressive Disclosure

Apply educational-content-patterns skill to structure React tutorial with 4 progressive layers

Learning Path Design

Apply educational-content-patterns skill to design 40-hour learning path for production ML engineering

Integration Points

• content-marketing-patterns - Tutorial marketing
• research-patterns - Technical accuracy
• assessment-creation-agent - Knowledge assessment

---

Success Output

When this skill is successfully applied, output:

✅ SKILL COMPLETE: educational-content-patterns

Completed:
- [x] Multi-level content generated (beginner/intermediate/advanced)
- [x] Learning objectives defined with Bloom's taxonomy
- [x] Progressive disclosure layers structured
- [x] Examples created for each skill level
- [x] Exercises designed with appropriate difficulty
- [x] Learning path created with prerequisites
- [x] Estimated learning time calculated

Outputs:
- content/beginner-module.md (X estimated hours)
- content/intermediate-module.md (Y estimated hours)
- content/advanced-module.md (Z estimated hours)
- learning-path.json (complete curriculum)
- Total learning path: X hours across Y modules

Completion Checklist

Before marking this skill as complete, verify:

• Content created for all target skill levels
• Learning objectives use measurable verbs (Bloom's taxonomy)
• Each level includes examples appropriate to audience
• Exercises test stated learning objectives
• Progressive disclosure maintains logical flow
• Prerequisites clearly documented
• Estimated time realistic (tested or industry standard)
• Content scaffolding supports learner progression
• Technical accuracy verified
• Examples tested and executable (if code)

Failure Indicators

This skill has FAILED if:

• ❌ Beginner content assumes advanced knowledge
• ❌ Learning objectives vague or unmeasurable ("understand X")
• ❌ Examples too complex for stated skill level
• ❌ No clear progression from beginner to advanced
• ❌ Exercises don't align with learning objectives
• ❌ Prerequisites missing or circular dependencies
• ❌ Time estimates wildly inaccurate (off by >50%)
• ❌ Content skips critical intermediate steps
• ❌ Technical errors in code examples
• ❌ Bloom's taxonomy levels inappropriate for skill level

When NOT to Use

Do NOT use this skill when:

• Single skill level sufficient (not multi-level curriculum)
• Reference documentation needed (use api-documentation instead)
• Quick tutorial required (use tutorial-patterns for single topic)
• Content for expert-only audience (skip beginner/intermediate)
• Non-educational content (marketing, sales, legal)
• Real-time interactive teaching (use live-training-patterns)
• Assessment-only needed (use assessment-creation-agent)
• Content reuse/adaptation preferred (use content-adaptation skill)

Use alternatives:

• tutorial-patterns - Single-topic quick start
• api-documentation - Reference material
• assessment-creation-agent - Quizzes and tests only
• live-training-patterns - Instructor-led training

Anti-Patterns (Avoid)

Anti-Pattern	Problem	Solution
"Understand" objectives	Not measurable	Use action verbs: apply, analyze, create, evaluate
Inconsistent difficulty	Confuses learners	Maintain strict progression: simple → complex
No scaffolding	Learners get stuck	Provide examples before exercises
Missing prerequisites	Assumes knowledge	Explicitly list required prior knowledge
Generic examples	Low relevance	Use domain-specific, realistic scenarios
Theory-only content	No skill transfer	Include hands-on exercises for every concept
No time estimates	Learners can't plan	Calculate based on word count + exercise complexity
Copying existing content	Copyright issues	Create original examples or properly attribute
Bloom's level mismatch	Beginner asked to "evaluate"	Match taxonomy level to skill progression
No feedback mechanism	Can't improve	Include self-check exercises with answers

Principles

This skill embodies CODITECT core principles:

#2 First Principles Thinking

• Start with learning science fundamentals (cognitive load, scaffolding)
• Apply Bloom's taxonomy as foundation for objectives
• Progressive disclosure based on how humans learn

#5 Eliminate Ambiguity

• Measurable learning objectives leave no doubt about outcomes
• Clear skill level definitions (beginner/intermediate/advanced)
• Explicit prerequisites and time estimates

#6 Clear, Understandable, Explainable

• Progressive disclosure prevents overwhelming learners
• Examples illustrate concepts concretely
• Each layer builds on previous understanding

#7 Separation of Concerns

• Each module focused on specific skill level
• Learning objectives separate from content
• Examples separate from exercises

#9 Evidence-Based Decisions

• Bloom's taxonomy proven educational framework
• Time estimates based on research (200 words/minute reading)
• Scaffolding based on cognitive load theory

#10 Research When in Doubt

• Educational best practices evolve (check latest learning science)
• Domain-specific pedagogical patterns exist
• Accessibility standards for educational content

---

Full Standard: CODITECT-STANDARD-AUTOMATION.md