Skip to content

aiskillstore/marketplace / skills/92bilal26/exercise-designer

exercise-designer

Verified

Designs evidence-based Python practice exercises with varied formats, difficulty progression, spaced repetition, test cases, hints, and rubrics.

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
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
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: 198kUpdated Claude CodeCodexVerifiedInstall