Update app.py

app.py

@@ -1,705 +1,705 @@
+# ruff: noqa
 """
-Personalized Worked Example Generator
-Demonstrates Cognitive Load Theory principles through AI-generated personalized examples.
+Interactive Exploration: Cognitive Load Theory & AI-Generated Worked Examples
+Five hands-on labs to understand how to design educational AI tools
 
-Based on research:
-- Sweller, J. (1988). Cognitive load during problem solving.
-- NSW CESE (2017). Cognitive load theory: Research that teachers really need to understand.
+Built for embedding in Quarto workshop materials
 """
 
 import marimo
 
-__generated_with = "0.9.0"
+__generated_with = "0.17.8"
 app = marimo.App(width="medium")
 
 
 @app.cell
-def imports():
+def _():
     import marimo as mo
     from openai import OpenAI
     from pydantic import BaseModel, Field
     from typing import Literal
     import os
-
-    return mo, OpenAI, BaseModel, Field, Literal, os
+    return BaseModel, Field, OpenAI, mo, os
 
 
 @app.cell
-def welcome_section(mo):
+def _(mo):
     mo.md("""
-    # 🎓 Personalized Worked Example Generator
+    # 🧪 Interactive Exploration Lab
+    ## Designing AI Tools Grounded in Cognitive Load Theory
 
-    **Learn concepts through examples tailored to YOUR interests!**
+    Welcome to the **interactive exploration**! This isn't a complete tool—it's a laboratory
+    where you'll experiment with the key design decisions that make AI educational tools effective.
 
-    ## Why This Works
+    ### What You'll Explore
 
-    This tool demonstrates principles from **Cognitive Load Theory**:
+    Through 5 hands-on labs, you'll discover:
 
-    ### The Worked Example Effect
-    > "Novice learners who are given worked examples to study perform better
-    > than learners who are required to solve problems themselves."
-    >
-    > — NSW Centre for Education Statistics and Evaluation (2017)
+    1. 🎨 **Prompt Design Lab** - How prompt engineering shapes learning
+    2. ⚖️ **Personalization A/B Test** - Feel the cognitive load difference
+    3. 🏗️ **Data Model Designer** - What makes examples "worked"
+    4. 🎛️ **Parameter Playground** - Model settings and pedagogy
+    5. 🔍 **CLT Analyzer** - Evaluate examples with a critical lens
 
-    **Why?** Unguided problem-solving overloads working memory. Worked examples
-    reduce cognitive load, freeing capacity for learning.
+    ### Why This Matters
 
-    ### The Personalization Effect
+    You could just use a tool. But **understanding the design principles** lets you:
+    - Adapt tools to your specific domain
+    - Critique and improve existing AI educational tools
+    - Design new tools grounded in learning science
 
-    Familiar contexts (your hobbies, interests, goals) are easier to process,
-    further reducing cognitive load and improving learning.
+    **Ready to explore?** Let's start with the setup.
+    """)
+    return
 
+
+@app.cell
+def _(OpenAI, os):
+    """Setup: Initialize OpenAI client"""
+    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+    return (client,)
+
+
+@app.cell
+def _(mo):
+    mo.md("""
     ---
 
-    ## How It Works
+    ## 🎨 Lab 1: Prompt Design Laboratory
+
+    **Learning Question**: How does prompt engineering affect the quality of worked examples?
+
+    ### The Experiment
 
-    1. **Tell us about yourself** - interests, goals, background
-    2. **Choose a concept** to learn in your domain
-    3. **Get a custom example** woven into your context
+    You'll see **two prompts** - a basic one and one grounded in CLT principles.
+    Try editing them and see how the outputs change.
 
-    Let's get started! 👇
+    **Key insight**: The prompt IS your pedagogical design encoded in language.
     """)
     return
 
 
 @app.cell
-def define_models(BaseModel, Field, Literal):
-    """
-    PEDAGOGICAL DESIGN: Define data structures
+def _(BaseModel, Field):
+    """Simple data model for Lab 1"""
 
-    These Pydantic models embody our learning principles:
-    - Clear structure reduces cognitive load
-    - Explicit fields make the design transparent
-    - Type hints ensure reliability
-    """
+    class SimpleExample(BaseModel):
+        """Minimal structure for prompt comparison"""
+        problem: str = Field(description="The problem to solve")
+        solution: str = Field(description="Step-by-step solution")
+        explanation: str = Field(description="Why this approach works")
+    return (SimpleExample,)
 
-    class LearnerProfile(BaseModel):
-        """Collect learner information for personalization"""
 
-        name: str = Field(
-            description="Learner's first name"
-        )
+@app.cell
+def _(mo):
+    """Lab 1: Prompt inputs"""
 
-        domain: Literal["programming", "health_sciences", "agronomy"] = Field(
-            description="Learning domain"
-        )
+    mo.md("### Try These Prompts")
 
-        specific_interest: str = Field(
-            description="Specific interest within domain"
-        )
+    basic_prompt = mo.ui.text_area(
+        label="Basic Prompt (no pedagogical grounding):",
+        value="""Create an example problem about Python for loops and solve it step by step.""",
+        full_width=True,
+        rows=3
+    )
 
