Agent workshop questions

instructor/02-workshop-planning.md

@@ -1,5 +1,52 @@
 # Workshop Planning Guide
 
+## Pre-Planning: Essential Questions
+
+Before any planning begins, get clear answers to these questions from the instructor:
+
+### Core Questions Checklist
+
+- [ ] **Topic**: What is the main topic and what specific concepts should be covered?
+- [ ] **Audience**: Who is the primary audience and what is their experience level?
+- [ ] **Duration**: How long should the workshop be (2-4 hours, 4-8 hours, 1-2 days)?
+- [ ] **App Type**: Simple files (HTML/JS) or project apps (Remix, Vite, etc.)?
+- [ ] **Testing**: In-browser verification, automated test scripts, or both?
+- [ ] **Workshop Series**: Is this a continuation? Are follow-ups planned?
+- [ ] **Learning Outcomes**: What should learners be able to DO after completing?
+
+### App Type Decision Guide
+
+| Choose Simple Files When... | Choose Project Apps When... |
+|----------------------------|----------------------------|
+| Teaching fundamentals (HTML, CSS, JS basics) | Teaching framework-specific concepts |
+| Exercises are single-file focused | Exercises need build tools or bundlers |
+| Quick iteration is important | Real-world project structure matters |
+| Minimal setup is preferred | Multiple files/folders are needed |
+| Browser APIs are the focus | Server-side code is required |
+
+### Testing Approach Decision Guide
+
+| Choose In-Browser When... | Choose Test Scripts When... |
+|--------------------------|---------------------------|
+| Visual output is the goal | Specific behavior must be verified |
+| Learning HTML/CSS | Teaching testing concepts |
+| Simple console output suffices | Complex logic needs validation |
+| Immediate feedback is key | Automated grading is needed |
+
+### Workshop Series Considerations
+
+**If this is a continuation of another workshop:**
+- Review the previous workshop's final state as your starting point
+- Assume knowledge from the previous workshop (don't re-teach)
+- Reference the previous workshop in your introduction
+- Consider using the same app/codebase if applicable
+
+**If follow-up workshops are planned:**
+- Define clear boundaries for what's "out of scope - covered in follow-up"
+- Avoid going too deep on topics that will have dedicated workshops
+- End with a teaser of what's coming next
+- Leave the codebase in a state that can be extended
+
 ## Phase 1: Topic Research
 
 Before creating any exercises, thoroughly understand the topic:
@@ -11,13 +58,16 @@ Before creating any exercises, thoroughly understand the topic:
 - [ ] Understand common pain points and misconceptions
 - [ ] Identify prerequisites learners need
 - [ ] Determine the target audience skill level
+- [ ] Review previous workshop (if continuation)
+- [ ] Understand scope boundaries (if follow-up planned)
 
 ### Questions to Answer
 1. What does a beginner need to know?
 2. What does an expert need that beginners don't?
 3. What are the most common mistakes people make?
 4. What's the "aha moment" for this topic?
 5. How does this topic connect to real-world applications?
+6. What can be deferred to a follow-up workshop?
 
 ## Phase 2: Scoping
 
@@ -119,8 +169,21 @@ Exercises are relatively independent. Best for:
 ```markdown
 # Workshop: [Title]
 
+## Overview
+- **Duration:** [2-4 hours / 4-8 hours / 1-2 days]
+- **App Type:** [Simple files / Project apps / Mix]
+- **Testing:** [In-browser / Test scripts / Both]
+
 ## Target Audience
-[Who is this for? What do they already know?]
+- **Primary audience:** [Who is this for?]
+- **Experience level:** [Beginner / Intermediate / Advanced]
+- **What they already know:** [Assumed knowledge]
+
+## Workshop Series Context
+- **Previous workshop:** [Name and link, or "None - standalone"]
+- **Follow-up workshop:** [Planned topic, or "None planned"]
+- **Assumed from previous:** [Concepts carried forward, or N/A]
+- **Deferred to follow-up:** [Topics saved for later, or N/A]
 
 ## Learning Outcomes
 By the end of this workshop, learners will be able to:
@@ -153,6 +216,10 @@ By the end of this workshop, learners will be able to:
 - [Topic not covered]
 - [Topic not covered]
 
+## Deferred to Follow-up Workshop
+- [Topic to cover in next workshop]
+- [Topic to cover in next workshop]
+
 ## Potential Bonus Content
 - [Extra exercise idea]
 - [Extra exercise idea]
@@ -183,8 +250,21 @@ Consider:
 ```markdown
 # Workshop: React Server Components
 
+## Overview
+- **Duration:** 4-8 hours (standard)
+- **App Type:** Project apps (Next.js)
+- **Testing:** Mix of in-browser and test scripts
+
 ## Target Audience
-Experienced React developers who want to understand RSC
+- **Primary audience:** Frontend developers moving to full-stack
+- **Experience level:** Intermediate React developers
+- **What they already know:** React fundamentals, basic Node.js
+
+## Workshop Series Context
+- **Previous workshop:** "React Fundamentals" (assumes completion)
+- **Follow-up workshop:** "Advanced RSC Patterns" (planned)
+- **Assumed from previous:** Components, hooks, state management, JSX
+- **Deferred to follow-up:** Caching strategies, parallel routes, intercepting routes
 
 ## Learning Outcomes
 1. Understand the mental model of server vs client components
@@ -220,6 +300,15 @@ Experienced React developers who want to understand RSC
 - 03.problem.optimistic: Add optimistic updates
 
 [etc...]
+
+## Out of Scope
+- Next.js App Router specifics (covered in separate workshop)
+- Database integration details
+
+## Deferred to Follow-up Workshop
+- Advanced caching strategies
+- Parallel and intercepting routes
+- Production deployment patterns
 ```
 
 ## Planning Anti-Patterns

instructor/workflow/01-discovery.md

@@ -4,33 +4,116 @@
 
 ## Step 1.1: Understand the Topic
 
-Ask the instructor these questions:
+Before designing any exercises, you need clear answers to these essential questions. Ask the instructor to provide this information:
+
+### Essential Questions
 
 ```
-To create a great workshop, I need to understand:
+To create a great workshop, I need to understand the following:
 
+**Topic & Scope**
 1. What is the main topic? (e.g., "React Server Components", "Vitest Mocking")
-2. Who is the target audience? (beginners, intermediate, advanced)
-3. What should learners be able to do after completing the workshop?
-4. How long should the workshop be? (2-4 hours, 4-8 hours, full day)
-5. Are there specific technologies/frameworks required?
+2. What specific concepts or subtopics should be covered?
+3. What is explicitly OUT of scope for this workshop?
+
+**Audience**
+4. Who is the primary audience? (e.g., junior devs, senior engineers, full-stack developers)
+5. What is their expected experience level with this topic? (complete beginner, some familiarity, intermediate, advanced)
+6. What prerequisites should learners already know before starting?
+
+**Duration & Structure**
+7. How long should the workshop be?
+   - Short: 2-4 hours (4-6 exercises)
+   - Standard: 4-8 hours (6-10 exercises)
+   - Comprehensive: 1-2 days (8-12 exercises)
+
+**App Type**
+8. What type of exercise apps should be used?
+   - Simple files: Single HTML/CSS/JS files, minimal setup, served directly by workshop app
+   - Project apps: Full applications with build tools (Remix, Vite, etc.), separate dev servers
+
+**Testing Approach**
+9. How should exercises be tested/validated?
+   - In-browser: Learners verify visually or via browser console
+   - Test scripts: Automated tests using Vitest or similar (learners run tests to check their work)
+   - Both: Mix of visual verification and automated tests
+
+**Workshop Series Context**
+10. Is this workshop a continuation of another workshop?
+    - If yes: Which workshop? (This can serve as a starting point for code/concepts)
+    - If yes: What concepts from the previous workshop should be assumed knowledge?
+11. Are follow-up workshops planned to cover more advanced material?
+    - If yes: What topics will be deferred to the follow-up workshop(s)?
+    - This helps define clear boundaries for the current workshop
+
+**Learning Outcomes**
+12. What should learners be able to DO after completing the workshop? (specific, actionable outcomes)
+13. What is the "aha moment" you want learners to experience?
+```
+
+### Additional Clarifying Questions
+
+Depending on the topic, you may also need to ask:
+
+```
+**Code & Examples**
+- Should exercises use a specific coding style or conventions?
+- Are there existing codebases or examples to reference?
+- Should exercises build one continuous application or be independent?
+
+**Technical Requirements**
+- Are there specific versions of libraries/frameworks to use?
+- Are there any dependencies or tools that must be included?
+- Should exercises work offline or require internet access?
+
+**Content Style**
+- Is there a preferred tone? (formal, casual, humorous)
+- Should exercises reference real-world scenarios or use abstract examples?
+- Are there any topics or examples to avoid?
 ```
 
 ## Step 1.2: Research the Topic
 
-Before designing exercises:
+Once you have answers to the essential questions, research the topic:
 
 1. Review official documentation for the topic
 2. Identify core concepts that must be covered
 3. Find common pain points and misconceptions
 4. Understand best practices and anti-patterns
 5. Note any prerequisites learners need
+6. If this is a continuation workshop, review the previous workshop's content
+
+### For Continuation Workshops
+
+If this workshop builds on a previous one:
+
+- Review the previous workshop's exercise structure
+- Understand what code/concepts carry forward
+- Identify the "handoff point" where this workshop begins
+- Note any patterns or conventions established in the previous workshop
 
 ## Step 1.3: Define Boundaries
 
-Create a scope document:
+Create a scope document that captures all the discovered information:
 
 ```markdown
+## Workshop Overview
+- **Title:** [Workshop name]
+- **Duration:** [Hours/days]
+- **App Type:** [Simple files / Project apps / Mix]
+- **Testing:** [In-browser / Test scripts / Both]
+
+## Target Audience
+- **Primary audience:** [Who this is for]
+- **Experience level:** [Beginner / Intermediate / Advanced]
+- **Prerequisites:** [What learners must already know]
+
+## Workshop Series Context
+- **Previous workshop:** [Name or "None - standalone workshop"]
+- **Follow-up workshop:** [Planned topics or "None planned"]
+- **Assumed knowledge from previous:** [List or N/A]
+- **Deferred to follow-up:** [List or N/A]
+
 ## In Scope
 - [Core concept 1]
 - [Core concept 2]
@@ -40,22 +123,46 @@ Create a scope document:
 - [Related but not essential topic]
 - [Advanced topic for future workshop]
 
-## Prerequisites
-- [What learners must already know]
+## Learning Outcomes
+After completing this workshop, learners will be able to:
+1. [Specific outcome 1]
+2. [Specific outcome 2]
+3. [Specific outcome 3]
 ```
 
 ## Checkpoint
 
 Before proceeding, confirm with the instructor:
 
 ```
-Based on my research, here's what I understand:
+Based on our discussion, here's my understanding of the workshop:
 
 **Topic:** [Summary]
-**Audience:** [Who this is for]
+**Audience:** [Who this is for] with [experience level] experience
 **Duration:** [Expected length]
-**Core concepts:** [List]
-**Prerequisites:** [List]
+**App Type:** [Simple files / Project apps]
+**Testing:** [In-browser / Test scripts / Both]
+
+**Workshop Series:**
+- Previous workshop: [Name or "Standalone"]
+- Follow-up planned: [Yes/No - brief description if yes]
+
+**Core concepts to cover:**
+- [Concept 1]
+- [Concept 2]
+- [Concept 3]
+
+**Out of scope:**
+- [Topic 1]
+- [Topic 2]
+
+**Prerequisites learners need:**
+- [Prerequisite 1]
+- [Prerequisite 2]
+
+**Key learning outcomes:**
+1. [Outcome 1]
+2. [Outcome 2]
 
 Does this match your vision? Should I proceed to planning?
 ```

instructor/workflow/02-planning.md

@@ -4,13 +4,29 @@
 
 **Reference:** For planning best practices, see `../02-workshop-planning.md`
 
+## Prerequisites
+
+Before starting this phase, ensure you have answers to all discovery questions from Phase 1, including:
+- App type (simple files vs project apps)
+- Testing approach (in-browser vs test scripts)
+- Workshop series context (previous/follow-up workshops)
+- Target audience and experience level
+- Workshop duration
+
 ## Step 2.1: Draft Exercise List
 
-Create a high-level exercise outline:
+Create a high-level exercise outline that incorporates discovery answers:
 
 ```markdown
 # Workshop: [Title]
 
+## Overview
+- **Duration:** [From discovery]
+- **App Type:** [Simple files / Project apps]
+- **Testing:** [In-browser / Test scripts / Both]
+- **Previous Workshop:** [Name or "Standalone"]
+- **Follow-up Planned:** [Yes/No]
+
 ## Exercise Plan
 
 ### 01. [First Exercise Name]
@@ -56,6 +72,10 @@ Check the exercise plan:
 - [ ] Are there any gaps in coverage?
 - [ ] Can each step be completed in 15-30 minutes?
 - [ ] Is the total length appropriate for target duration?
+- [ ] Does the app type match the complexity needed for each exercise?
+- [ ] Is the testing approach consistent and appropriate?
+- [ ] If continuation: Does it properly build on the previous workshop?
+- [ ] If follow-up planned: Are boundaries clear on what's deferred?
 
 ## Workshop Length Guidelines
 
@@ -72,13 +92,28 @@ Present the plan to the instructor:
 ```
 Here's my proposed workshop structure:
 
+**Configuration:**
+- App Type: [Simple files / Project apps]
+- Testing: [In-browser / Test scripts / Both]
+- Duration: [X hours/days]
+
+**Workshop Series:**
+- Previous: [Workshop name or "Standalone"]
+- Follow-up: [Planned topic or "None"]
+
 [Full exercise plan with steps]
 
+**Scope boundaries:**
+- In scope: [Key topics]
+- Out of scope: [Excluded topics]
+- Deferred to follow-up: [If applicable]
+
 Questions:
 1. Does this cover what you wanted?
 2. Is the order logical?
 3. Should anything be added or removed?
 4. Is the difficulty progression appropriate?
+5. Are the app type and testing approach correct for this content?
 ```
 
 ## Next Step