Name: Concept Scaffolding
Author: ComeOnOliver

搵技能.../

# Scaffolding Plan: Python Decorators (B1 Level)

**Target Audience**: Intermediate (B1)
**Total Steps**: 5
**Estimated Time**: 90 minutes
**Layer**: 2 (AI-Assisted)

## Prerequisite Check
- Functions as first-class objects (Chapter 12)
- Function scope and closures (Chapter 13)

---

## Step 1: Functions as Objects (Foundation) — 15 min

**New Concepts**: 2 (functions assignable, functions returnable)
**Cognitive Load**: Low (review + 1 new idea)
**Scaffolding**: Heavy (show-then-explain)

### Worked Example
```python
def greet(name):
    return f"Hello, {name}"

# Functions can be assigned to variables
my_function = greet
result = my_function("Alice")  # "Hello, Alice"

# Functions can be passed as arguments
def call_twice(func, arg):
    func(arg)
    func(arg)

call_twice(greet, "Bob")  # Prints twice

def make_multiplier(n):
    def multiply(x):
        return x * n  # Closure: multiply "remembers" n
    return multiply

times_three = make_multiplier(3)
result = times_three(5)  # 15

def original_function(x):
    return x * 2

def wrapper(func):
    def inner(x):
        print("Before calling function")
        result = func(x)  # Call original
        print("After calling function")
        return result
    return inner

# Manual decoration
decorated = wrapper(original_function)
decorated(5)
# Output:
# Before calling function
# After calling function
# 10

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

# These are equivalent:
# 1. Manual
my_func = logger(my_func)

# 2. Decorator syntax
@logger
def my_func(x):
    return x * 2

my_func(5)  # Logs "Calling my_func", returns 10

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()  # Prints "Hello!" three times


**Self-Monitoring Check**:
- ✅ Cognitive load calculated (not arbitrary steps)
- ✅ Worked examples before practice (not explain-then-try)
- ✅ Validation checkpoints (not assumptions)
- ✅ Tier-appropriate load (B1: 3-5 concepts/step)
- ✅ Dependency order correct (foundation → complex)
- ✅ Step count optimal (5 steps, not 12)
- ✅ Layer-aligned (L2 AI collaboration where appropriate)

---

## Success Metrics

**Reasoning Activation Score**: 4/4
- ✅ Persona: Cognitive stance established (load architect)
- ✅ Questions: Systematic inquiry structure (5 question sets)
- ✅ Principles: Decision frameworks (7 principles)
- ✅ Meta-awareness: Anti-convergence monitoring (5 convergence points)

**Comparison**:
- v2.0 (procedural): 0/4 reasoning activation
- v3.0 (reasoning): 4/4 reasoning activation

---

**Ready to use**: Invoke this skill when you need to break complex concepts into progressive learning steps with cognitive load management and validation checkpoints.

Concept Scaffolding | Skills Pool

Step	New Concepts	Load Level	Appropriate?
1	2	Low	✓ (B1 can handle)
2	3	Moderate	✓ (B1 target)
3	4	Moderate-High	✓ (with AI support)
4	2	Low	✓ (syntax sugar)
5	3	High	✓ (optional extension)

Concept Scaffolding

Concept Scaffolding

Concept Scaffolding Skill v3.0 (Reasoning-Activated)

Persona: The Cognitive Stance

Questions: The Reasoning Structure

1. Complexity Diagnosis

2. Learner State Analysis

3. Scaffolding Architecture

4. Integration Design

5. Validation Planning

Principles: The Decision Framework

Principle 1: Cognitive Load Budget Over Arbitrary Steps

Principle 2: Simple → Realistic → Complex (Not Linear)

Principle 3: Foundational Before Complex (Dependency Ordering)

Principle 4: Worked Examples First, Then Practice

Principle 5: Checkpoints Over Assumptions

Principle 6: 3-7 Steps Optimal (Not 1, Not 12)

Principle 7: Layer-Appropriate Scaffolding

Anti-Convergence: Meta-Awareness

Convergence Point 1: Arbitrary Step Counts

Convergence Point 2: Skipping Worked Examples

Convergence Point 3: No Validation Checkpoints

Convergence Point 4: Ignoring Tier-Based Load Limits

Convergence Point 5: Teaching Out of Dependency Order

Integration with Other Skills

Activation Example (Full Workflow)

Activation (Reasoning Mode):

Output (Reasoning-Activated Scaffolding):

Checkpoint

Step 2: Functions Returning Functions (Closure Introduction) — 20 min

Worked Example

Checkpoint

Step 3: The Wrapper Pattern (Manual Decoration) — 25 min

Worked Example (WITH AI AS TEACHER)

Checkpoint

Step 4: Decorator Syntax (@) — 20 min

Worked Example (AI AS CO-WORKER)

Checkpoint

Step 5: Decorators with Arguments — 10 min (stretch)

Worked Example (AI AS TEACHER)

Checkpoint

Cognitive Load Analysis

Layer Integration

Sessions

Docker Patterns

Autonomous Loops

Kotlin Patterns

Eval Harness

Golang Patterns