-        hobby_or_passion: str = Field(
-            description="A hobby or passion they have"
-        )
+    clt_prompt = mo.ui.text_area(
+        label="CLT-Grounded Prompt (reduces cognitive load):",
+        value="""Create a worked example about Python for loops.
 
-        goal: str = Field(
-            description="What they want to achieve"
-        )
+    CRITICAL: This is a WORKED EXAMPLE for novice learners.
+    - Problem: Clear, specific, uses familiar context (counting items)
+    - Solution: Break into small steps, explain each step's purpose
+    - Explanation: Connect to WHY this pattern works (not just WHAT it does)
 
-        background_level: Literal["beginner", "intermediate", "advanced"] = Field(
-            description="Their current level in the domain"
-        )
+    Keep cognitive load low: avoid technical jargon, use concrete examples.""",
+        full_width=True,
+        rows=8
+    )
 
+    mo.vstack([basic_prompt, clt_prompt])
+    return basic_prompt, clt_prompt
 
-    class PersonalizedWorkedExample(BaseModel):
-        """
-        A complete worked example tailored to the learner
 
-        DESIGN RATIONALE (based on CLT):
-        - title: Engaging hook using learner's context
-        - problem_statement: Clear framing reduces ambiguity
-        - given_data: Familiar context reduces extraneous load
-        - step_by_step_solution: List structure supports chunking
-        - final_answer: Explicit conclusion aids schema formation
-        - connection_to_goal: Motivation through relevance
-        - practice_suggestion: Spaced practice opportunity
-        """
+@app.cell
+def _(mo):
+    """Lab 1: Generate button"""
 
-        title: str = Field(
-            description="Engaging title that incorporates learner's interest"
-        )
+    lab1_button = mo.ui.button(
+        label="🔬 Generate Both Examples",
+        kind="success"
+    )
 
-        problem_statement: str = Field(
-            description="Problem framed in learner's context (3-4 sentences)"
-        )
+    mo.md(f"### Compare the Results\n\n{lab1_button}")
+    return (lab1_button,)
 
-        given_data: str = Field(
-            description="Data presented in familiar context (can include code blocks or tables)"
-        )
 
-        step_by_step_solution: list[str] = Field(
-            description="Clear steps with explanations. Include code or calculations."
-        )
+@app.cell
+def _(SimpleExample, basic_prompt, client, clt_prompt, lab1_button, mo):
+    """Lab 1: Generate and compare both examples"""
+
+    lab1_output = None
+
+    # Debug: Show button state
+    if lab1_button.value:
+        try:
+            with mo.status.spinner(title="Generating both examples..."):
+                # Generate basic example
+                basic_response = client.responses.parse(
+                    model="gpt-4o-mini",
+                    input=[{"role": "user", "content": basic_prompt.value}],
+                    text_format=SimpleExample
+                )
+                basic_example = basic_response.output_parsed
 
-        final_answer: str = Field(
-            description="The final answer with interpretation relevant to learner's context"
-        )
+                # Generate CLT-grounded example
+                clt_response = client.responses.parse(
+                    model="gpt-4o-mini",
+                    input=[{"role": "user", "content": clt_prompt.value}],
+                    text_format=SimpleExample
+                )
+                clt_example = clt_response.output_parsed
+
+            _comparison = mo.vstack([
+                mo.md("### 📊 Basic Prompt Result"),
+                mo.md(f"**Problem:** {basic_example.problem}"),
+                mo.md(f"**Solution:** {basic_example.solution}"),
+                mo.md(f"**Explanation:** {basic_example.explanation}"),
+                mo.md("---"),
+                mo.md("### 🎓 CLT-Grounded Prompt Result"),
+                mo.md(f"**Problem:** {clt_example.problem}"),
+                mo.md(f"**Solution:** {clt_example.solution}"),
+                mo.md(f"**Explanation:** {clt_example.explanation}"),
+            ])
+
+            _reflection = mo.callout(mo.md("""
+            ### 💭 What Do You Notice?
+
+            - Which problem is clearer and more specific?
+            - Which solution breaks down steps better?
+            - Which explanation helps you understand WHY, not just WHAT?
+
+            **The prompt IS your pedagogical design!**
+            """), kind="info")
+
+            lab1_output = mo.vstack([_comparison, _reflection])
+
+        except Exception as e:
+            import traceback
+            lab1_output = mo.callout(
+                mo.md(f"""
+                ### ⚠️ Error Generating Examples
+
+                **Error type:** {type(e).__name__}
+
+                **Error message:** {str(e)}
+
+                **Full traceback:**
+                ```
+                {traceback.format_exc()}
+                ```
+
+                **Common fixes:**
+                - Make sure you have a `.env` file with `OPENAI_API_KEY=sk-...`
+                - Check that your API key is valid
+                - Ensure you have API credits available
+                """),
+                kind="danger"
+            )
+    else:
+        # Show this when button hasn't been clicked yet
+        lab1_output = mo.md("_Click the button above to generate examples_")
 
-        connection_to_goal: str = Field(
-            description="How this example relates to their stated goal (2-3 sentences)"
-        )
+    lab1_output
 
-        practice_suggestion: str = Field(
-            description="A similar problem they could try next, using their context"
-        )
 
