aiskillstore/marketplace / skills/92bilal26/exercise-designer
exercise-designer
VerifiedDesigns evidence-based Python practice exercises with varied formats, difficulty progression, spaced repetition, test cases, hints, and rubrics.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 17.6 KB |
| reference/difficulty-progression.md | markdown | 4.5 KB |
| reference/evidence-based-strategies.md | markdown | 9.0 KB |
| reference/exercise-types.md | markdown | 7.5 KB |
| reference/spaced-repetition.md | markdown | 4.9 KB |
| scripts/generate-test-cases.pyexecutable | script | 6.0 KB |
| templates/exercise-template.yml | config | 2.1 KB |
| templates/rubric-template.yml | config | 2.4 KB |
reference/difficulty-progression.md
View on GitHub# Difficulty Progression in Programming Exercises
## Overview
Effective exercise sequences gradually increase difficulty, building learner confidence and competence. This guide provides frameworks for designing progressive exercise difficulty.
## Difficulty Dimensions
Exercises can increase difficulty along multiple dimensions:
1. **Cognitive Complexity**: Number of concepts/steps required
2. **Code Length**: Lines of code to write
3. **Abstraction Level**: Concrete → abstract thinking
4. **Scaffolding**: Amount of support provided
5. **Problem Clarity**: Specification clarity
6. **Edge Cases**: Number of special cases to handle
## Bloom's Taxonomy Progression
Map exercises to cognitive levels:
**Remember** (Lowest):
- Recall syntax, recognize patterns
- Example: "What does list.append() do?"
**Understand**:
- Explain concepts, predict output
- Example: "Trace this code and predict output"
**Apply**:
- Use concepts in standard situations
- Example: "Write a function using list comprehension"
**Analyze**:
- Debug code, compare approaches
- Example: "Find and fix three bugs in this code"
**Evaluate**:
- Assess quality, choose best approach
- Example: "Which of these three solutions is most efficient and why?"
**Create** (Highest):
- Design new solutions, integrate multiple concepts
- Example: "Build a contact manager with add/search/delete functions"
## Progressive Example Sequence
### Level 1: Guided (Highest Support)
```python
# Complete this function (one blank)
def double_number(n):
return n __ 2 # Fill in the operator
```
### Level 2: Structured (Medium Support)
```python
# Complete this function (multiple blanks, clear structure provided)
def find_max(numbers):
max_value = numbers[0]
for num in ________:
if _________:
max_value = ________
return max_value
```
### Level 3: Specification (Low Support)
```
Write a function find_max(numbers) that returns the largest number in a list.
Handle empty lists by returning None.
```
### Level 4: Open-Ended (Minimal Support)
```
Create a function to process a list of student scores. It should:
- Calculate average
- Find highest and lowest scores
- Determine letter grades (A: 90+, B: 80-89, C: 70-79, D: 60-69, F: <60)
- Return a summary dictionary
```
## PRIME Framework
**P**rerequisites: What must be known first
**R**elevance: Clear purpose and application
**I**nstruction: Explicit about what to do
**M**anageable: Achievable with current skills
**E**ngaging: Interesting and meaningful
## Difficulty Scaling Patterns
### Pattern 1: Concept Accumulation
```
Exercise 1: Use if statement
Exercise 2: Use if/else
Exercise 3: Use if/elif/else
Exercise 4: Nested conditionals
Exercise 5: Complex boolean expressions
```
### Pattern 2: Scaffolding Fade
```
Exercise 1: Complete code (70% provided)
Exercise 2: Complete code (50% provided)
Exercise 3: Complete code (30% provided)
Exercise 4: Specification only (0% provided)
```
### Pattern 3: Constraint Addition
```
Exercise 1: Sort a list (use built-in sorted())
Exercise 2: Sort without built-in functions
Exercise 3: Sort with custom comparison
Exercise 4: Implement sorting algorithm from scratch
```
### Pattern 4: Edge Case Complexity
```
Exercise 1: Handle normal input only
Exercise 2: Handle empty input
Exercise 3: Handle invalid types
Exercise 4: Handle all edge cases with clear error messages
```
## Recommended Difficulty Distribution
**Beginner Module** (10 exercises):
- 40% Easy (Levels 1-2)
- 40% Medium (Level 3)
- 20% Challenging (Level 4)
**Intermediate Module**:
- 20% Easy (review)
- 50% Medium
- 30% Challenging
**Advanced Module**:
- 10% Easy (review)
- 30% Medium
- 60% Challenging
## Time-Based Progression
**5-minute exercises**: Fill-in-blank, trace execution
**10-minute exercises**: Debug-this, small functions
**20-minute exercises**: Multi-function programs
**45-minute exercises**: Mini-projects with multiple requirements
## Warning Signs
**Too Easy**:
- Learners complete instantly without thinking
- No errors or struggle
- Boredom reported
**Too Hard**:
- High frustration, giving up
- Unable to start (no entry point)
- Requires concepts not yet taught
**Adjustment**: Move difficulty up or down based on completion time and success rate (target 70-80% success).
## Further Reading
- "Flow" (Csikszentmihalyi) - Optimal challenge balance
- "How to Design Programs" - Systematic exercise progression
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |