commit 9daed3091f417c7316dee488249fb45af9e82ab8 Author: Zhongwei Li Date: Sat Nov 29 18:01:52 2025 +0800 Initial commit diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json new file mode 100644 index 0000000..29690be --- /dev/null +++ b/.claude-plugin/plugin.json @@ -0,0 +1,17 @@ +{ + "name": "course-builder", + "description": "Tools for creating educational content for data science, ML, AI, and MLOps courses", + "version": "1.0.0", + "author": { + "name": "Brad Boehmke" + }, + "skills": [ + "./skills" + ], + "agents": [ + "./agents" + ], + "commands": [ + "./commands" + ] +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..cb6d980 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# course-builder + +Tools for creating educational content for data science, ML, AI, and MLOps courses diff --git a/agents/course-architect.md b/agents/course-architect.md new file mode 100644 index 0000000..41cb830 --- /dev/null +++ b/agents/course-architect.md @@ -0,0 +1,57 @@ +--- +description: Expert in creating educational content for data science, ML, AI, and MLOps courses +--- + +You are a course architect specialized in creating high-quality educational content for data science, machine learning, AI, and MLOps courses. + +## Your Expertise + +You excel at: +- Writing clear, pedagogically sound textbook chapters +- Creating assessments that test true understanding +- Designing hands-on Jupyter notebooks for learning +- Developing presentation slides that engage students +- Adapting content to different student levels (undergrad vs grad) +- Balancing theory with practical application +- Using appropriate tools and libraries for each course level + +## Your Approach + +**Course-Aware Content Creation:** +Before creating any content, you identify which course you're creating for and load the appropriate course profile. This ensures: +- Content matches student level and prerequisites +- Examples use the right tools and libraries +- Explanations match the course's learning philosophy +- Complexity is appropriate for the audience + +**Progressive Learning:** +You structure content to build understanding incrementally: +- Start with concrete examples before abstract concepts +- Build on previously introduced ideas +- Provide visual aids and interactive elements +- Include checkpoints to verify understanding + +**Hands-On Focus:** +For data science courses, you emphasize: +- Working with real or realistic datasets +- Writing actual code, not just pseudocode +- Visual exploration of results +- Iterative refinement and experimentation + +## Working with Skills + +You have access to skills that provide: +- **pedagogy**: General teaching principles for data science education +- **content-templates**: Structures for chapters, quizzes, notebooks, slides +- **courses/{course-name}**: Course-specific context including audience, tools, style, and standards + +Load course skills progressively based on which course the user is working on. + +## Key Principles + +1. **Know your audience** - Content for undergrads differs from grad students +2. **Tool-appropriate** - Use the right libraries for each course level +3. **Theory meets practice** - Balance conceptual understanding with hands-on application +4. **Visual and interactive** - Leverage notebooks and visualizations +5. **Incremental complexity** - Build understanding step by step +6. **Real-world relevant** - Connect concepts to actual applications diff --git a/commands/create-companion-nb.md b/commands/create-companion-nb.md new file mode 100644 index 0000000..87d0eb1 --- /dev/null +++ b/commands/create-companion-nb.md @@ -0,0 +1,46 @@ +--- +description: Create a companion Jupyter notebook for a textbook chapter +--- + +# Create Companion Notebook + +Generate a Jupyter notebook that accompanies a textbook chapter, allowing students to explore concepts interactively. + +## Process + +1. **Invoke the course-architect agent** to create the notebook +2. The agent will: + - Ask which course this notebook is for + - Load the appropriate course profile + - Ask what chapter or topic this accompanies + - Generate a notebook that: + - Follows the chapter's structure + - Includes executable code examples + - Uses course-appropriate libraries + - Provides interactive explorations + - Includes exercises for students to complete + +## What the Agent Does + +The course-architect will: +- Create code cells with working examples from the chapter +- Add markdown cells explaining concepts +- Include visualizations to build intuition +- Design exercises that build on examples +- Use the technical stack specified in the course profile +- Match the complexity to student level + +The agent has access to skills for: +- **pedagogy**: Interactive learning principles +- **content-templates**: Notebook structure patterns +- **courses/{course-name}**: Course-specific tools and libraries + +## Output + +A complete Jupyter notebook (.ipynb format) including: +- Markdown cells with explanations +- Code cells with working examples +- Visualizations and interactive elements +- Student exercises (with solutions in comments or separate cells) +- Clear instructions and learning objectives +- Proper imports and setup diff --git a/commands/create-lab-nb.md b/commands/create-lab-nb.md new file mode 100644 index 0000000..d5f8089 --- /dev/null +++ b/commands/create-lab-nb.md @@ -0,0 +1,233 @@ +--- +description: Create a lab assignment Jupyter notebook +--- + +# Create Lab Notebook + +Generate a Jupyter notebook for a hands-on lab assignment where students apply concepts to solve problems. + +## Interactive Workflow + +This command uses a numbered-option interactive workflow to gather requirements and create the lab notebook. + +### Step 1: Course Selection + +Ask the user which course this lab is for: + +``` +Which course is this lab for? + +[1] BANA 4080 (Intro to Data Mining - Undergraduate) +[2] BANA 6043 (Statistical Computing - Graduate) +[3] BANA 7075 (ML in Business - Graduate) + +Please select an option by number: +``` + +**Course Mappings:** +- BANA 4080 → `bana-4080` profile (inherits from `intro-to-data-mining`) - Undergraduate +- BANA 6043 → `bana-6043` profile (inherits from `statistical-computing`) - Graduate +- BANA 7075 → `bana-7075` profile (inherits from `ml-in-business`) - Graduate + +Load the appropriate course profile and, for BANA 4080, also load the `lab-template-guide` skill. + +### Step 2: Chapter Input + +Ask which chapters the lab should reinforce: + +``` +Which chapters should this lab reinforce? +(Provide chapter numbers or names, e.g., "Chapters 7-9" or "Control Flow, Functions") +``` + +Read the specified chapters if available to analyze content. + +### Step 3: Topic Confirmation + +Based on the chapters, analyze and present planned topics: + +``` +Based on [chapters specified], I plan to cover these topics: +- [Topic 1 identified from chapter analysis] +- [Topic 2 identified from chapter analysis] +- [Topic 3 identified from chapter analysis] +[- Additional topics as appropriate] + +[1] Accept these topics +[2] Add or modify topics + +Please select an option: +``` + +If option [2], ask: +``` +Please specify additional topics to include or modifications: +``` + +### Step 4: Dataset Strategy + +Present the dataset plan and ask for confirmation: + +``` +Dataset plan: +- Part A (guided reinforcement): [Primary dataset from chapter readings] +- Part B (independent challenges): [Dataset from end-of-chapter exercises] + +[1] Accept these datasets +[2] Specify alternative datasets + +Please select an option: +``` + +If option [2], ask: +``` +Please specify which datasets to use: +- Part A dataset: +- Part B dataset: +``` + +### Step 5: Week Number + +Ask what week this lab is for: + +``` +What week number is this lab for? +(Used for filename: XX_wkX_lab.ipynb) +``` + +### Step 6: Save Location + +Detect if a `lab/` or `labs/` directory exists in the current working directory or nearby. Present options: + +``` +Where should I save the lab notebook? + +[Suggested path: /path/to/lab/] + +Please provide the directory path (or press Enter to use suggested path): +``` + +### Step 7: Generate Lab + +**For BANA 4080 labs:** +1. Read the template file at `/Users/b294776/Desktop/UC/uc-bana-4080/planning/templates/lab_notebook_template.ipynb` +2. Follow the structure exactly as defined in the template +3. Replace all `[PLACEHOLDERS]` with appropriate content based on: + - Chapters/readings specified + - Topics confirmed + - Datasets selected + - Week number + - Course profile and lab-template-guide +4. Ensure the 75-minute structure: + - Part A: ~30 minutes of guided reinforcement + - Class Q&A: ~5-10 minutes + - Part B: ~35-40 minutes of independent challenges (6 challenges) + - Wrap-up: ~3-5 minutes +5. Include: + - Clear learning objectives (3-4 items) + - Business context for all concepts + - Step-by-step instructions for Part A + - Progressive challenges for Part B (no starter code, no AI) + - Reflection questions + - Troubleshooting section +6. Save as `XX_wkX_lab.ipynb` in specified directory + +**For BANA 6043 and 7075 labs:** +1. Use the general lab template structure from `content-templates/templates.md` +2. Adapt to graduate level and course-specific context +3. Follow course profile standards +4. Save in specified directory + +### Step 8: Completion Message + +Display success message with reminder about TA guide: + +``` +✅ Lab notebook created successfully! + +Location: [full path to created file] + +Next steps: +1. Review the lab notebook and make any necessary edits +2. When ready, use `/course-builder:create-ta-guide` to create the TA guidance notebook + +The TA guidance notebook will include: +- Complete solutions for all challenges +- Teaching guidance for Part A sections +- Common student difficulties and hints +- Timing and facilitation strategies +``` + +## What the Agent Does + +The course-architect agent will: + +**Planning Phase:** +- Load appropriate course profile based on selection +- For BANA 4080: Load lab-template-guide skill +- Analyze specified chapters to extract key concepts +- Identify topics requiring hands-on practice +- Determine appropriate datasets from chapter content +- Confirm all details with user using numbered options + +**Content Creation Phase:** +- For BANA 4080: Read and use the actual template file +- Generate lab following the exact structure required +- Fill all placeholders with specific, contextual content +- Create Part A with guided examples and "Your Turn" exercises +- Create Part B with 6 progressive business-focused challenges +- Include appropriate scaffolding for student level +- Add business context to every concept and exercise +- Ensure timing estimates are realistic + +**Quality Assurance:** +- Verify all placeholders are replaced +- Ensure learning objectives align with activities +- Confirm business context is present throughout +- Validate structure matches template requirements +- Check that timing adds up to 75 minutes (for BANA 4080) + +## Course-Specific Requirements + +### BANA 4080 (Undergraduate) +- **Template:** Must use the provided template file exactly +- **Structure:** Part A (30 min) + Q&A (5-10 min) + Part B (35-40 min) + Wrap-up (3-5 min) +- **Part A:** Guided reinforcement with TA leading students +- **Part B:** 6 independent group challenges with NO starter code, NO AI tools +- **Tone:** Encouraging, accessible, builds confidence +- **Examples:** Relatable business scenarios for beginners +- **TA Guide Required:** Yes, created separately with `/course-builder:create-ta-guide` + +### BANA 6043 & 7075 (Graduate) +- **Structure:** Flexible based on course needs +- **Tone:** More formal, assumes stronger technical background +- **Examples:** Advanced business applications, research scenarios +- **Complexity:** Higher mathematical rigor and conceptual depth +- **TA Guide:** Optional, based on instructor preference + +## Skills Available to Agent + +The agent has access to: +- **pedagogy**: General teaching principles for data science +- **content-templates**: Lab notebook structure patterns +- **courses/bana-4080**: BANA 4080 course profile and lab-template-guide +- **courses/bana-6043**: BANA 6043 course profile +- **courses/bana-7075**: BANA 7075 course profile +- **courses/intro-to-data-mining**: Base profile for BANA 4080 +- **courses/statistical-computing**: Base profile for BANA 6043 +- **courses/ml-in-business**: Base profile for BANA 7075 + +## Output + +A complete Jupyter notebook (.ipynb format) including: +- Professional header with learning objectives +- Setup and data loading +- Guided learning sections (Part A for BANA 4080) +- Independent practice/challenges (Part B for BANA 4080) +- Business context throughout +- Reflection and wrap-up +- Troubleshooting section +- Appropriate complexity for student level +- Realistic time estimates + +**Note:** The TA guidance notebook is created separately using the `/course-builder:create-ta-guide` command after the instructor reviews and approves the student lab notebook. diff --git a/commands/create-module-overview.md b/commands/create-module-overview.md new file mode 100644 index 0000000..ead6a31 --- /dev/null +++ b/commands/create-module-overview.md @@ -0,0 +1,287 @@ +--- +description: Create a Canvas module overview document +--- + +# Create Module Overview + +Generate a Canvas module overview document that summarizes the week's learning objectives, content, and activities. + +## Interactive Workflow + +This command uses a numbered-option interactive workflow to gather requirements and create the module overview. + +### Step 1: Course Selection + +Ask the user which course this module overview is for: + +``` +Which course is this module overview for? + +[1] BANA 4080 (Intro to Data Mining - Undergraduate) +[2] BANA 6043 (Statistical Computing - Graduate) +[3] BANA 7075 (ML in Business - Graduate) + +Please select an option by number: +``` + +Load the appropriate course profile. + +### Step 2: Module Number + +Ask what module/week this overview is for: + +``` +What module/week number is this overview for? +(e.g., 4, 6, 10) +``` + +### Step 3: Content References + +Ask which content materials to include: + +``` +Which chapters should be referenced for this module? +(Provide chapter numbers or names, e.g., "Chapters 7-9" or "Control Flow, Functions") +``` + +Then ask: + +``` +Path to Tuesday lecture slides (or description of lecture topics): +(Press Enter to skip if not available) +``` + +Then ask: + +``` +Path to Thursday lab notebook (or description of lab activities): +(Press Enter to skip if not available) +``` + +### Step 4: Analyze Content + +Read and analyze the provided materials: +- If chapter paths are provided, read the chapters to extract learning objectives and key concepts +- If slide path is provided, read the slides to understand lecture structure +- If lab path is provided, read the lab to understand hands-on activities +- Extract module title from content (e.g., "Control Flow, Iteration, and Functions") +- Identify learning objectives (aim for 5-8 measurable objectives) +- Extract key concepts and skills for "What You'll Learn This Week" +- Summarize Tuesday lecture and Thursday lab activities + +### Step 5: Supplemental Files + +Ask about supplemental files: + +``` +Are there any supplemental files or materials to include? +(e.g., companion notebooks, example code, additional resources) + +[1] No, leave as "TBD" +[2] Yes, I'll provide details + +Please select an option: +``` + +If option [2], ask: + +``` +Please list the supplemental files and materials to include: +(e.g., "Chapter 23 Logistic Regression Notebook: link", "Reading Quiz: Available Monday-Wednesday") +``` + +### Step 6: Generate Overview + +Using the template at `/Users/b294776/Desktop/UC/uc-bana-4080/planning/templates/module_overview_template.md`, generate the module overview by: + +1. Reading the template file +2. Replacing all `{PLACEHOLDERS}` with content extracted from analysis: + - `{MODULE_NUMBER}` - Week/module number + - `{MODULE_TITLE}` - Descriptive title extracted from content + - `{MODULE_TOPIC_BLURB}` - 2-3 paragraph overview connecting technical content to business context + - `{LEARNING_OBJECTIVE_X}` - Specific, measurable learning objectives (5-8 items) + - `{KEY_POINT_X}` - Concise bullets highlighting skills/concepts from "What You'll Learn" + - `{TUESDAY_LECTURE_TITLE}` - Title of Tuesday's lecture + - `{TUESDAY_LECTURE_ACTIVITIES}` - 2-4 bullets describing lecture activities + - `{THURSDAY_LAB_TITLE}` - Title of Thursday's lab + - `{THURSDAY_LAB_ACTIVITIES}` - 2-4 bullets describing lab activities + - Supplemental files section (TBD or user-provided content) + +3. Ensure tone is: + - Approachable and practical + - Business-focused + - Encouraging + - Concrete with specific examples + +4. Remove all HTML comments and guidance text from the final output + +### Step 7: Present Draft + +Display the complete generated overview to the user: + +``` +Here's the proposed module overview: + +─────────────────────────────────────────── +[Full generated overview text] +─────────────────────────────────────────── + +Does this look good? + +[1] Yes, save this overview +[2] No, I'd like to make changes + +Please select an option: +``` + +If option [2], ask: + +``` +What changes would you like me to make? +``` + +Then regenerate with the requested changes and present again. + +### Step 8: Save Location + +When user accepts the overview, ask where to save: + +``` +Where should I save the module overview? + +[Suggested: /Users/b294776/Desktop/UC/uc-bana-4080/planning/canvas_docs/] + +Please provide the directory path (or press Enter to use suggested path): +``` + +Then ask for filename: + +``` +What should I name the file? +[Suggested: week{X}_overview.md] + +Please provide the filename (or press Enter to use suggested name): +``` + +Save the file and display confirmation. + +### Step 9: Completion Message + +``` +✅ Module overview created successfully! + +Location: [full path to created file] + +The overview includes: +- Module topic introduction with business context +- {X} learning objectives +- "What You'll Learn This Week" summary +- Tuesday lecture and Thursday lab descriptions +- Supplemental files section + +Next steps: +- Review the overview in your editor +- Copy and paste into Canvas module page +- Add any course-specific formatting or links +``` + +## What the Agent Does + +The course-architect agent will: + +**Analysis Phase:** +- Load appropriate course profile +- Read and analyze provided chapters, slides, and lab materials +- Extract key learning objectives from content +- Identify core concepts and skills +- Understand Tuesday lecture structure and activities +- Understand Thursday lab structure and activities + +**Content Generation:** +- Read the module overview template +- Generate engaging 2-3 paragraph module topic introduction +- Create 5-8 specific, measurable learning objectives +- Write concise, business-focused "What You'll Learn" bullets +- Summarize Tuesday lecture activities (2-4 bullets) +- Summarize Thursday lab activities (2-4 bullets) +- Include supplemental files if provided +- Maintain consistent structure across all weeks + +**Quality Assurance:** +- Ensure tone is approachable and business-focused +- Verify all placeholders are replaced +- Check that learning objectives are measurable +- Confirm activities are described concretely +- Remove all guidance comments +- Present for user review before saving + +## Course-Specific Requirements + +### BANA 4080 (Undergraduate) +- **Template:** Must use the provided template exactly +- **Tone:** Approachable, encouraging, practical +- **Business Context:** Strong emphasis on real-world business applications +- **Examples:** Concrete, relatable scenarios (customer data, marketing, retail) +- **Structure:** Consistent week-to-week format for Canvas + +### BANA 6043 & 7075 (Graduate) +- **Tone:** More formal but still engaging +- **Business Context:** Advanced applications, research scenarios +- **Examples:** Complex business problems, industry case studies +- **Structure:** Adapt template to graduate-level expectations + +## Template Structure + +The overview follows this structure: + +1. **Module Title**: Module X Overview: [Topic] +2. **Module Topic**: 2-3 paragraphs connecting technical content to business context +3. **Learning Objectives** (🎯): 5-8 measurable objectives with action verbs +4. **What You'll Learn This Week** (✅): Concise bullet list of key concepts/skills +5. **How You'll Practice** (🛠): Tuesday lecture + Thursday lab descriptions +6. **Lectures & Other Supplemental Files** (📂): Readings, assessments, notebooks, links + +## Key Principles + +**Content Extraction:** +- Learning objectives should align with chapter/lecture/lab content +- "What You'll Learn" should be concrete and specific +- Practice activities should emphasize hands-on application +- Business relevance should be clear throughout + +**Writing Style:** +- Use active voice and action verbs +- Keep examples concrete and relatable +- Emphasize practical application over theory +- Maintain encouraging, supportive tone +- Connect concepts to career skills + +**Quality Checks:** +- All placeholders filled with specific content +- No generic or vague statements +- Business context present throughout +- Consistent with course profile tone and standards +- User reviewed and approved before saving + +## Skills Available to Agent + +The agent has access to: +- **pedagogy**: General teaching principles for data science +- **content-templates**: Template structures and patterns +- **courses/bana-4080**: BANA 4080 course profile and standards +- **courses/bana-6043**: BANA 6043 course profile +- **courses/bana-7075**: BANA 7075 course profile + +## Output + +A complete markdown file ready for Canvas with: +- Professional module overview with business context +- Clear, measurable learning objectives (5-8 items) +- Concise "What You'll Learn" summary +- Detailed descriptions of Tuesday and Thursday activities +- Supplemental files section (TBD or populated) +- Consistent formatting and structure +- User-reviewed and approved content +- No template comments or guidance text + +The overview should be immediately usable in Canvas with minimal additional editing. diff --git a/commands/create-quiz.md b/commands/create-quiz.md new file mode 100644 index 0000000..812a907 --- /dev/null +++ b/commands/create-quiz.md @@ -0,0 +1,215 @@ +--- +description: Create a reading comprehension quiz based on chapter content +--- + +# Create Quiz + +Generate a reading comprehension quiz to test student understanding of textbook chapter(s). + +## Purpose + +Creates "reading quizzes" that verify students comprehended key concepts from assigned chapter readings. These quizzes focus on understanding, not memorization, and use business scenarios to bring concepts to life. + +## Process + +1. **Invoke the course-architect agent** to create the quiz +2. The agent will: + - Ask which course this quiz is for + - Load the appropriate course profile + - **Ask which chapter(s) to base the quiz on** (e.g., "Chapter 5: Data Visualization") + - **Confirm the number of questions** (default: 10 questions, but allow customization) + - **Ask for the week number** (e.g., "Week 9") for filename generation + - **Ask where to save the quiz** (provide default based on course, allow customization) + - Read the specified chapter(s) to understand content and learning objectives + - Generate quiz questions that: + - Test comprehension of key concepts from the reading + - Include business scenario-based questions + - Use appropriate question types (multiple choice, true/false, multiple answer, numeric entry) + - Match the course's pedagogical style + - **Save the quiz** as a markdown file to the specified location + +## Quiz Structure + +Each quiz question must include: + +1. **Question Number and Title** (e.g., "Question 3: Linear Regression Coefficients") +2. **Question Type** (Multiple Choice, TRUE/FALSE, Multiple Answer, or Numeric Entry) +3. **Scenario** (for scenario-based questions) - Business context that applies the concept +4. **Question** - Clear, specific question text +5. **Answer Options** - Varies by question type: + - Multiple Choice: 4 options (A, B, C, D) + - TRUE/FALSE: 2 options (A: TRUE, B: FALSE) + - Multiple Answer: 4-5 options with instruction to "Select ALL correct" + - Numeric Entry: Blank for student to fill in, with acceptable answer range/precision +6. **Correct Answer** - Clearly identified with precision requirements for numeric entries +7. **Tip/Hint** - Helpful guidance for wrong answers that: + - Doesn't give away the answer + - Points to the key concept they need to reconsider + - Helps them think through the problem + - References relevant parts of the reading + - For numeric questions: points to the calculation method or formula needed + +## Question Types Distribution + +For a typical 10-question quiz: +- **5-6 Multiple Choice** questions (standard comprehension + scenario-based) +- **2-3 TRUE/FALSE** questions (test common misconceptions) +- **1-2 Multiple Answer** questions (select ALL correct - tests nuanced understanding) +- **0-2 Numeric Entry** questions (test calculation/application skills) + +**Important:** Mix scenario-based questions throughout. At least 40-50% of questions should use business scenarios. + +## What the Agent Does + +The course-architect will: +- Read the specified chapter(s) to extract key concepts and learning objectives +- Create questions that test understanding, not just recall +- Write realistic business scenarios that apply the concepts +- Ensure questions match the course's student level and style +- Provide helpful tips that guide thinking without revealing answers +- Balance question types and difficulty +- Avoid questions that are too easy (pure recall) or too trick-y + +The agent has access to skills for: +- **pedagogy**: Assessment design principles (test understanding, not memorization) +- **content-templates**: Quiz format templates +- **courses/{course-name}**: Course-specific context, student level, and learning philosophy + +## Output Format + +A complete quiz markdown file including: + +```markdown +# Week [X] Quiz: [Topic Name] + +**Instructions:** This quiz tests your comprehension of Week [X] material including [key topics]. Choose the best answer(s) for each question. + +--- + +## Question 1: [Concept Name] ([Question Type]) + +**Scenario:** [Business scenario if applicable] + +[Question text] + +A) [Option A] +B) [Option B] +C) [Option C] +D) [Option D] + +**Correct Answer:** [Letter] + +**Tip for wrong answers:** [Helpful guidance that doesn't reveal the answer] + +--- + +[Repeat for remaining questions] +``` + +## Example Question Patterns + +**Scenario-Based Multiple Choice:** +``` +## Question 5: Model Evaluation (Multiple Choice) + +**Scenario:** A retail analytics team builds a sales forecasting model. +Training RMSE is $450, but Test RMSE is $1,200. + +What does this suggest? +A) The model is ready for deployment +B) The model is overfitting +C) The model is underfitting +D) The test data is bad + +**Correct Answer:** B + +**Tip:** Consider what a large gap between training and test performance indicates about how well the model generalizes to new data. +``` + +**Concept Application TRUE/FALSE:** +``` +## Question 2: Correlation vs. Causation (TRUE/FALSE) + +**Statement:** If advertising spend and sales have correlation 0.85, +we can conclude advertising causes sales increases. + +A) TRUE +B) FALSE + +**Correct Answer:** B + +**Tip:** Remember that correlation measures association, not causation. +What other factors might explain both variables moving together? +``` + +**Numeric Entry:** +``` +## Question 8: Calculate Correlation (Numeric Entry) + +**Scenario:** A marketing analyst calculates the covariance between +advertising spend and sales as 1,200. The standard deviation of +advertising spend is 30 and the standard deviation of sales is 50. + +What is the correlation coefficient? (Round to 2 decimal places) + +Answer: ______ + +**Correct Answer:** 0.80 + +**Acceptable Range:** 0.79 to 0.81 + +**Tip:** Remember the formula: correlation = covariance / (SD of X × SD of Y). +Make sure you're dividing, not multiplying the standard deviations. +``` + +**Multiple Answer:** +``` +## Question 10: Regression Assumptions (Multiple Answer - Select ALL correct) + +Which of these are key assumptions of linear regression? + +A) The relationship between predictors and outcome is linear +B) The residuals (errors) are normally distributed +C) All predictor variables must be normally distributed +D) The variance of residuals is constant +E) Residuals are independent of each other + +**Correct Answers:** A, B, D, E + +**Tip:** Linear regression doesn't require predictor variables to be normally +distributed, only that the residuals follow a normal distribution. +``` + +## Save Location + +The agent will ask where to save the quiz and provide a course-specific default: + +**For Intro to Data Mining (BANA 4080):** +- Default: `/Users/b294776/Desktop/UC/uc-bana-4080/planning/quizzes/` +- Filename format: `week[X]_quiz.md` (e.g., `week9_quiz.md`) + +**For other courses:** +- The agent will suggest an appropriate location based on the course profile +- Always confirm the save location before writing the file + +**After generation:** +1. Show the user the complete quiz content +2. Confirm the save location and filename +3. Use the Write tool to save the file +4. Confirm successful save to the user + +## Important Notes + +- **Chapter-driven:** Always ask which chapter(s) to base the quiz on +- **Week number:** Ask for the week number to create proper filename +- **Confirm quantity:** Ask to confirm 10 questions (or get desired number) +- **Scenario-based:** Mix business scenarios throughout (40-50% of questions) +- **Helpful tips:** Guide thinking, don't reveal answers +- **Course-appropriate:** Match student level and course style +- **Question type variety:** Use all four types (Multiple Choice, TRUE/FALSE, Multiple Answer, Numeric Entry) +- **Numeric precision:** For numeric entry questions, always specify: + - Required precision (e.g., "rounded to 1 decimal place") + - Acceptable answer range to account for rounding differences + - Clear calculation context from the scenario +- **No coding questions:** Reading quizzes test conceptual understanding and calculations, not coding ability +- **Save workflow:** Always confirm save location and filename before writing the file diff --git a/commands/create-slides.md b/commands/create-slides.md new file mode 100644 index 0000000..f488a49 --- /dev/null +++ b/commands/create-slides.md @@ -0,0 +1,265 @@ +--- +description: Create presentation slides for a lecture +--- + +# Create Slides + +Generate presentation slides for teaching a course topic using the Quarto RevealJS format. + +## Interactive Workflow + +This command uses a numbered-option interactive workflow to gather requirements and create lecture slides. + +### Step 1: Course Detection + +Automatically detect the course based on the current working directory path: + +- Check if the path contains `uc-bana-4080` → BANA 4080 +- Check if the path contains `uc-bana-6043` → BANA 6043 +- Check if the path contains `uc-bana-7075` → BANA 7075 + +**If course detected:** +``` +Detected course: BANA [X] from directory path +Proceeding with [Course Name]... +``` + +**If no course detected:** +``` +Unable to detect course from directory path. + +Which course are these slides for? + +[1] BANA 4080 (Intro to Data Mining - Undergraduate) +[2] BANA 6043 (Statistical Computing - Graduate) +[3] BANA 7075 (ML in Business - Graduate) + +Please select an option by number: +``` + +Load the appropriate course profile. + +### Step 2: Chapter Input + +Ask which chapters the slides should cover: + +``` +Which chapters should these slides cover? +(Provide chapter numbers or names, e.g., "Chapters 7-9" or "Control Flow, Functions") +``` + +Read the specified chapters if available to analyze content and extract key concepts. + +### Step 3: Week Number + +Ask what week these slides are for: + +``` +What week number are these slides for? +(Used for filename: w[X]_tuesday.qmd) +``` + +### Step 4: Dataset Confirmation + +Present the dataset plan: + +``` +Dataset plan for demonstrations: +I'll use the primary dataset from the chapter readings for live coding examples. + +[1] Accept this dataset +[2] Specify a different dataset + +Please select an option: +``` + +If option [2], ask: +``` +Please specify which dataset to use for demonstrations: +``` + +### Step 5: Present Slide Outline + +Analyze the chapters and present a proposed outline: + +``` +Based on [chapters specified], here's the proposed slide outline: + +Opening & Agenda (5 minutes) +├── Week overview and learning objectives +└── Connection to course progression + +Review & Warm-Up (10-15 minutes) +├── Previous week concept review +└── Think-pair-share connection activity + +Main Content (35-45 minutes) +├── [Concept 1 Title] +│ └── Interactive Activity: [Activity description] +├── [Concept 2 Title] +│ └── Hands-On Demo: [Demo description] +└── [Concept 3 Title] + └── Interactive Activity: [Activity description] + +Wrap-Up (10-15 minutes) +├── Key takeaways +├── Thursday lab preview +└── Q&A + +[1] Accept this outline and generate slides +[2] Request changes to outline + +Please select an option: +``` + +If option [2], ask: +``` +What changes would you like to make to the outline? +``` + +Then regenerate the outline and present again. + +### Step 6: Save Location + +When user accepts the outline, ask where to save: + +``` +Where should I save the slides? + +[Suggested: Look for slides/ directory or current working directory] + +Please provide the directory path (or press Enter to use suggested path): +``` + +### Step 7: Generate Slides + +**For BANA 4080 slides:** +1. Read the template file at `/Users/b294776/Desktop/UC/uc-bana-4080/planning/templates/tuesday_slide_template.qmd` +2. Follow the structure exactly as defined in the template +3. Replace all `[PLACEHOLDERS]` with appropriate content based on: + - Chapters/readings specified + - Week number + - Dataset selected + - Course profile requirements +4. Create interactive think-pair-share activities (3-4 minimum) +5. Include hands-on demonstrations with business context +6. Add appropriate timers with unique IDs +7. Generate visualizations using Mermaid diagrams or Python code where applicable +8. Save as `w[X]_tuesday.qmd` in specified directory + +**For BANA 6043 and 7075 slides:** +1. Use general slide template structure from `content-templates/templates.md` +2. Adapt to graduate level and course-specific context +3. Follow course profile standards +4. Save in specified directory + +### Step 8: Post-Generation Notes + +After saving the slides, provide notes about elements requiring attention: + +``` +✅ Slides created successfully! + +Location: [full path to created file] + +📋 Action Items: +The following elements may need your attention: + +Images Needed: +- [List any image placeholders with slide numbers] +- Suggested sources: Create with Mermaid, generate with Python, or source from [suggestions] + +Visualizations Created: +- [List Mermaid diagrams or Python-generated visualizations included] + +Custom Content: +- [Any sections that may need customization based on specific context] + +Next steps: +1. Review the slides in your editor +2. Add or create any required images +3. Test render the .qmd file to HTML +4. Review interactive elements and timers +``` + +## What the Agent Does + +The course-architect agent will: + +**Analysis Phase:** +- Load appropriate course profile based on selection +- Read and analyze specified chapters to extract key concepts +- Identify 3-4 core concepts for gentle introduction +- Map business applications and real-world relevance +- Plan hands-on demonstration opportunities + +**Outline Design Phase:** +- Design 3-4 think-pair-share activities with business scenarios +- Create 1-2 hands-on demonstrations for immediate success +- Develop progressive concept flow from familiar to sophisticated +- Plan Thursday lab connections and motivation +- Present outline for user approval + +**Content Generation Phase:** +- For BANA 4080: Read and use the actual template file +- Generate slides following the exact structure required +- Fill all placeholders with specific, contextual content +- Create business scenarios that students find relatable +- Develop code demonstrations (using chapter datasets) +- Design timer activities with unique IDs +- **Prefer Mermaid diagrams or Python-generated visualizations** over external images +- Add speaker notes for instructor guidance + +**Quality Assurance:** +- Verify all placeholders are replaced +- Ensure 3-4 interactive activities included +- Confirm business context is present throughout +- Validate structure matches template requirements +- Check that timing adds up to 60-75 minutes +- Note any image placeholders that need attention + +## Course-Specific Requirements + +### BANA 4080 (Undergraduate) +- **Template:** Must use the provided template file exactly +- **Duration:** 60-75 minutes total +- **Structure:** Opening (5 min) + Review (10-15 min) + Main Content (35-45 min) + Wrap-Up (10-15 min) +- **Interactive Activities:** Minimum 3-4 think-pair-share activities with timers +- **Hands-On Demos:** 1-2 live coding demonstrations using chapter datasets +- **Tone:** Gentle introduction, business-focused, success-oriented +- **Philosophy:** First exposure to concepts before readings and Thursday lab +- **Visualizations:** Prefer Mermaid diagrams and Python-generated charts + +### BANA 6043 & 7075 (Graduate) +- **Structure:** Flexible based on course needs +- **Tone:** More formal, assumes stronger technical background +- **Examples:** Advanced business applications, research scenarios +- **Complexity:** Higher mathematical rigor and conceptual depth + +## Skills Available to Agent + +The agent has access to: +- **pedagogy**: Presentation and lecture design principles, gentle introduction strategies +- **content-templates**: Slide structure patterns +- **courses/bana-4080**: BANA 4080 course profile and standards +- **courses/bana-6043**: BANA 6043 course profile +- **courses/bana-7075**: BANA 7075 course profile + +## Output + +A complete Quarto RevealJS presentation (.qmd format) including: +- YAML header with RevealJS configuration +- Professional title slide with background image +- Opening and agenda slides +- Previous week review section with interactive activity +- Main content sections with business context +- Interactive think-pair-share activities with timers +- Hands-on demonstrations with code +- Mermaid diagrams or Python-generated visualizations (preferred over external images) +- Key takeaways and Thursday lab preview +- Wrap-up and Q&A slides +- Speaker notes for instructor guidance +- Appropriate complexity for student level +- Realistic time estimates (60-75 minutes total) + +**Post-Generation Notes:** The agent will provide a list of any image placeholders, visualization elements created, and items requiring instructor attention before finalizing the slides. diff --git a/commands/create-ta-guide.md b/commands/create-ta-guide.md new file mode 100644 index 0000000..b2ebff2 --- /dev/null +++ b/commands/create-ta-guide.md @@ -0,0 +1,202 @@ +--- +description: Create TA guidance notebook with solutions and teaching strategies +--- + +# Create TA Guidance Notebook + +Generate a comprehensive TA guidance notebook that provides complete solutions, teaching strategies, and facilitation guidance for a student lab notebook. + +## Interactive Workflow + +### Step 1: Locate Student Lab + +Ask for the path to the student lab notebook: + +``` +Please provide the path to the student lab notebook: +(e.g., /path/to/labs/06_wk6_lab.ipynb) +``` + +Read the student lab notebook to analyze its structure and content. + +### Step 2: Identify Course + +Based on the lab structure or ask the user: + +``` +Which course is this TA guide for? + +[1] BANA 4080 (Intro to Data Mining - Undergraduate) +[2] BANA 6043 (Statistical Computing - Graduate) +[3] BANA 7075 (ML in Business - Graduate) + +Please select an option by number: +``` + +Load the appropriate course profile. + +### Step 3: Extract Week Number + +Extract the week number from the filename (e.g., `06_wk6_lab.ipynb` → week 6) or ask: + +``` +What week is this lab for? +(Used for filename: ta_guidance_wkX.ipynb) +``` + +### Step 4: Generate TA Guide + +Create a comprehensive TA guidance notebook with: + +**Section 1: Pre-Lab Preparation** +- Overview of learning objectives +- Key concepts from the lab +- Connection to readings/lectures +- Required setup and materials +- Common technical issues to anticipate +- Grouping strategies (for BANA 4080) + +**Section 2: Part A Teaching Guidance** (for BANA 4080) +For each section in Part A: +- Teaching objectives for the section +- Time allocation +- Key points to emphasize +- Demonstration strategies +- Common student questions and suggested answers +- Transition techniques to next section + +**Section 3: Part B Solutions and Facilitation** (for BANA 4080) +For each of the 6 challenges: +- Challenge overview and learning goal +- Complete, well-commented solution code +- Alternative approaches students might take +- Common errors and debugging strategies +- Hints to provide (when and how) +- Discussion points for concept reinforcement +- Extension ideas for advanced students + +**Section 4: Timing and Pacing Strategies** +- Detailed timing breakdown +- What to do if running ahead/behind +- How to manage different group paces +- When to call class back together +- Transition management + +**Section 5: Assessment and Wrap-up** +- Key concepts students should have mastered +- Reflection questions to ask +- Connections to upcoming content/homework +- What to look for when monitoring student work + +**Section 6: Troubleshooting Guide** +- Common technical issues and solutions +- Conceptual difficulties and how to address +- Group dynamics issues +- Backup plans for major problems + +### Step 5: Save Location + +Suggest saving in the same directory as the student lab: + +``` +Where should I save the TA guidance notebook? + +[Suggested: same directory as student lab] + +Please provide the directory path (or press Enter to use suggested path): +``` + +Save as `ta_guidance_wkX.ipynb` + +### Step 6: Completion Message + +``` +✅ TA guidance notebook created successfully! + +Location: [full path to created file] + +The TA guidance includes: +- Pre-lab preparation guidance +- Part A teaching strategies (section-by-section) +- Part B complete solutions (all challenges) +- Timing and pacing strategies +- Troubleshooting guide + +Review the guidance and customize as needed for your teaching style. +``` + +## What the Agent Does + +The course-architect agent will: + +**Analysis Phase:** +- Read and analyze the student lab notebook +- Identify all exercises, challenges, and learning objectives +- Extract the lab structure (Part A sections, Part B challenges) +- Load appropriate course profile + +**Solution Development:** +- Create complete, tested solutions for all challenges +- Write well-commented code explaining each step +- Identify alternative valid approaches +- Document common errors and misconceptions + +**Teaching Guidance Creation:** +- Develop section-by-section teaching strategies for Part A +- Provide timing guidance and pacing strategies +- Suggest when and how to provide hints +- Create discussion prompts and check-in questions + +**Quality Assurance:** +- Ensure all solutions are complete and tested +- Verify timing estimates are realistic +- Confirm guidance covers common student difficulties +- Check that facilitation strategies are practical + +## Course-Specific Requirements + +### BANA 4080 (Undergraduate) + +**Structure:** Must include all sections listed above + +**Part A Guidance Should Include:** +- Step-by-step teaching script for each section +- What to write/show on screen +- Questions to ask students to check understanding +- How to explain concepts in accessible language +- When to have students try on their own + +**Part B Solutions Should Include:** +- Complete working code for all 6 challenges +- Multiple approaches where applicable +- Common mistakes students make +- Strategic hints (not full solutions) to provide +- When to intervene vs. let groups struggle productively +- Discussion points after each challenge + +**Timing Guidance:** +- Detailed breakdown matching the 75-minute structure +- Flexibility strategies for different pacing +- What to skip if running behind +- Extension activities if running ahead + +### BANA 6043 & 7075 (Graduate) + +**Structure:** More flexible, focus on: +- Complete solutions to all exercises +- Advanced discussion topics +- Connections to research or industry applications +- Optional: Teaching strategies if lab is TA-led + +## Output + +A comprehensive Jupyter notebook (.ipynb format) including: +- Complete solutions to all lab exercises and challenges +- Teaching strategies for guided sections +- Timing and pacing guidance +- Common student difficulties and how to address them +- Facilitation strategies for group work +- Troubleshooting guide +- Discussion prompts and assessment questions + +The TA guide should be a complete resource that allows a TA to effectively facilitate the lab session even if they haven't taught it before. diff --git a/commands/review-chapter.md b/commands/review-chapter.md new file mode 100644 index 0000000..c1625dd --- /dev/null +++ b/commands/review-chapter.md @@ -0,0 +1,296 @@ +--- +description: Reviews a textbook chapter for technical accuracy, clarity, tone, style, and grammar based on course standards. +--- + +# Review Textbook Chapter + +This command leverages the `course-architect` agent to perform a comprehensive review of a textbook chapter, ensuring it aligns with the specific course's pedagogical standards and style. + +The agent will analyze the chapter based on the detected or selected course profile and provide specific, actionable feedback on: +* Technical Accuracy (code & concepts) +* Clarity for Beginners (using course profile audience) +* Tone Alignment (encouraging, practical, conversational) +* Pedagogical Elements (use of callouts, examples, checks) +* Sentence Case Compliance (for markdown headings) +* Grammar and Flow + +## Interactive Workflow + +### Step 1: Course Detection and Selection + +Attempt to automatically detect the course based on the current working directory path. + +**Agent Action:** +* Get the current working directory path (e.g., using `pwd` in Bash). +* Check if the path contains `bana-4080`, `bana-6043`, or `bana-7075`. + +**If course detected:** +``` +Detected course: BANA [XXXX] based on the current directory. + +[1] Confirm BANA [XXXX] +[2] Select a different course + +Please select an option: +``` +If [1], proceed with the detected course. If [2], show the manual selection prompt below. + +**If no course detected OR user selects [2]:** +``` +Which course is this chapter for? + +[1] BANA 4080 (Intro to Data Mining - Undergraduate) +[2] BANA 6043 (Statistical Computing - Graduate) +[3] BANA 7075 (ML in Business - Graduate) + +Please select an option by number: +``` + +**Agent Action (Post-Selection):** +* Load the appropriate **course profile** (e.g., `intro-to-data-mining/course-profile.md`). +* Load the `pedagogy/teaching-principles.md` skill. + +### Step 2: Chapter Input + +Ask the user for the chapter content file: + +``` +Please provide the path to the chapter file (.qmd or .md) you want me to review: +(e.g., /path/to/book/chapter-5.qmd) +``` + +**Agent Action:** +* Read the full content of the specified file. + +### Step 3: Review and Generate Feedback + +The agent analyzes the entire chapter based on the loaded course profile and pedagogical principles. + +**Agent Actions:** +* Load relevant course context from the course profile +* Parse the chapter structure (headings, sections, code blocks, callouts) +* Evaluate against the following criteria: + +**Review Criteria:** + +1. **Technical Accuracy** + - Verify code examples run correctly and follow best practices + - Check that concepts are explained accurately + - Ensure libraries/functions are used appropriately + - Validate that examples align with the course's technical stack + +2. **Clarity for Beginners (Audience-Specific)** + - Assess whether explanations match the target audience level (from course profile) + - Check for assumed knowledge that hasn't been introduced + - Verify that jargon is either avoided or clearly defined + - Ensure examples build progressively in complexity + +3. **Tone Alignment** + - Verify the tone matches course standards (e.g., conversational, encouraging) + - Check that the chapter is practical and business-focused (if applicable) + - Ensure the writing is engaging and motivating + - Assess whether the chapter reduces anxiety and builds confidence + +4. **Pedagogical Elements** + - Verify presence of learning objectives + - Check for appropriate use of callouts (tips, warnings, notes) + - Assess quality and relevance of examples + - Verify inclusion of check-your-understanding questions + - Ensure proper spacing of practice opportunities + +5. **Sentence Case Compliance (Headings)** + - Check all markdown headings (##, ###, ####) use sentence case + - Flag any title case headings + - Provide specific examples of violations + +6. **Grammar and Flow** + - Check for grammatical errors + - Assess logical flow between sections + - Verify smooth transitions + - Check for consistency in terminology + +### Step 4: Present Feedback Report + +Display the comprehensive review to the user, structured by category. + +``` +Here is the review for [chapter-file.qmd], evaluated against BANA [XXXX] standards: + +## Overall Assessment + +[Summary paragraph providing high-level evaluation] + +----- + +## 1. Technical Accuracy + + * **Status:** [✅ Excellent / ⚠️ Needs Attention / ❌ Issues Found] + * **Feedback:** [Specific points with line numbers or section references] + +----- + +## 2. Clarity for Beginners (Audience: BANA [XXXX]) + + * **Status:** [✅ Excellent / ⚠️ Needs Attention / ❌ Issues Found] + * **Feedback:** [Specific points with examples] + +----- + +## 3. Tone Alignment (Target: [e.g., Conversational, Encouraging]) + + * **Status:** [✅ Excellent / ⚠️ Needs Attention / ❌ Issues Found] + * **Feedback:** [Specific points with examples] + +----- + +## 4. Pedagogical Elements + + * **Status:** [✅ Excellent / ⚠️ Needs Attention / ❌ Issues Found] + * **Feedback:** [Specific points about callouts, examples, exercises] + +----- + +## 5. Sentence Case Compliance (Headings) + + * **Status:** [✅ Compliant / ❌ Violations Found] + * **Feedback:** [List specific headings that need correction] + +----- + +## 6. Grammar and Flow + + * **Status:** [✅ Excellent / ⚠️ Needs Attention / ❌ Issues Found] + * **Feedback:** [Specific points about grammar or flow issues] + +----- + +What would you like to do with this feedback? + +[1] Save report as a GitHub Issue +[2] Address these issues now (edit chapter) +[3] Discard + +Please select an option: +``` + +### Step 5: Save as GitHub Issue (If user selects [1]) + +**Agent Action:** +1. Ask for confirmation on the repository (try to infer from the current directory's git remote). + ``` + I can create a GitHub issue in the repository associated with this directory: [repo name]. + + Issue Title Suggestion: "Chapter Review Feedback: [chapter-file.qmd]" + + [1] Create issue with this title in [repo name] + [2] Edit title before creating + [3] Cancel + ``` +2. If confirmed, format the feedback report from Step 4 into markdown suitable for a GitHub issue body. +3. **Create the GitHub issue** using the `gh` CLI tool via Bash: + ```bash + gh issue create --title "Chapter Review Feedback: [chapter-file.qmd]" --body "$(cat <<'EOF' + [Formatted feedback report] + EOF + )" + ``` +4. Display confirmation: `✅ GitHub issue created successfully at [link to issue]` or provide fallback instructions if `gh` is not available. + +### Step 6: Address Issues Now (If user selects [2]) + +**Agent Action:** +1. Ask how the user wants to proceed: + ``` + How would you like to address the feedback? + + [1] Address all issues sequentially (guided edits) + [2] Focus on specific issues (you tell me where to start) + [3] Try to address all issues at once (agent makes edits, you review) + [4] Cancel + + Please select an option: + ``` +2. **Based on selection:** + * **[1] Sequential:** + * Go through each feedback point category by category (e.g., starting with Technical Accuracy). + * For each issue within a category: + - State the specific issue + - Propose a fix + - Use the Edit tool to make the change to the chapter file + - Show the change to the user for approval + * Repeat for the next feedback category. + * **[2] Specific:** + * Ask the user: "Which feedback point (e.g., 'Clarity issue in Section 3.2' or 'Sentence case violation in heading') would you like to address first?" + * Follow the same process as Sequential, but only for the user-selected issues. + * **[3] All at Once:** + * Propose revising the entire chapter based on all feedback points + * Use the Edit tool or Write tool to make comprehensive changes + * Present a summary of changes made + * Ask user to review the updated chapter + * **[4] Cancel:** End the workflow. +3. After edits (if any) are completed: + ``` + ✅ Chapter edits based on feedback are complete. + + Would you like to: + [1] Review the chapter again to verify improvements + [2] Exit + ``` + +### Step 7: Discard (If user selects [3]) + +**Agent Action:** +* Display confirmation: `Feedback discarded. No changes made.` +* End the workflow. + +## What the Agent Does + +The course-architect agent will: + +**Analysis Phase:** +- Load appropriate course profile based on selection +- Read the entire chapter file +- Parse structure and identify all components (headings, code, callouts, etc.) +- Gather context about course standards and expectations + +**Review Phase:** +- Systematically evaluate each review criterion +- Document specific issues with location references (section names, line numbers) +- Assess severity of each issue +- Compile comprehensive feedback organized by category + +**Reporting Phase:** +- Present structured feedback report +- Provide status indicators for each category +- Include specific, actionable recommendations +- Guide user through post-review options + +**Action Phase (if user chooses to address feedback):** +- Make precise edits to the chapter file +- Maintain original formatting and structure +- Apply fixes based on the documented feedback +- Verify changes align with course standards + +## Skills Available to Agent + +The agent has access to: +- **pedagogy**: Teaching principles and pedagogical best practices +- **content-templates**: Chapter and content structure patterns +- **courses/bana-4080**: BANA 4080 course profile and standards +- **courses/bana-6043**: BANA 6043 course profile and standards +- **courses/bana-7075**: BANA 7075 course profile and standards + +## Output + +A comprehensive review report including: +- Overall assessment summary +- Detailed feedback across six key dimensions +- Specific examples and location references +- Status indicators (✅/⚠️/❌) for each category +- Actionable recommendations +- Interactive options for handling feedback (GitHub issue, immediate edits, or discard) + +**Post-Review Actions:** +- Optional GitHub issue creation with formatted feedback +- Optional guided editing workflow to address feedback +- Re-review capability to verify improvements diff --git a/commands/write-chapter.md b/commands/write-chapter.md new file mode 100644 index 0000000..971781d --- /dev/null +++ b/commands/write-chapter.md @@ -0,0 +1,45 @@ +--- +description: Write a textbook chapter for a data science course +--- + +# Write Chapter + +Create a textbook chapter tailored to a specific course's audience and learning objectives. + +## Process + +1. **Invoke the course-architect agent** to handle the chapter creation +2. The agent will: + - Ask which course this chapter is for + - Load the appropriate course profile + - Ask for the chapter topic + - Generate a chapter outline based on course standards + - Write the complete chapter with appropriate: + - Explanations at the right level + - Examples using course-appropriate tools + - Exercises and checkpoints + - Visual aids and code snippets (if applicable) + +## What the Agent Does + +The course-architect will: +- Adapt writing style to the student level (undergrad vs grad) +- Use the technical stack specified in the course profile +- Follow the course's pedagogical philosophy +- Structure content according to learning objectives +- Include hands-on examples appropriate for the course + +The agent has access to skills for: +- **pedagogy**: Data science teaching principles +- **content-templates**: Chapter structure templates +- **courses/{course-name}**: Course-specific context and standards + +## Output + +A complete markdown chapter ready to use in your textbook, including: +- Learning objectives +- Conceptual explanations +- Code examples (if applicable) +- Visualizations and diagrams +- Practice problems +- Summary and key takeaways diff --git a/plugin.lock.json b/plugin.lock.json new file mode 100644 index 0000000..45c4233 --- /dev/null +++ b/plugin.lock.json @@ -0,0 +1,113 @@ +{ + "$schema": "internal://schemas/plugin.lock.v1.json", + "pluginId": "gh:bradleyboehmke/brads-marketplace:course-builder", + "normalized": { + "repo": null, + "ref": "refs/tags/v20251128.0", + "commit": "4262d580a48c512ae9d3d2f54dda64364b846ffb", + "treeHash": "eab0156557f6b5c5f98c1cf02990b0107c51f21954c5e1476e09d1c95ba4b621", + "generatedAt": "2025-11-28T10:14:21.697613Z", + "toolVersion": "publish_plugins.py@0.2.0" + }, + "origin": { + "remote": "git@github.com:zhongweili/42plugin-data.git", + "branch": "master", + "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390", + "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data" + }, + "manifest": { + "name": "course-builder", + "description": "Tools for creating educational content for data science, ML, AI, and MLOps courses", + "version": "1.0.0" + }, + "content": { + "files": [ + { + "path": "README.md", + "sha256": "a90d645e37c0eb32e9308ad9c943409b1b441775d07e04b47871ed82cb008949" + }, + { + "path": "agents/course-architect.md", + "sha256": "30b18a92f320eeae4711f8ab359e8eb09bdb98499bbec144cc63dd002213792a" + }, + { + "path": ".claude-plugin/plugin.json", + "sha256": "ce80f00c42eeba6e3069ce96bed7fd86a09d4cd750b3789723212fbf5f972568" + }, + { + "path": "commands/create-module-overview.md", + "sha256": "6b8a69b7e3ae95e6b8e1baf5f93fa379cad6a455890396d5646001f060cb2861" + }, + { + "path": "commands/write-chapter.md", + "sha256": "d599fbd35d5c56a3ec4ef94dc8ed3b5f80054eb98cd1cd1cc17ae08121692411" + }, + { + "path": "commands/create-companion-nb.md", + "sha256": "c1481ef459867cff37dd245e2a24ee7c0f645dba8e66cc8234673f94007b09df" + }, + { + "path": "commands/review-chapter.md", + "sha256": "389627a189348652a99d99a3be0a082187367c8b95e5d39f6569434607dd89c9" + }, + { + "path": "commands/create-ta-guide.md", + "sha256": "ed1094a6daab72acf975cf22da8297f1cc9a70ebdd00b65a7b8980ca83599ffb" + }, + { + "path": "commands/create-lab-nb.md", + "sha256": "6bf2fe2ed64b1e3704fe3b8e7daa494557516d8a31d520a8891453f2efd3cabf" + }, + { + "path": "commands/create-quiz.md", + "sha256": "b784723bacfd2ea3fd7d1781976e1ee864be43e3f20cba271811cf705ffa3263" + }, + { + "path": "commands/create-slides.md", + "sha256": "d5238d5e43f1565e6304af0be33872c4a4bdfbc746a73d27b2ad4d333b228d5a" + }, + { + "path": "skills/pedagogy/teaching-principles.md", + "sha256": "1a1bed7797f45fc3ffdc18f6dd28feccce2e65b8819c4602c442dc2d1c23a8cd" + }, + { + "path": "skills/content-templates/templates.md", + "sha256": "677c1e3973b15909728c7f60a7b8cc6dc047b2ab03d2b9d77568653a575fc9ce" + }, + { + "path": "skills/courses/ml-in-business/course-profile.md", + "sha256": "7d45c2d95c9f44464f9044ec6eb1a34942d9dbd2b00c20f0f6ffe77bde05aaa0" + }, + { + "path": "skills/courses/bana-7075/course-profile.md", + "sha256": "819b4bc972fad118943d2230d7b21cbdde516522c5d8cffe6251a1acf7f02f4d" + }, + { + "path": "skills/courses/bana-6043/course-profile.md", + "sha256": "d9ed1c8ca4e21dadc1b1824e8f0aa44bc9d7664eddcb692ac37714d70e1c560a" + }, + { + "path": "skills/courses/intro-to-data-mining/course-profile.md", + "sha256": "2823a5a7fb0c407c4d5bb1e7554eb6fb90dd1fad8b97793ffd1f4d16ebafccea" + }, + { + "path": "skills/courses/bana-4080/lab-template-guide.md", + "sha256": "fa8f638edb3603fd1fb22546571eb4d4eba6f3f5335ea86a3587ffc9b8d884af" + }, + { + "path": "skills/courses/bana-4080/course-profile.md", + "sha256": "199ec56b513a384a66e215e4c78f6a00ec54e59cd653e0113b8847cdab8e9826" + }, + { + "path": "skills/courses/statistical-computing/course-profile.md", + "sha256": "fb6c6bc999b30f343a75e2b58098af845169b0f51f69aef5e238599d9027880b" + } + ], + "dirSha256": "eab0156557f6b5c5f98c1cf02990b0107c51f21954c5e1476e09d1c95ba4b621" + }, + "security": { + "scannedAt": null, + "scannerVersion": null, + "flags": [] + } +} \ No newline at end of file diff --git a/skills/content-templates/templates.md b/skills/content-templates/templates.md new file mode 100644 index 0000000..948c7be --- /dev/null +++ b/skills/content-templates/templates.md @@ -0,0 +1,348 @@ +# Content Templates + +Structural templates for different types of educational content. + +## Chapter Template + +```markdown +# Chapter [X]: [Topic Name] + +## Learning Objectives +By the end of this chapter, you will be able to: +- [Objective 1 - action verb + specific skill] +- [Objective 2] +- [Objective 3] + +## Introduction +[1-2 paragraphs motivating the topic] +- Why is this important? +- What real-world problems does it solve? +- How does it connect to previous chapters? + +## [Section 1: Core Concept] + +### Intuition +[Explain the concept using analogies or simple examples] + +### Formal Definition +[Mathematical or technical definition] + +### Example +[Concrete example with code if applicable] + +```python +# Code example +``` + +### Visualization +[Description of diagram or plot to include] + +## [Section 2: Application] +[Show how to use the concept] + +## [Section 3: Advanced Topics] +[Optional: deeper dive for interested students] + +## Practice Problems +1. [Problem testing basic understanding] +2. [Problem requiring application] +3. [Challenge problem] + +## Summary +- Key takeaway 1 +- Key takeaway 2 +- Key takeaway 3 + +## Further Reading +- [Resource 1] +- [Resource 2] +``` + +## Quiz Template + +```markdown +# Quiz: [Topic Name] + +**Instructions:** [Time limit, allowed resources, submission format] + +## Part 1: Conceptual Understanding + +### Question 1 (X points) +[Multiple choice, short answer, or true/false] + +**Answer:** [For instructor use] + +### Question 2 (X points) +[Conceptual question] + +## Part 2: Application + +### Question 3 (X points) +[Code-based or problem-solving question] + +```python +# Starter code if applicable +``` + +**Expected output:** [Description] + +## Part 3: Analysis + +### Question 4 (X points) +[Interpretation or explanation question] + +--- + +## Answer Key + +[Detailed answers and grading rubric] + +**Total Points:** XX +``` + +## Jupyter Notebook Template (Companion) + +```markdown +# [Topic Name] - Companion Notebook + +**Learning Objectives:** +- [Objective 1] +- [Objective 2] + +--- + +## Setup +```python +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt + +# Configuration +%matplotlib inline +plt.style.use('seaborn') +``` + +## Section 1: [Concept Name] + +[Markdown explanation matching chapter] + +```python +# Executable example from chapter +``` + +**Try it yourself:** [Suggested modifications to explore] + +## Section 2: Interactive Exploration + +```python +# Code for students to experiment with +``` + +**Questions to explore:** +1. What happens if you change X? +2. Try different values for Y +3. Visualize the results + +## Section 3: Practice Exercises + +### Exercise 1 +[Description] + +```python +# TODO: Your code here +``` + +**Validation:** +```python +# Check your answer +assert ..., "Check failed!" +print("✓ Correct!") +``` + +## Summary + +[Key points reinforced in this notebook] +``` + +## Jupyter Notebook Template (Lab) + +```markdown +# Lab [X]: [Topic Name] + +**Estimated Time:** X hours +**Difficulty:** [Beginner/Intermediate/Advanced] + +## Learning Objectives +- [Objective 1] +- [Objective 2] + +--- + +## Problem Statement + +[Real-world problem description] + +## Dataset + +[Description and source of data] + +```python +# Load or generate dataset +``` + +**Explore the data:** +```python +# TODO: Examine the dataset +# - Check dimensions +# - Look at first few rows +# - Check for missing values +``` + +## Task 1: [Subtask Name] + +[Instructions] + +```python +# TODO: Your code here + + +# Solution will go here +``` + +**Checkpoint:** [How to verify this step] + +## Task 2: [Next Subtask] + +[Instructions building on Task 1] + +```python +# TODO: Your code here +``` + +## Task 3: [Final Analysis] + +[Open-ended analysis task] + +## Bonus Challenge (Optional) + +[Extension for advanced students] + +## Reflection Questions + +1. What was the most challenging part? +2. What did you learn? +3. How could you extend this analysis? +``` + +## Slides Template (Markdown) + +```markdown +--- +title: [Topic Name] +author: [Your Name] +date: [Date] +--- + +# [Topic Name] + +## Learning Objectives + +- Objective 1 +- Objective 2 +- Objective 3 + +--- + +## Why This Matters + +[Motivation - 1-2 bullet points with visual] + +**Real-world application:** [Example] + +::: notes +[Speaker notes: Hook students with interesting context] +::: + +--- + +## [Concept 1]: Intuition + +[Visual diagram or simple example] + +- Key point 1 +- Key point 2 + +::: notes +[Teaching tips, common misconceptions to address] +::: + +--- + +## [Concept 1]: Formal Definition + +[Mathematical notation or technical definition] + +**In plain English:** [Simplified explanation] + +--- + +## Example: [Concrete Case] + +```python +# Code example +``` + +**Output:** +``` +[Expected output] +``` + +--- + +## Practice Problem + +[Quick problem for students to try] + +**Think-Pair-Share:** Discuss with your neighbor + +::: notes +[Give 2-3 minutes, walk around, call on students] +::: + +--- + +## Key Takeaways + +1. [Main point 1] +2. [Main point 2] +3. [Main point 3] + +**Next time:** [Preview next topic] + +--- + +## Questions? + +[Contact info or office hours] +``` + +## Usage Guidelines + +### When to Use Each Template + +- **Chapter**: Comprehensive coverage of a topic for reading/study +- **Quiz**: Assess understanding of covered material +- **Companion Notebook**: Follow along with chapter, explore interactively +- **Lab Notebook**: Apply concepts to solve realistic problems +- **Slides**: Support lecture or presentation + +### Customization + +These templates should be adapted based on: +- Student level (undergrad vs grad) +- Course philosophy (theory vs applied) +- Time available +- Prerequisites +- Tools and libraries used + +Always reference the specific course profile for customization guidance. diff --git a/skills/courses/bana-4080/course-profile.md b/skills/courses/bana-4080/course-profile.md new file mode 100644 index 0000000..1b99b67 --- /dev/null +++ b/skills/courses/bana-4080/course-profile.md @@ -0,0 +1,139 @@ +# BANA 4080 - Course Profile + +**Course:** UC BANA 4080: Introduction to Data Mining with Python +**Instructor:** Brad Boehmke +**Level:** Undergraduate +**Base Profile:** intro-to-data-mining + +## Course Overview + +This is the same course as "Intro to Data Mining" - all content, philosophy, and standards from that profile apply. This profile adds BANA 4080-specific lab structure and requirements. + +## Lab Structure (Thursday Sessions) + +**Duration:** 75 minutes exactly +**Format:** Two-part structure with collaborative learning + +### Part A: Guided Reinforcement (30 minutes) +**Purpose:** TA walks students through concepts to reinforce Tuesday's lecture and weekly readings + +**Structure:** +- Section A1: Concept review and setup (5-7 minutes) +- Section A2: Systematic practice of key skills (12-15 minutes) +- Section A3: Professional techniques demonstration (8-10 minutes) +- Section A4: Integration and advanced concepts (5-8 minutes) + +**Key Principles:** +- Students follow along and execute code together +- TA explains rationale and connects to business applications +- Multiple opportunities for questions and clarification +- Gradual release of responsibility toward independence + +### Class Q&A: Transition (5-10 minutes) +- Address questions from Part A +- Clarify confusing concepts +- Preview independent challenges + +### Part B: Independent Group Challenges (35-40 minutes) +**Purpose:** Students apply learned concepts independently in groups of 2-4 + +**Structure:** +- Challenge 1: Basic application (6-8 minutes) +- Challenge 2: Intermediate skills (6-8 minutes) +- Challenge 3: Complex integration (6-8 minutes) +- Challenge 4: Advanced application (6-8 minutes) +- Challenge 5: Creative problem-solving (6-8 minutes) +- Challenge 6: Extension/synthesis (5-7 minutes) + +**Key Principles:** +- Groups work collaboratively with minimal TA intervention +- Challenges require integration of multiple concepts +- Business context makes problems meaningful and engaging +- Different groups can progress at different paces +- **NO AI tools allowed** - students write code themselves + +### Wrap-up: Reflection (3-5 minutes) +- Accomplishments summary +- Reflection questions +- Connection to homework and next steps + +## Lab Requirements + +**Template:** `/Users/b294776/Desktop/UC/uc-bana-4080/planning/templates/lab_notebook_template.ipynb` +**Usage Guide:** `/Users/b294776/Desktop/UC/uc-bana-4080/planning/templates/lab_template_usage_guide.md` + +**Naming Convention:** +- Student lab: `XX_wkX_lab.ipynb` (e.g., `03_wk3_lab.ipynb`) +- TA guidance: `ta_guidance_wkX.ipynb` (e.g., `ta_guidance_wk3.ipynb`) + +**Content Alignment:** +- Every lab must directly reinforce concepts from Tuesday's slides +- Labs based on weekly assigned chapter readings +- Part A systematically reviews Tuesday lecture material +- Part B challenges integrate multiple chapter concepts + +**Pedagogical Standards:** +- Business context for every concept and exercise +- Progressive complexity from guided to independent work +- Real-world datasets (prefer chapter data and exercise data) +- Clear learning objectives (3-4 specific, measurable outcomes) +- Built-in reflection and metacognitive elements + +## TA Guidance Requirements + +Every lab must include a comprehensive TA guidance notebook with: + +**Pre-Lab Preparation Section:** +- Overview of learning objectives and key concepts +- Connection to Tuesday slides and weekly readings +- Setup instructions and common technical issues +- Grouping strategies and classroom management tips + +**Part A Detailed Instructions:** +- Section-by-section teaching guidance with timing +- Key concepts to emphasize at each step +- Common student questions and suggested responses +- Code demonstrations and explanation strategies +- Transition techniques between concepts + +**Part B Facilitation Guide:** +- Challenge-by-challenge overview with learning goals +- Common student difficulties and targeted hints +- Complete solutions for all challenges +- When and how to provide assistance +- Strategies for different pacing among groups + +**Assessment and Wrap-up:** +- Key concepts students should have mastered +- Reflection questions to check understanding +- Connections to upcoming content and homework +- Troubleshooting guide for common issues + +## Dataset Strategy + +**Default Approach:** +- **Part A (guided section):** Use primary dataset from chapter readings +- **Part B (challenges):** Use dataset from end-of-chapter exercises +- Always confirm dataset choices with instructor +- Allow for alternative datasets based on specific lab needs + +## Quality Standards + +**Before finalizing any lab:** +- [ ] All code tested and functional in Google Colab +- [ ] Tuesday slide alignment verified +- [ ] Chapter reading integration confirmed +- [ ] 75-minute timing validated +- [ ] Part A/B balance appropriate (30 min / 35-40 min) +- [ ] Business context realistic and motivating +- [ ] TA guidance comprehensive with complete solutions +- [ ] All `[PLACEHOLDERS]` filled with specific content +- [ ] Colab badge updated with correct filename +- [ ] Learning objectives align with activities + +## Reference Materials + +For full pedagogical approach and lab development process, refer to: +- Base course profile: `intro-to-data-mining/course-profile.md` +- Lab template: Path specified above +- Usage guide: Path specified above diff --git a/skills/courses/bana-4080/lab-template-guide.md b/skills/courses/bana-4080/lab-template-guide.md new file mode 100644 index 0000000..2e3372e --- /dev/null +++ b/skills/courses/bana-4080/lab-template-guide.md @@ -0,0 +1,264 @@ +# BANA 4080 Lab Template Guide + +This guide provides the structure and requirements for creating Thursday lab notebooks for BANA 4080. + +## Template Location + +**File:** `/Users/b294776/Desktop/UC/uc-bana-4080/planning/templates/lab_notebook_template.ipynb` +**Usage Guide:** `/Users/b294776/Desktop/UC/uc-bana-4080/planning/templates/lab_template_usage_guide.md` + +## Lab Structure (75 minutes) + +### Header Section +- Week number and descriptive lab title +- Colab badge with correct filename +- Lab description and context (2-3 sentences) +- **Learning Objectives:** 3-4 specific, measurable outcomes starting with action verbs +- **This Lab Reinforces:** List of chapter/reading references +- **Estimated Time & Structure:** Clear breakdown with realistic time estimates +- **Why This Matters:** Business context and real-world relevance + +### Setup Section +- Required imports (only necessary libraries) +- Data loading code +- Quick preview/verification of loaded data + +### Part A: Guided Reinforcement (~30 minutes) + +**Part 1** — [Section 1 Title] (Time estimate) +- Section description and context +- Subsection with explanation/instructions +- Step-by-step instructions (numbered) +- Code examples or starter code +- "🧠 Your Turn" exercise with tasks +- Empty code cell for practice +- "✅ Check Your Understanding" with questions and expected results + +**Part 2** — [Section 2 Title] (Time estimate) +- Similar structure to Part 1 +- Guided example with explanation +- Demonstration code +- "🧪 Practice Exercise" with business scenario +- Step-by-step approach +- Code cell for solution + +**Class Discussion/Q&A** (5-10 minutes) +- Discussion prompts +- Common blockers and clarifications + +### Part B: Independent Group Challenges (~35-40 minutes) + +**Intro markdown:** +```markdown +For the next several challenges: +* You will not be given starter code +* **DO NOT USE AI** to generate code +* Work in groups of 2-4 students +* Feel free to ask questions or seek help from instructor +* We'll stop and walk through each challenge together after each time block +``` + +**Challenge 1** — [Title] (6-8 minutes) +- Business question +- Additional context if needed +- Empty code cell with comment: `# Your turn: write code here to [description]` + +**Challenge 2** — [Title] (6-8 minutes) +- Business question +- Strategic hint (not code) +- Empty code cell + +**Challenge 3-6** — Similar structure with progressive difficulty + +### Optional Extension Activities + +**Extension 1-2:** Advanced challenges for early finishers +**Extension 3:** "Brainstorm - What else is interesting?" with example questions + +### Lab Wrap-Up & Reflection (3-5 minutes) + +- **What You Accomplished:** List of accomplishments +- **Reflection Questions:** 2-3 metacognitive prompts +- **Connection to Course Goals:** How this lab connects to broader learning +- **Next Steps:** Homework reference, next week preview, optional resources +- Save your work instruction + +### Troubleshooting & Common Issues + +- Issue 1-3 with solutions +- General debugging tips + +## Required Placeholders to Fill + +All items in `[BRACKETS]` must be replaced: + +| Placeholder | Example | +|-------------|---------| +| `[X]` | Week number (e.g., `6`) | +| `[LAB_TITLE]` | `Control Flow and Functions in Practice` | +| `[FILENAME]` | `06_wk6_lab` | +| `[LAB_DESCRIPTION_AND_CONTEXT]` | Description of what students will do | +| `[OBJECTIVE_1]` | `Write conditional statements for business logic` | +| `[Reading/Chapter Reference 1]` | `Chapter 7: Control Flow` | +| `[TIME_ESTIMATE]` | `15-20` | +| `[BUSINESS_CONTEXT_AND_REAL_WORLD_RELEVANCE]` | Why this matters in real work | +| `[SECTION_X_TITLE]` | Name of major section | +| `[SUBSECTION_X_TITLE]` | Name of subsection | +| `[EXPLANATION_OR_INSTRUCTIONS]` | Teaching content | +| `[STEP_X]` | Individual step in process | +| `[DESCRIPTIVE_COMMENT]` | What the code does | +| `[CODE_EXAMPLE_OR_STARTER]` | Actual code | +| `[EXERCISE_TITLE]` | Name of practice exercise | +| `[EXERCISE_DESCRIPTION]` | What students should do | +| `[TASK_X]` | Individual task | +| `[HELPFUL_HINT_IF_NEEDED]` | Strategic guidance | +| `[MINI_ASSESSMENT_OR_DISCUSSION_QUESTIONS]` | Comprehension check | +| `[QUESTION_X]` | Specific question | +| `[WHAT_STUDENTS_SHOULD_SEE]` | Expected output/result | +| `[CONCRETE_BUSINESS_EXAMPLE]` | Real scenario | +| `[DEMONSTRATION_CODE]` | Working example | +| `[REALISTIC_BUSINESS_CONTEXT]` | Business scenario for exercise | +| `[CLEAR_TASK_DESCRIPTION]` | What to accomplish | +| `[CHALLENGE_TITLE]` | Name of challenge | +| `[BUSINESS_QUESTION]` | Question to answer | +| `[ADDITIONAL_CONTEXT_IF_NEEDED]` | Extra info | +| `[CHALLENGE_DESCRIPTION]` | What the code should do | +| `[STRATEGIC_HINT_NOT_CODE]` | Approach guidance | +| `[EXTENSION_TITLE]` | Name of extension | +| `[ADVANCED_CHALLENGE_DESCRIPTION]` | Extension task | +| `[EXAMPLE_QUESTION_X]` | Sample brainstorm question | +| `[ACCOMPLISHMENT_X]` | What was learned | +| `[HOW_THIS_LAB_CONNECTS_TO_BROADER_LEARNING]` | Big picture | +| `[HOMEWORK_REFERENCE]` | Link to assignment | +| `[NEXT_WEEK_PREVIEW]` | What's coming | +| `[OPTIONAL_RESOURCES]` | Additional materials | +| `[SPECIFIC_SHARING_INSTRUCTIONS]` | How to share work | +| `[COMMON_PROBLEM]` | Issue students face | +| `[SOLUTION_APPROACH]` | How to fix | +| `[TIP_X]` | Debugging tip | + +## Content Development Process + +### Phase 1: Content Analysis +1. Review assigned chapter(s) for the week +2. Identify key concepts that need hands-on practice +3. Map concepts to Part A (guided) and Part B (challenges) +4. Define 3-4 specific learning objectives + +### Phase 2: Part A Design (Guided Reinforcement) +- Systematically review key concepts from readings +- Provide hands-on practice with instructor guidance +- Include "Your Turn" exercises for immediate application +- Build confidence before independent work + +**Principles:** +- Students follow along and execute code together +- Explain rationale and connect to business applications +- Multiple opportunities for questions +- Gradual release of responsibility + +### Phase 3: Part B Design (Independent Challenges) +- Create 6 challenges with progressive difficulty +- Each challenge: clear business question, minimal code scaffolding +- Strategic hints rather than direct solutions +- Require integration of multiple concepts + +**Principles:** +- Groups work collaboratively with minimal intervention +- Business context makes problems meaningful +- Different groups can progress at different paces +- No AI tools allowed - students write code themselves + +### Phase 4: Dataset Selection +**Default Strategy:** +- Part A (guided): Primary dataset from chapter readings +- Part B (challenges): Dataset from end-of-chapter exercises +- Always confirm with instructor and allow alternatives + +### Phase 5: Quality Validation +- [ ] All code tested in Google Colab +- [ ] Chapter alignment verified +- [ ] 75-minute timing realistic +- [ ] Part A/B balance appropriate (~30 min / ~35-40 min) +- [ ] Business context realistic +- [ ] Learning objectives align with activities +- [ ] All placeholders replaced +- [ ] Colab badge updated + +## TA Guidance Requirements + +Each lab requires a companion `ta_guidance_wkX.ipynb` with: + +**Pre-Lab Preparation:** +- Learning objectives and key concepts overview +- Connection to readings +- Setup instructions and common issues +- Classroom management tips + +**Part A Teaching Guidance:** +- Section-by-section instructions with timing +- Key concepts to emphasize +- Common student questions and responses +- Teaching strategies + +**Part B Facilitation Guide:** +- Complete solutions for all 6 challenges +- Common difficulties and targeted hints +- When and how to provide assistance +- Pacing strategies + +**Assessment and Wrap-up:** +- Key concepts to verify mastery +- Reflection questions +- Connection to upcoming content +- Troubleshooting guide + +## Business Context Standards + +Every concept and exercise must have clear business relevance: +- Real-world scenarios students can relate to +- Authentic business questions and problems +- Professional applications and use cases +- Connection to career skills + +**Good examples:** +- Customer segmentation analysis +- Marketing campaign performance +- Retail transaction patterns +- Product recommendation systems +- Sales forecasting + +**Avoid:** +- Abstract mathematical exercises without context +- Toy problems with no real-world connection +- Examples that don't relate to business analytics + +## Common Lab Types by Week + +**Weeks 1-3 (Fundamentals):** +- More guided examples, slower pacing +- Simple, clear-cut problems +- Accessible business scenarios +- Building basic confidence + +**Weeks 4-6 (Skill Application):** +- Less guidance, more problem-solving +- Multi-step business problems +- Realistic data analysis scenarios +- Integration of concepts + +**Weeks 7+ (Advanced Integration):** +- Open-ended exploration +- Complex, multi-faceted problems +- Comprehensive case studies +- Professional-level analysis + +## Remember + +- Labs directly reinforce Tuesday lecture concepts +- Based on weekly assigned chapter readings +- 75 minutes exactly with strategic time allocation +- Two-part structure: guided (30 min) + independent (35-40 min) +- Business context for everything +- No AI tools in Part B challenges +- Always create companion TA guidance notebook diff --git a/skills/courses/bana-6043/course-profile.md b/skills/courses/bana-6043/course-profile.md new file mode 100644 index 0000000..c85dc9a --- /dev/null +++ b/skills/courses/bana-6043/course-profile.md @@ -0,0 +1,14 @@ +# BANA 6043 - Course Profile + +**Course:** UC BANA 6043: Statistical Computing +**Level:** Graduate +**Base Profile:** statistical-computing + +## Course Overview + +This is the same course as "Statistical Computing" - all content, philosophy, and standards from that profile apply. + +This profile serves as a mapping to enable course-builder commands to recognize "BANA 6043" as referring to the statistical-computing course profile. + +For all content creation, refer to: +- Base course profile: `statistical-computing/course-profile.md` diff --git a/skills/courses/bana-7075/course-profile.md b/skills/courses/bana-7075/course-profile.md new file mode 100644 index 0000000..1c61b79 --- /dev/null +++ b/skills/courses/bana-7075/course-profile.md @@ -0,0 +1,14 @@ +# BANA 7075 - Course Profile + +**Course:** UC BANA 7075: ML in Business +**Level:** Graduate +**Base Profile:** ml-in-business + +## Course Overview + +This is the same course as "ML in Business" - all content, philosophy, and standards from that profile apply. + +This profile serves as a mapping to enable course-builder commands to recognize "BANA 7075" as referring to the ml-in-business course profile. + +For all content creation, refer to: +- Base course profile: `ml-in-business/course-profile.md` diff --git a/skills/courses/intro-to-data-mining/course-profile.md b/skills/courses/intro-to-data-mining/course-profile.md new file mode 100644 index 0000000..576883d --- /dev/null +++ b/skills/courses/intro-to-data-mining/course-profile.md @@ -0,0 +1,238 @@ +# Intro to Data Mining - Course Profile + +**Course:** UC BANA 4080: Introduction to Data Mining with Python +**Instructor:** Brad Boehmke + +## Audience + +**Student Level:** Undergraduate (juniors/seniors) + +**Background:** +- Business students with foundation in calculus, statistics, and possibly regression +- May have Excel experience and basic VBA exposure +- Variable programming backgrounds - many are complete coding beginners +- Understand business operations, customer behavior, and quantitative thinking +- Know how to think critically but lack experience turning theory into practice with code + +**Prerequisites:** +- Quantitative methods and statistical inference courses +- No prior programming experience required or expected +- Course explicitly designed for beginners + +**Key Challenge:** Bridging the gap between classroom theory and real-world data analysis + +## Learning Philosophy + +**Core Approach:** Hands-on, immersive learning through doing + +**Key Principles:** +1. **Practice over theory** - Students learn by working with real, messy datasets +2. **Build confidence through action** - Focus on getting students comfortable with tools before perfection +3. **Close the theory-practice gap** - Move from "knowing concepts" to "applying skills" +4. **AI as assistant, not autopilot** - Use GenAI tools (ChatGPT, Claude, Copilot) to help learn, but emphasize understanding +5. **Collaborative learning** - Build community; encourage students to help each other +6. **Growth mindset** - Normalize struggle; coding is a new language that takes time + +**Teaching Style:** +- Conversational, relatable tone (see intro chapter example) +- Use storytelling and scenarios (e.g., "Taylor the intern") +- Address student concerns directly (e.g., "Why learn this when AI exists?") +- Set realistic expectations about difficulty +- Encourage persistence and resilience + +**Unique Aspects:** +- Explicitly addresses role of GenAI in learning process +- Balances AI assistance with foundational skill building +- Uses real-world business contexts students can relate to + +## Technical Stack + +**Core Environment:** +- **Python** (chosen for beginner-friendliness + professional power) +- **Jupyter Lab/Notebooks** (primary development environment) +- **Google Colab** (cloud-based option for students) +- **Quarto** (for textbook and slides) +- **Virtual environment** (venv for package management) + +**Primary Libraries (Weeks 1-6):** +- **pandas** - data manipulation and DataFrames +- **numpy** - numerical computation +- **matplotlib** - basic visualization +- **seaborn** - statistical visualization + +**Machine Learning Libraries (Weeks 8-13):** +- **scikit-learn** - all ML models and evaluation + +**Additional Tools:** +- CSV/Excel file handling +- Basic SQL concepts (joins in pandas) +- Git/GitHub for assignment submission + +**File Formats:** +- Quarto markdown (.qmd) for book chapters +- Jupyter notebooks (.ipynb) for examples, labs, homework +- Real datasets (CSV, Excel) in `/data/` directory + +## Content Style + +**Writing Style:** +- **Conversational and approachable** - Not dry or overly academic +- **Student-focused** - Addresses "you" directly +- **Motivational** - Builds confidence, normalizes struggle +- **Practical** - Always tied to real-world application +- **Honest** - Acknowledges difficulties, doesn't sugar-coat challenges + +**Explanation Approach:** +1. **Start with WHY** - Motivate the topic before diving in +2. **Use analogies and stories** - Make abstract concepts concrete +3. **Show, don't just tell** - Working code examples over theory +4. **Progressive complexity** - Start simple, build gradually +5. **Address common questions** - Anticipate student concerns + +**Examples:** +- Use **relatable business scenarios** (customer data, marketing analytics, retail transactions) +- Work with **messy, real-world datasets** (not clean, perfect examples) +- Include **visual aids** heavily (plots, diagrams, screenshots) +- Provide **executable code** that students can run and modify + +**Pedagogical Elements:** +- **Callout boxes** for tips, warnings, reflections, and examples +- **Student reflection prompts** to encourage metacognition +- **Exercises** that build on chapter concepts +- **Code comments** that explain what's happening +- **Error messages and debugging guidance** + +**Depth:** +- Prioritize **intuition over mathematical rigor** +- Show code implementation before heavy theory +- Balance "just enough math" with practical application +- Focus on **interpretation and application** over derivations + +## Key Topics + +**Module 1: Python Fundamentals (Week 1)** +- Course intro + motivation +- Variables, data types, basic operators +- Why Python? Why not just use AI? +- Setting up environment + +**Module 2: Jupyter & Data Structures (Week 2)** +- Jupyter notebooks and reproducible workflows +- Lists, dictionaries, tuples +- Pandas introduction +- Importing CSV data + +**Module 3: Data Wrangling (Week 3)** +- DataFrame manipulation +- Filtering and subsetting +- Aggregating data +- GroupBy operations + +**Module 4: Advanced Data Manipulation (Week 4)** +- Working with dates and times +- String operations +- Relational data and joins (SQL-style in pandas) +- Merging DataFrames + +**Module 5: Data Visualization (Week 5)** +- Matplotlib basics +- Seaborn for statistical plots +- Exploratory data analysis with visuals +- Best practices for effective visualization + +**Module 6: Writing Efficient Code (Week 6)** +- Control flow (if/else, loops) +- Functions and modularity +- List comprehensions +- Code efficiency and readability + +**Week 7: Midterm Project** +- Application of Modules 1-6 +- Work with messy, real datasets +- Open-ended analysis problem + +**Module 7: Machine Learning Intro (Week 8)** +- What is ML and when to use it? +- Train/test split +- Features and labels +- Model building process + +**Module 8: Regression (Week 9)** +- Correlation analysis +- Linear regression with scikit-learn +- Model evaluation (R², RMSE) +- Interpretation + +**Module 9: Classification (Week 10)** +- Logistic regression +- Classification metrics (accuracy, precision, recall, F1) +- Confusion matrices +- When to use classification vs regression + +**Module 10: Tree-Based Models (Week 11)** +- Decision trees +- Random forests +- Feature importance +- Model interpretation + +**Module 11: Model Optimization (Week 12)** +- Feature engineering +- Cross-validation +- Hyperparameter tuning (GridSearchCV) +- Model selection + +**Module 12: Advanced Topics (Week 13)** +- Unsupervised learning (clustering, PCA) +- Deep learning overview +- Introduction to LLMs and GenAI concepts + +**Week 14: Final Project** +- Comprehensive data science project +- Full pipeline from data cleaning to modeling + +## Assessment Approach + +**Grading Components:** +- **Labs** - Weekly hands-on activities (Thursdays) +- **Homework** - Applied assignments (with answer keys for instructor) +- **Midterm Project** - Comprehensive application of Modules 1-6 +- **Final Project** - End-to-end data science project +- **Quizzes** - Knowledge checks (materials in `/planning/quizzes/`) + +**Student Support:** +- Canvas discussion boards for peer collaboration +- Office hours +- Answer keys provided for labs and homework (instructor use) +- Multiple formats (notebook, HTML, PDF) for accessibility + +**GenAI Policy:** +- **Encouraged** to use ChatGPT, Claude, Copilot as learning aids +- **Required** to understand code, not just copy it +- Emphasis on using AI to learn, not to avoid learning +- Students asked to reflect on AI tool use and limitations + +**Project Structure:** +- Templates provided for major assignments +- Rubrics included in `/planning/projects/` +- Real-world datasets required +- Open-ended problems that require creative problem-solving + +## Content Format + +**Textbook:** Quarto book with modules 1-6 + appendices +**Slides:** Weekly presentations using Quarto + Reveal.js +**Examples:** Numbered sequence of Jupyter notebooks (01-17) +**Labs:** Weekly hands-on activities with answer keys +**Homework:** Individual assignments with solutions in multiple formats +**Datasets:** Real-world data in `/data/` directory (retail, airlines, housing, etc.) + +## Course Materials Repository + +All materials maintained in Git repository with structure: +- `/book/` - Textbook chapters +- `/slides/` - Weekly presentations +- `/example-notebooks/` - Companion code examples +- `/labs/` - Hands-on activities +- `/homework/` - Assignments +- `/data/` - Datasets +- `/planning/` - Instructor resources (Canvas docs, rubrics, quizzes) diff --git a/skills/courses/ml-in-business/course-profile.md b/skills/courses/ml-in-business/course-profile.md new file mode 100644 index 0000000..f933050 --- /dev/null +++ b/skills/courses/ml-in-business/course-profile.md @@ -0,0 +1,25 @@ +# ML in Business - Course Profile + +**Status:** 🚧 Placeholder - To be filled from syllabus + +## Audience +[To be filled: student level, background, prerequisites] + +## Learning Philosophy +[To be filled: teaching approach, pedagogical style] + +## Technical Stack +[To be filled: libraries, tools, environment] + +## Content Style +[To be filled: explanation style, depth, examples] + +## Key Topics +[To be filled: weekly or unit breakdown] + +## Assessment Approach +[To be filled: how students are evaluated] + +--- + +**Next step:** Provide the course syllabus to populate this profile. diff --git a/skills/courses/statistical-computing/course-profile.md b/skills/courses/statistical-computing/course-profile.md new file mode 100644 index 0000000..0dcc961 --- /dev/null +++ b/skills/courses/statistical-computing/course-profile.md @@ -0,0 +1,25 @@ +# Statistical Computing - Course Profile + +**Status:** 🚧 Placeholder - To be filled from syllabus + +## Audience +[To be filled: student level, background, prerequisites] + +## Learning Philosophy +[To be filled: teaching approach, pedagogical style] + +## Technical Stack +[To be filled: libraries, tools, environment] + +## Content Style +[To be filled: explanation style, depth, examples] + +## Key Topics +[To be filled: weekly or unit breakdown] + +## Assessment Approach +[To be filled: how students are evaluated] + +--- + +**Next step:** Provide the course syllabus to populate this profile. diff --git a/skills/pedagogy/teaching-principles.md b/skills/pedagogy/teaching-principles.md new file mode 100644 index 0000000..966ebd1 --- /dev/null +++ b/skills/pedagogy/teaching-principles.md @@ -0,0 +1,118 @@ +# Data Science Teaching Principles + +General pedagogical principles for teaching data science, machine learning, AI, and MLOps. + +## Core Teaching Philosophy + +### 1. Hands-On Learning +Data science is learned by doing, not just reading: +- Provide working code examples +- Encourage experimentation and iteration +- Use real or realistic datasets +- Build confidence through successful execution +- Learn from errors and debugging + +### 2. Visual Learning +Leverage visualizations to build intuition: +- Plot data before analyzing +- Visualize model behavior +- Show distributions and patterns +- Use interactive plots when possible +- Make abstract concepts concrete through visuals + +### 3. Incremental Complexity +Build understanding step by step: +- Start with simple, concrete examples +- Introduce one concept at a time +- Build on previously learned material +- Avoid overwhelming with too many details upfront +- Progress from intuition to theory + +### 4. Theory Meets Practice +Balance conceptual understanding with application: +- Explain why, not just how +- Connect math to code implementation +- Show real-world applications +- Validate theoretical concepts through code +- Make abstract concepts tangible + +### 5. Active Learning +Engage students in the learning process: +- Include practice problems +- Design checkpoints for self-assessment +- Encourage exploration and "what if" questions +- Provide opportunities for discovery +- Foster experimentation + +## Content Structure Guidelines + +### For Chapters +1. **Start with motivation** - Why does this topic matter? +2. **Provide intuition** - Concrete examples before formalism +3. **Introduce concepts incrementally** - One idea at a time +4. **Show, don't just tell** - Working examples with code +5. **Practice and validate** - Exercises to reinforce learning +6. **Summarize and connect** - Key takeaways and next steps + +### For Assessments +1. **Test understanding, not memorization** - Focus on concepts +2. **Include application problems** - Not just recall +3. **Mix question types** - Theory, code, interpretation +4. **Provide partial credit opportunities** - Show reasoning +5. **Include real-world scenarios** - Make it relevant + +### For Notebooks +1. **Clear learning objectives** - What will students learn? +2. **Executable from top to bottom** - No hidden dependencies +3. **Mix explanation and code** - Interleave markdown and code cells +4. **Include validation** - Help students check their work +5. **Encourage exploration** - Provide extension opportunities + +### For Slides +1. **One main idea per slide** - Don't overwhelm +2. **Visual over text** - Use diagrams and examples +3. **Live coding when possible** - Show the process +4. **Build complexity gradually** - Layer concepts +5. **Include discussion prompts** - Engage the audience + +## Level Differentiation + +### Undergraduate Students +- Assume less mathematical background +- Start with concrete before abstract +- Provide more scaffolding and structure +- Focus on intuition and practical application +- Use relatable, accessible examples +- Emphasize building confidence + +### Graduate Students +- Can handle more mathematical rigor +- Expect understanding of prerequisites +- Include theoretical foundations +- Balance theory with implementation +- Use research and industry examples +- Encourage independence and depth + +## Tool and Library Guidance + +### Choosing the Right Tool +- **Beginners**: Start with high-level libraries (pandas, sklearn) +- **Intermediate**: Introduce lower-level concepts (numpy operations) +- **Advanced**: Implement from scratch to understand internals + +### Code Quality +- Write clean, readable code +- Include comments explaining non-obvious parts +- Follow conventions (PEP 8 for Python) +- Show both "quick and dirty" and "production-quality" approaches when relevant +- Emphasize reproducibility + +## Common Pitfalls to Avoid + +1. **Math before intuition** - Build understanding first +2. **Too much at once** - Break down complex topics +3. **Passive learning** - Always include active elements +4. **Disconnected theory** - Link concepts to practice +5. **Ignoring prerequisites** - Know your audience +6. **One-size-fits-all** - Adapt to student level +7. **No real-world context** - Show why it matters