-    return LearnerProfile, PersonalizedWorkedExample
+@app.cell
+def _(mo):
+    mo.md("""
+    ---
 
+    ## ⚖️ Lab 2: Personalization A/B Test
 
-@app.cell
-def define_concepts():
-    """Define concept library for each domain"""
-
-    CONCEPTS = {
-        "programming": [
-            {
-                "name": "For Loops",
-                "abstract": "Iterate through a sequence of items",
-                "difficulty": "beginner",
-                "typical_use": "Processing lists, repeating actions multiple times"
-            },
-            {
-                "name": "List Comprehensions",
-                "abstract": "Create new lists using concise syntax",
-                "difficulty": "intermediate",
-                "typical_use": "Transform data, filter lists elegantly"
-            },
-            {
-                "name": "Dictionary Methods",
-                "abstract": "Access and manipulate key-value pairs",
-                "difficulty": "beginner",
-                "typical_use": "Store related data, perform fast lookups"
-            },
-            {
-                "name": "Functions with Parameters",
-                "abstract": "Create reusable code blocks that accept inputs",
-                "difficulty": "beginner",
-                "typical_use": "Organize code, avoid repetition"
-            },
-            {
-                "name": "String Formatting",
-                "abstract": "Create formatted text output using f-strings",
-                "difficulty": "beginner",
-                "typical_use": "Display data, create messages dynamically"
-            }
-        ],
-        "health_sciences": [
-            {
-                "name": "Mean and Standard Deviation",
-                "abstract": "Describe central tendency and variability in data",
-                "difficulty": "beginner",
-                "typical_use": "Summarize health measurements, describe populations"
-            },
-            {
-                "name": "Correlation Analysis",
-                "abstract": "Measure strength and direction of relationship between two variables",
-                "difficulty": "intermediate",
-                "typical_use": "Find relationships in health data, guide research"
-            },
-            {
-                "name": "Linear Regression",
-                "abstract": "Predict one variable from another using a straight-line relationship",
-                "difficulty": "intermediate",
-                "typical_use": "Predict outcomes, understand relationships, forecast trends"
-            },
-            {
-                "name": "Independent T-Test",
-                "abstract": "Compare means between two independent groups",
-                "difficulty": "intermediate",
-                "typical_use": "Test intervention effectiveness, compare treatments"
-            },
-            {
-                "name": "Confidence Intervals",
-                "abstract": "Estimate population parameters with uncertainty",
-                "difficulty": "intermediate",
-                "typical_use": "Interpret research findings, quantify precision"
-            },
-            {
-                "name": "Effect Size (Cohen's d)",
-                "abstract": "Measure practical significance of differences",
-                "difficulty": "intermediate",
-                "typical_use": "Interpret research impact beyond p-values"
-            }
-        ],
-        "agronomy": [
-            {
-                "name": "Yield Prediction",
-                "abstract": "Estimate crop output based on inputs using regression",
-                "difficulty": "intermediate",
-                "typical_use": "Plan harvest, allocate resources, financial projections"
-            },
-            {
-                "name": "NPK Optimization",
-                "abstract": "Calculate optimal fertilizer ratios for maximum benefit",
-                "difficulty": "intermediate",
-                "typical_use": "Maximize yield while minimizing cost and environmental impact"
-            },
-            {
-                "name": "Growing Degree Days",
-                "abstract": "Calculate heat accumulation for crop development",
-                "difficulty": "beginner",
-                "typical_use": "Predict crop stages, plan field operations"
-            },
-            {
-                "name": "Water Use Efficiency",
-                "abstract": "Calculate crop yield per unit of water used",
-                "difficulty": "beginner",
-                "typical_use": "Optimize irrigation, compare varieties"
-            },
-            {
-                "name": "Cost-Benefit Analysis",
-                "abstract": "Compare costs and returns of agricultural interventions",
-                "difficulty": "intermediate",
-                "typical_use": "Make informed decisions about inputs and practices"
-            }
-        ]
-    }
+    **Learning Question**: Can you FEEL the difference in cognitive load?
 
-    return CONCEPTS,
+    ### The Experiment
+
+    You'll enter YOUR context (hobby, goal), then see the SAME concept taught:
+    - **Generic**: Standard textbook style
+    - **Personalized**: Using your context
+
+    **Hypothesis**: The personalized version should feel more engaging and easier to process.
+    """)
+    return
 
 
 @app.cell
-def setup_openai_client(OpenAI, os):
-    """
-    Initialize OpenAI client
+def _(mo):
+    """Lab 2: Context inputs"""
 
-    Simple and transparent - just create the client with your API key
-    """
-    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+    mo.md("### Your Context")
+
+    your_hobby = mo.ui.text(
+        label="Your hobby or interest:",
+        placeholder="e.g., photography, cooking, gaming",
+        full_width=True
+    )
+
+    your_goal = mo.ui.text(
+        label="What you want to achieve:",
+        placeholder="e.g., build a recipe app, automate photo editing",
+        full_width=True
+    )
 
-    return client,
+    mo.vstack([your_hobby, your_goal])
+    return your_hobby, your_goal
 
 
 @app.cell
