zhongwei/gh-bradleyboehmke-brads-marketplace-course-builder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-29 18:01:52 +08:00
commit 9daed3091f
21 changed files with 2964 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
.claude-plugin/plugin.json Normal file
View File

@@ -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"
]
}

3
README.md Normal file
View File

@@ -0,0 +1,3 @@
# course-builder
Tools for creating educational content for data science, ML, AI, and MLOps courses

57
agents/course-architect.md Normal file
View File

@@ -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

46
commands/create-companion-nb.md Normal file
View File

@@ -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

233
commands/create-lab-nb.md Normal file
View File

@@ -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.

287
commands/create-module-overview.md Normal file
View File

@@ -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.

215
commands/create-quiz.md Normal file
View File

@@ -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

265
commands/create-slides.md Normal file
View File

@@ -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.

202
commands/create-ta-guide.md Normal file
View File

@@ -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.

296
commands/review-chapter.md Normal file
View File

@@ -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

45
commands/write-chapter.md Normal file
View File

@@ -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

113
plugin.lock.json Normal file
View File

@@ -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": []
}
}

348
skills/content-templates/templates.md Normal file
View File

@@ -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.

139
skills/courses/bana-4080/course-profile.md Normal file
View File

@@ -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

264
skills/courses/bana-4080/lab-template-guide.md Normal file
View File

@@ -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

14
skills/courses/bana-6043/course-profile.md Normal file
View File

@@ -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`

14
skills/courses/bana-7075/course-profile.md Normal file
View File

@@ -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`

238
skills/courses/intro-to-data-mining/course-profile.md Normal file
View File

@@ -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)

25
skills/courses/ml-in-business/course-profile.md Normal file
View File

@@ -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.

25
skills/courses/statistical-computing/course-profile.md Normal file
View File

@@ -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.

118
skills/pedagogy/teaching-principles.md Normal file
View File

@@ -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