-def define_system_prompt():
-    """
-    PEDAGOGICAL DESIGN: Craft the system prompt
-
-    This prompt embodies our CLT principles:
-    - Personalization reduces extraneous load
-    - Worked examples reduce germane load
-    - Clear structure supports schema formation
-    """
-
-    SYSTEM_PROMPT = """You are an expert educator who creates highly personalized
-    worked examples that connect abstract concepts to learners' lived experiences.
-
-    CRITICAL INSTRUCTIONS:
-    1. Weave the learner's interests, hobbies, and goals naturally into the example
-    2. Use their name throughout to increase personal connection
-    3. Make data and scenarios feel authentic to their context
-    4. Keep explanations clear but connect to what they care about
-    5. Match complexity to their level (beginner/intermediate/advanced)
-    6. Make the connection to their goal explicit and motivating
-    7. Use concrete numbers and realistic data
-    8. For programming examples, include actual runnable code with comments
-    9. For quantitative examples, show all calculations step by step
-
-    STRUCTURE YOUR EXAMPLES:
-    - Start with an engaging title that mentions their interest
-    - Frame the problem in their context (use their name and interests)
-    - Present data that feels real to their situation
-    - Walk through steps clearly with explanations
-    - For code: include comments explaining each part
-    - For math: show each calculation explicitly
-    - Connect the final answer to their goal
-    - Suggest a related practice problem in their context
-
-    AVOID:
-    - Generic examples with personal details superficially added
-    - Forced or artificial connections
-    - Too much technical jargon for beginners
-    - Abstract variable names (use meaningful names from their context)
-    - Skipping steps in solutions
-
-    Remember: This is a WORKED EXAMPLE - a complete solution for the learner
-    to study, not a problem for them to solve.
-    """
-
-    return SYSTEM_PROMPT,
+def _(mo):
+    """Lab 2: Generate button"""
+
+    lab2_button = mo.ui.button(
+        label="⚖️ Generate A/B Comparison",
+        kind="success"
+    )
+
+    mo.md(f"{lab2_button}")
+    return (lab2_button,)
 
 
 @app.cell
-def create_generator_function(client, SYSTEM_PROMPT, PersonalizedWorkedExample):
-    """
-    CORE FUNCTION: Generate personalized examples
-
-    Notice how simple this is:
-    1. Build the user prompt with learner context
-    2. Call OpenAI's responses API with our Pydantic model
-    3. Get back a validated PersonalizedWorkedExample
-
-    The new responses.parse() API is cleaner than the old chat completions!
-    """
-
-    def generate_personalized_example(
-        profile: 'LearnerProfile',
-        concept: dict
-    ) -> PersonalizedWorkedExample:
-        """Generate a personalized worked example"""
-
-        # Build the user prompt with all the context
-        user_prompt = f"""
-        Create a worked example for:
-
-        LEARNER PROFILE:
-        - Name: {profile.name}
-        - Domain: {profile.domain}
-        - Specific interest: {profile.specific_interest}
-        - Hobby/passion: {profile.hobby_or_passion}
-        - Goal: {profile.goal}
-        - Level: {profile.background_level}
-
-        CONCEPT TO TEACH:
-        - Name: {concept['name']}
-        - Abstract description: {concept['abstract']}
-        - Difficulty: {concept['difficulty']}
-        - Typical use: {concept['typical_use']}
-
-        Create a worked example that teaches this concept using {profile.name}'s
-        specific context. The example should feel personal and relevant to their
-        goal of "{profile.goal}".
-
-        Make the problem realistic and the data believable for their situation.
-
-        For programming: Include complete, runnable code with explanatory comments.
-        For quantitative problems: Show every calculation step explicitly.
-
-        This is a WORKED EXAMPLE - provide the complete solution for them to study.
-        """
-
-        # Call OpenAI with structured outputs using the new responses API
-        response = client.responses.parse(
-            model="gpt-5.1",
-            input=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": user_prompt}
-            ],
-            text_format=PersonalizedWorkedExample
-        )
-
-        # Extract the parsed example
-        return response.output_parsed
-
-    return generate_personalized_example,
+def _(SimpleExample, client, lab2_button, mo, your_goal, your_hobby):
+    """Lab 2: Generate A/B comparison"""
+
+    lab2_output = None
+
+    if lab2_button.value and your_hobby.value and your_goal.value:
+        try:
+            with mo.status.spinner(title="Generating generic and personalized examples..."):
+                # Generic example
+                generic_prompt = "Create a worked example about Python dictionaries for beginners."
+                generic_response = client.responses.parse(
+                    model="gpt-4o-mini",
+                    input=[{"role": "user", "content": generic_prompt}],
+                    text_format=SimpleExample
+                )
+                generic_example = generic_response.output_parsed
+
+                # Personalized example
+                personalized_prompt = f"""Create a worked example about Python dictionaries for beginners.
+
+IMPORTANT: Personalize this example for someone who is interested in {your_hobby.value} and wants to {your_goal.value}.
+Use familiar contexts and examples from their interest to make the concept more relatable and reduce cognitive load."""
+
+                personalized_response = client.responses.parse(
+                    model="gpt-4o-mini",
+                    input=[{"role": "user", "content": personalized_prompt}],
+                    text_format=SimpleExample
+                )
+                personalized_example = personalized_response.output_parsed
+
+            _comparison = mo.vstack([
+                mo.md("### 📖 Generic Example (Standard Textbook Style)"),
+                mo.md(f"**Problem:** {generic_example.problem}"),
+                mo.md(f"**Solution:** {generic_example.solution}"),
+                mo.md(f"**Explanation:** {generic_example.explanation}"),
+                mo.md("---"),
+                mo.md(f"### ✨ Personalized Example (Your Context: {your_hobby.value})"),
+                mo.md(f"**Problem:** {personalized_example.problem}"),
+                mo.md(f"**Solution:** {personalized_example.solution}"),
+                mo.md(f"**Explanation:** {personalized_example.explanation}"),
+            ])
+
+            _reflection = mo.callout(mo.md("""
+            ### 💭 How Did That Feel?
+
+            - Which example was more engaging to read?
+            - Which one felt easier to process mentally?
+            - Could you visualize the personalized example more easily?
+
+            **This is the personalization effect in action!** Familiar contexts reduce extraneous cognitive load.
+            """), kind="success")
+
+            lab2_output = mo.vstack([_comparison, _reflection])
+
+        except Exception as e:
+            lab2_output = mo.callout(
+                mo.md(f"""
+                ### ⚠️ Error Generating Examples
+
+                **Error:** {str(e)}
+
+                Check your `.env` file and API key.
+                """),
+                kind="danger"
+            )
+
+    lab2_output
 
 
 @app.cell
-def profile_form_header(mo):
-    """Header for profile form"""
-    mo.md("---\n## 👤 Step 1: Tell Us About Yourself")
+def _(mo):
+    mo.md("""
+    ---
+
+    ## 🏗️ Lab 3: Data Model Designer
+
+    **Learning Question**: What makes a worked example "worked"?
+
+    ### The Experiment
+
+    Design the data structure for a worked example. What fields do you need?
+    Think about:
+    - What cognitive load principle does each field support?
+    - How does structure guide the AI's output?
+
+    **Current Model** (you can modify this in your mind):
+    ```python
+    class WorkedExample:
+        problem: str           # What they need to solve
+        solution_steps: list   # Broken into chunks (why a list?)
+        final_answer: str      # Clear conclusion
+        key_insight: str       # Schema activation
+    ```
+    """)
     return
 
 
 @app.cell
-def profile_inputs(mo):
-    """Individual input widgets for profile"""
+def _(mo):
+    """Lab 3: Interactive field selector"""
+
+    mo.md("### Which Fields Support Learning?")
+
+    field_options = {
+        "problem: str": "The problem statement",
+        "solution_steps: list[str]": "Steps as a list (chunking!)",
+        "solution: str": "Solution as one big block",
+        "final_answer: str": "Explicit conclusion",
+        "key_insight: str": "Why this approach works",
+        "code_with_comments: str": "Annotated code",
+        "common_mistakes: str": "What to avoid",
+        "connection_to_real_world: str": "Practical relevance"
+    }
 
-    name_input = mo.ui.text(
-        label="Your first name:",
-        placeholder="e.g., Maria",
-        full_width=True
+    field_selector = mo.ui.multiselect(
+        options=list(field_options.keys()),
+        label="Select fields for YOUR ideal worked example:",
+        value=["problem: str", "solution_steps: list[str]", "final_answer: str", "key_insight: str"]
     )
 
-    domain_input = mo.ui.dropdown(
-        label="Choose your learning domain:",
-        options={
-            "Programming (Python)": "programming",
-            "Health Sciences (Statistics)": "health_sciences",
-            "Agronomy (Agricultural Science)": "agronomy"
-        },
-        value=None,
-        full_width=True
-    )
+    field_selector
+    return (field_selector,)
 
-    interest_input = mo.ui.text(
-        label="Your specific interest in this domain:",
-        placeholder="e.g., web development, sports nutrition, coffee farming",
-        full_width=True
-    )
 
-    hobby_input = mo.ui.text(
-        label="A hobby or passion you have:",
-        placeholder="e.g., photography, cycling, cooking",
-        full_width=True
-    )
+@app.cell
+def _(field_selector, mo):
+    """Lab 3: Display selection count"""
+    mo.md(f"**You selected {len(field_selector.value)} fields**")
+    return
 
-    goal_input = mo.ui.text(
-        label="What you want to achieve:",
-        placeholder="e.g., build a portfolio site, improve performance, increase yield",
-        full_width=True
-    )
 
-    level_input = mo.ui.dropdown(
-        label="Your current level:",
-        options=["beginner", "intermediate", "advanced"],
-        value="beginner",
-        full_width=True
-    )
+@app.cell
+def _(field_selector, mo):
+    """Lab 3: Analysis"""
 
-    return name_input, domain_input, interest_input, hobby_input, goal_input, level_input
+    if field_selector.value:
+        mo.md(f"""
+        ### Your Selected Structure
 
+        ```python
+        class WorkedExample:
+            {chr(10).join(['    ' + f for f in field_selector.value])}
+        ```
 
-@app.cell
-def display_profile_form(mo, name_input, domain_input, interest_input, hobby_input, goal_input, level_input):
-    """Display the profile form"""
+        ### 💭 Design Analysis
 
-    mo.vstack([
-        name_input,
-        domain_input,
-        interest_input,
-        hobby_input,
-        goal_input,
-        level_input
-    ])
+        **Key Questions:**
+        - Did you choose `solution_steps: list[str]` or `solution: str`?
+          - **List = chunking** (reduces cognitive load)
+          - **String = one big block** (higher load for novices)
+
+        - Did you include `key_insight`?
+          - Helps with **schema activation** (connecting to prior knowledge)
+
+        - Did you include `common_mistakes`?
+          - **Desirable difficulty**: learning from contrasts
 
+        **The design IS the pedagogy**. Each field choice implements a CLT principle.
+        """)
     return
 
 
 @app.cell
-def check_profile_complete(name_input, domain_input, interest_input, hobby_input, goal_input, level_input):
-    """Check if profile is complete"""
-
-    profile_complete = all([
-        name_input.value,
-        domain_input.value,
-        interest_input.value,
-        hobby_input.value,
-        goal_input.value,
-        level_input.value
-    ])
+def _(mo):
+    mo.md("""
+    ---
+
+    ## 🎛️ Lab 4: Parameter Playground
 
-    return profile_complete,
+    **Learning Question**: How do model parameters affect pedagogical quality?
+
+    ### The Experiment
+
+    GPT-5.1 has parameters like `reasoning.effort`. Try different settings and see
+    how they affect example quality.
+
+    **Note**: This lab is conceptual---showing the parameters you COULD control.
+    """)
+    return
 
 
 @app.cell
-def create_profile(profile_complete, LearnerProfile, name_input, domain_input, interest_input, hobby_input, goal_input, level_input):
-    """Create profile object if form is complete"""
-
-    if profile_complete:
-        learner_profile = LearnerProfile(
-            name=name_input.value,
-            domain=domain_input.value,
-            specific_interest=interest_input.value,
-            hobby_or_passion=hobby_input.value,
-            goal=goal_input.value,
-            background_level=level_input.value
-        )
-    else:
-        learner_profile = None
+def _(mo):
+    """Lab 4: Parameter sliders"""
+
+    mo.md("### Adjust Parameters")
 
-    return learner_profile,
+    reasoning_effort = mo.ui.dropdown(
+        options=["none", "low", "medium", "high"],
+        value="low",
+        label="Reasoning Effort (how much thinking?)"
+    )
+
+    verbosity = mo.ui.dropdown(
+        options=["low", "medium", "high"],
+        value="medium",
+        label="Verbosity (explanation detail)"
+    )
+
+    mo.vstack([reasoning_effort, verbosity])
+    return reasoning_effort, verbosity
 
 
 @app.cell
-def show_profile_status(mo, profile_complete, learner_profile):
-    """Show profile status"""
-
-    if profile_complete:
-        mo.callout(
-            f"""
-            ✅ **Profile Complete!**
-
-            Great, {learner_profile.name}! Now choose a concept below.
-            """,
-            kind="success"
-        )
-    else:
-        mo.callout(
-            "📝 Please fill in all fields above to continue.",
-            kind="info"
-        )
+def _(mo, reasoning_effort, verbosity):
+    """Lab 4: Display parameter info"""
+    mo.callout(mo.md(f"""
+    **Current Settings:**
+
+    - Reasoning: {reasoning_effort.value}
+    - Verbosity: {verbosity.value}
 
+    **For novices**: Low reasoning (fast), medium-high verbosity (detailed explanations)
+
+    **For experts**: Higher reasoning (better solutions), lower verbosity (concise)
+
+    The "best" parameters depend on your learners!
+    """), kind="info")
     return
 
 
 @app.cell
-def concept_selection_header(mo, profile_complete):
-    """Header for concept selection"""
+def _(mo):
+    mo.md("""
+    ---
 
-    if profile_complete:
-        mo.md("---\n## 📚 Step 2: Choose a Concept to Learn")
+    ## 🔍 Lab 5: CLT Analyzer
 
+    **Learning Question**: Can you evaluate examples using CLT principles?
+
+    ### The Experiment
+
+    Read an AI-generated example and evaluate it against CLT criteria.
+    This develops your **critical lens** for educational AI.
+    """)
     return
 
 
 @app.cell
-def concept_selector_widget(mo, profile_complete, learner_profile, CONCEPTS):
-    """Create concept selector based on chosen domain"""
-
-    if profile_complete and learner_profile:
-        available_concepts = CONCEPTS[learner_profile.domain]
-
-        concept_selector = mo.ui.dropdown(
-            label=f"Choose a concept in {learner_profile.domain.replace('_', ' ').title()}:",
-            options={
-                f"{c['name']} ({c['difficulty']})": c
-                for c in available_concepts
-            },
-            value=None,
-            full_width=True
-        )
-
-        mo.vstack([
-            concept_selector,
-            mo.callout(
-                "👆 Select a concept from the dropdown above to continue.",
-                kind="info"
-            ) if not concept_selector.value else None
-        ])
-    else:
-        concept_selector = None
+def _(mo):
+    """Lab 5: Generate button"""
 
-    return concept_selector,
+    mo.md("### Generate an Example to Analyze")
+
+    lab5_button = mo.ui.button(
+        label="🎲 Generate Random Example",
+        kind="neutral"
+    )
+
+    lab5_button
+    return (lab5_button,)
 
 
 @app.cell
-def generate_button_widget(mo, profile_complete, concept_selector):
-    """Create generate button"""
-
-    if profile_complete and concept_selector and concept_selector.value:
-        generate_button = mo.ui.button(
-            label="✨ Generate My Personalized Example",
-            kind="success",
-            full_width=True
-        )
-
-        mo.vstack([
-            mo.md("---"),
-            mo.md("## 🎯 Step 3: Generate Your Example"),
-            generate_button
-        ])
-    else:
-        generate_button = None
+def _(SimpleExample, client, lab5_button, mo):
+    """Lab 5: Generate and display example to analyze"""
+
+    lab5_output = None
+
+    if lab5_button.value:
+        try:
+            with mo.status.spinner(title="Generating example..."):
+                response = client.responses.parse(
+                    model="gpt-4o-mini",
+                    input=[{"role": "user", "content": "Create a worked example about Python dictionaries for beginners."}],
+                    text_format=SimpleExample
+                )
+                analyze_example = response.output_parsed
 
-    return generate_button,
+            lab5_output = mo.vstack([
+                mo.md("### Example to Analyze"),
+                mo.md(f"**Problem:** {analyze_example.problem}"),
+                mo.md(f"**Solution:** {analyze_example.solution}"),
+                mo.md(f"**Explanation:** {analyze_example.explanation}"),
+            ])
+
+        except Exception as e:
+            lab5_output = mo.callout(
+                mo.md(f"""
+                ### ⚠️ Error Generating Example
+
+                **Error:** {str(e)}
+
+                Check your `.env` file and API key.
+                """),
+                kind="danger"
+            )
+
+    lab5_output
 
 
 @app.cell
-def generate_and_display(mo, generate_button, learner_profile, concept_selector, generate_personalized_example):
-    """Generate and display the personalized example"""
+def _(mo):
+    """Lab 5: CLT evaluation checklist"""
 
-    if generate_button and generate_button.value and learner_profile and concept_selector.value:
+    mo.md("### Evaluate Using CLT Principles")
 
-        # Show loading state
-        with mo.status.spinner(title="Creating your personalized example... This may take 30-60 seconds."):
-            try:
-                example = generate_personalized_example(
-                    profile=learner_profile,
-                    concept=concept_selector.value
-                )
+    reduces_extraneous = mo.ui.checkbox(
+        label="✅ Reduces extraneous cognitive load (no unnecessary complexity)"
+    )
 
-                # Display the example
-                display_content = mo.vstack([
-                    mo.md("---"),
-                    mo.md(f"# {example.title}"),
-                    mo.md("## 📋 The Problem"),
-                    mo.md(example.problem_statement),
-                    mo.md("### Given Data"),
-                    mo.md(example.given_data),
-                    mo.md("---"),
-                    mo.md("## 💡 Step-by-Step Solution"),
-                    *[mo.md(f"**Step {i}:**\n\n{step}")
-                      for i, step in enumerate(example.step_by_step_solution, 1)],
-                    mo.md("---"),
-                    mo.md("## ✅ Final Answer"),
-                    mo.md(example.final_answer),
-                    mo.md("---"),
-                    mo.callout(
-                        f"### 🎯 Why This Matters for You\n\n{example.connection_to_goal}",
-                        kind="success"
-                    ),
-                    mo.md("---"),
-                    mo.callout(
-                        f"### 🚀 Try This Next\n\n{example.practice_suggestion}",
-                        kind="info"
-                    ),
-                ])
-
-                display_content
-
-            except Exception as e:
-                mo.callout(
-                    f"❌ Error generating example: {str(e)}\n\nPlease check your OpenAI API key.",
-                    kind="danger"
-                )
+    manages_intrinsic = mo.ui.checkbox(
+        label="✅ Manages intrinsic load (breaks problem into chunks)"
+    )
 
-    return
+    optimizes_germane = mo.ui.checkbox(
+        label="✅ Optimizes germane load (helps build schemas/patterns)"
+    )
 
+    worked_not_problem = mo.ui.checkbox(
+        label="✅ Is a WORKED example (shows complete solution, not a puzzle)"
+    )
 
-@app.cell
-def footer(mo):
-    """Display footer with information"""
+    clear_steps = mo.ui.checkbox(
+        label="✅ Has clear step-by-step progression"
+    )
 
-    mo.md("""
-    ---
+    explains_why = mo.ui.checkbox(
+        label="✅ Explains WHY, not just WHAT"
+    )
 
-    ## 📖 About This Tool
+    mo.vstack([
+        reduces_extraneous,
+        manages_intrinsic,
+        optimizes_germane,
+        worked_not_problem,
+        clear_steps,
+        explains_why
+    ])
+    return (
+        clear_steps,
+        explains_why,
+        manages_intrinsic,
+        optimizes_germane,
+        reduces_extraneous,
+        worked_not_problem,
+    )
 
-    ### Cognitive Load Theory Principles
 
-    This tool demonstrates research-backed learning principles:
+@app.cell
+def _(
+    clear_steps,
+    explains_why,
+    manages_intrinsic,
+    mo,
+    optimizes_germane,
+    reduces_extraneous,
+    worked_not_problem,
+):
+    """Lab 5: Scoring"""
+
+    checklist_values = [
+        reduces_extraneous.value,
+        manages_intrinsic.value,
+        optimizes_germane.value,
+        worked_not_problem.value,
+        clear_steps.value,
+        explains_why.value
+    ]
+
+    score = sum(1 for v in checklist_values if v)
+
+    if score > 0:
+        mo.callout(f"""
+        ### Score: {score}/6
+
+        {"🌟" * score}
+
+        **Interpretation:**
+        - 5-6: Excellent pedagogical design
+        - 3-4: Good, but room for improvement
+        - 1-2: Needs significant pedagogical revision
+        - 0: Not yet evaluated
+
+        **Key Skill**: You're developing a CLT-grounded critical lens for evaluating AI tools!
+        """, kind="success" if score >= 5 else "info")
+    return
 
-    **The Worked Example Effect** (Sweller, 1988; Cooper & Sweller, 1987)
-    > "Novice learners who are given worked examples to study perform better on
-    > subsequent tests than learners who are required to solve the equivalent
-    > problems themselves."
 
-    - **Why?** Unguided problem-solving overloads working memory
-    - **Result:** Studying worked examples frees cognitive capacity for learning
-    - **Evidence:** Effect size of 0.52 across multiple studies (Crissman, 2006)
+@app.cell
+def _(mo):
+    mo.md("""
+    ---
 
-    **The Personalization Effect** (Cordova & Lepper, 1996)
-    > "Familiar contexts require less cognitive effort to process, reducing
-    > extraneous cognitive load and improving learning outcomes."
+    ## 🎯 Conclusion: From Exploration to Creation
 
-    - **Why?** Known contexts don't require working memory to parse
-    - **Result:** More capacity available for schema construction
-    - **Benefit:** Increased motivation through personal relevance
+    ### What You Discovered
 
-    ### Built With
+    Through these 5 labs, you explored:
 
-    - [Marimo](https://marimo.io) - Reactive Python notebooks
-    - [OpenAI GPT-5.1](https://platform.openai.com/docs/guides/latest-model) - Latest language model with structured outputs
-    - [Pydantic](https://pydantic.dev) - Data validation
+    1. ✅ **Prompts encode pedagogy** - Design drives outputs
+    2. ✅ **Personalization reduces load** - Context matters
+    3. ✅ **Structure shapes learning** - Data models are pedagogical choices
+    4. ✅ **Parameters affect quality** - Settings have learning implications
+    5. ✅ **Critical evaluation is a skill** - You can assess AI tools with CLT
 
-    ### 🔧 Extend This Tool
+    ### What's Next?
 
-    Ideas for enhancement:
+    Now that you understand the **design principles**, you're ready to:
 
-    - Add more domains (economics, chemistry, history, literature)
-    - Include images and diagrams in examples
-    - Create sequences of scaffolded examples
-    - Track learner progress over time
-    - Export examples to PDF or flashcards
-    - Add multilingual support
-    - Integrate with learning management systems
+    **Option 1: Build Your Own Tool**
+    - Use the simplified code from the workshop
+    - Apply these design principles
+    - Deploy to HuggingFace Spaces
 
-    ### 📚 Research References
+    **Option 2: Use the Complete Tool**
+    - [Try the full Worked Example Weaver](https://huggingface.co/spaces/virtuelleakademie/worked-example-weaver-app)
+    - See all 5 principles integrated
 
-    - Cooper, G., & Sweller, J. (1987). Effects of schema acquisition and rule
-      automation on mathematical problem-solving transfer. *Journal of Educational
-      Psychology*, 79(4), 347-362.
+    **Option 3: Adapt to Your Domain**
+    - Take the template
+    - Add your concepts
+    - Customize for your learners
 
-    - Cordova, D. I., & Lepper, M. R. (1996). Intrinsic motivation and the process
-      of learning: Beneficial effects of contextualization, personalization, and
-      choice. *Journal of Educational Psychology*, 88(4), 715.
+    ### The Big Idea
 
-    - Crissman, J. (2006). *The design and utilization of effective worked examples:
-      A meta-analysis* (Doctoral dissertation). University of Nebraska, Lincoln.
+    AI tools for education should be **grounded in learning science**, not just technically impressive.
 
-    - NSW Centre for Education Statistics and Evaluation (2017). *Cognitive load
-      theory: Research that teachers really need to understand*.
-      [Link](https://education.nsw.gov.au/about-us/education-data-and-research/cese/publications/literature-reviews/cognitive-load-theory)
+    You now have:
+    - 🧠 The theoretical foundation (CLT)
+    - 🔬 Hands-on experience (these labs)
+    - 🛠️ The technical skills (simple OpenAI API)
+    - 🎯 A critical lens (can evaluate tools)
 
-    - Sweller, J. (1988). Cognitive load during problem solving: Effects on learning.
-      *Cognitive Science*, 12(2), 257-285.
+    **Go build something that helps people learn!**
 
     ---
 
-    **Created for the BFH Workshop:** KI in der Lehre: Advanced
+    *Created by the [Virtual Academy](https://virtuelleakademie.ch/), BFH*
     """)
-
     return