learning-objectives

What this skill does

# Learning Objectives Skill

## Purpose

Enable educators to create **measurable, actionable learning objectives** aligned with Bloom's taxonomy and CEFR proficiency levels. This skill helps:
- Define what students will achieve (not just what topics they'll cover)
- Ensure objectives are specific and testable (not vague)
- Identify prerequisites and scaffold learning progressively
- Plan appropriate assessment methods
- Sequence learning from basic recall to creative synthesis
- **Map to international proficiency standards (CEFR A1-C2) for portability**
- **Include AI co-learning outcomes (working WITH AI, not just independently)**

**Constitution v4.0.1 Alignment**: This skill implements evals-first objective design—defining success criteria BEFORE creating learning objectives, integrating CEFR proficiency levels (Principle 5: Progressive Complexity), and incorporating Section IIb (AI Three Roles Framework) co-learning outcomes.

## When to Activate

Use this skill when:
- Planning curriculum or lesson design and need to define learning outcomes
- Creating assessments and want to align them with clear objectives
- Designing a course and need measurable outcomes for accreditation
- Educators ask to "define objectives", "create learning goals", "set outcomes", or "what should students achieve?"
- Reviewing existing objectives and wondering if they're specific enough
- Designing a lesson and unsure what students should be able to do by the end

## Evals-First Objective Design (Constitution v4.0.1)

**CRITICAL WORKFLOW**:
1. **Evals First**: Review success criteria from chapter spec BEFORE writing objectives
2. **Objectives Second**: Design learning objectives that lead to eval success
3. **Alignment Third**: Ensure each objective maps to at least one success eval
4. **Validation Fourth**: Verify objectives are measurable and aligned

**Template**:
```markdown
### Objective Design (Evals-First)

**Source**: Chapter spec at `specs/part-X/chapter-Y/spec.md`

**Success Evals from Spec**:
1. 75%+ write valid specification (business goal: reduce iteration cycles)
2. 80%+ identify vague requirements (business goal: prevent scope creep)

**Learning Objectives Designed to Achieve Evals**:
- LO-001: Write clear specifications → Eval #1
- LO-002: Identify ambiguous requirements → Eval #2
```

**Do NOT** create objectives without:
- ✅ Reference to approved spec with success evals
- ✅ Explicit mapping: Objective → Eval → Business Goal
- ✅ Measurability aligned with eval criteria

## Process

### Step 1: Understand the Context

When a request comes in to generate learning objectives, first understand:
- **What topic or concept?** (Python decorators, OOP, async/await, etc.)
- **Who are the learners?** (Beginners, intermediate, advanced)
- **How long to teach?** (30 minutes, 2 hours, full unit)
- **What's the end goal?** (Can they build something? Understand theory? Debug code?)
- **What are the success evals?** (From chapter spec—what defines success?)

### Step 2: Review Bloom's Taxonomy (If Needed)

If you're not familiar with the specific topic's cognitive levels, read:
📖 [reference/blooms-taxonomy-programming.md](reference/blooms-taxonomy-programming.md)

This document maps Bloom's 6 levels to programming contexts with:
- Action verbs for each level (Remember, Understand, Apply, Analyze, Evaluate, Create)
- Programming examples
- Assessment methods for each level

### Step 3: Identify Prerequisites

Read the guidance on prerequisite analysis:
📖 [reference/prerequisite-analysis.md](reference/prerequisite-analysis.md)

For your objectives, determine:
- What must learners know BEFORE tackling the main concept?
- List prerequisites at Remember/Understand level (not deep mastery)
- Trace dependency chains to foundational knowledge

### Step 4: Choose Assessment Methods

Based on the Bloom's level of each objective, review appropriate assessment methods:
📖 [reference/assessment-methods.md](reference/assessment-methods.md)

This guides you to pair objectives with realistic assessment approaches (code exercises for Apply level, code reviews for Evaluate, etc.).

### Step 5: Generate Objectives with CEFR Proficiency Levels

For each topic, create 3-5 objectives (typically):
- At least one from each level needed for the topic (Remember through Create)
- Progressively building in complexity
- Each with clear statement, context, prerequisites, assessment method, and success criteria
- **Map to CEFR proficiency level (A1/A2/B1/B2/C1)**

Use the template as guidance:
📄 [templates/learning-objective-template.yml](templates/learning-objective-template.yml)

**Key principle**: Each objective should answer:
- **What will learners DO?** (verb from Bloom's level)
- **In what context?** (the specific situation or problem)
- **How will we know they succeeded?** (measurable criteria)
- **What proficiency level?** (CEFR A1-C2)

### CEFR Proficiency Mapping (Constitution v3.1.2)

**Align objectives with international proficiency standards** (from skills-proficiency-mapper v2.0):

**A1 (Beginner - Recognition)**:
- Bloom's: Remember/Understand only
- Example: "Identify Python syntax for defining a function"
- Measurable: Recognition, not production

**A2 (Elementary - Guided Application)**:
- Bloom's: Understand/Apply with scaffolding
- Example: "Complete a function definition with provided hints"
- Measurable: Application with support

**B1 (Intermediate - Independent Application)**:
- Bloom's: Apply independently
- Example: "Implement a function from clear specification without assistance"
- Measurable: Real-world application without scaffolding

**B2 (Upper-Intermediate - Analysis)**:
- Bloom's: Analyze/Evaluate
- Example: "Compare two implementations and justify which is more maintainable"
- Measurable: Evaluation with justification

**C1 (Advanced - Creation/Synthesis)**:
- Bloom's: Evaluate/Create
- Example: "Design a system architecture for scalable deployment"
- Measurable: Original design with trade-off analysis

**Proficiency Progression Rule**: Lessons should progress A1→A2→B1 within a chapter (not jump from A1 to C1).

### Three-Role AI Partnership Objectives (Section IIb, Constitution v4.0.1)

**CRITICAL**: AI-native learning objectives must include ability to work WITH AI in bidirectional co-learning partnership (per Section IIb forcing functions), not just independently.

**Traditional Objective Format**:
```
LO-001: Implement user authentication (independent skill)
```

**AI-Native Objective Format**:
```
LO-001: Implement user authentication working with AI as co-learning partner
  - Use AI as Teacher: Learn security patterns from AI suggestions
  - Use AI as Student: Refine AI's output through clear specifications
  - Use AI as Co-Worker: Iterate toward optimal solution collaboratively
  - Validate: Verify AI-generated code meets security requirements
```

**Three-Role Objective Types**:

**1. AI as Teacher Objectives** (Student learns from AI):
- "Identify pattern suggested by AI that improves code quality"
- "Explain trade-offs in AI's proposed approaches"
- "Apply AI-suggested pattern to new context"

**2. AI as Student Objectives** (Student teaches AI):
- "Write specification that produces correct code on first try"
- "Provide feedback that improves AI's next iteration"
- "Clarify requirements when AI asks for disambiguation"

**3. AI as Co-Worker Objectives** (Collaborative iteration):
- "Iterate with AI to converge on optimal solution"
- "Make strategic decisions while AI handles tactical implementation"
- "Validate AI outputs for correctness and appropriateness"

**Example AI-Native Objective Set**:
```yaml
- id: "LO-AUTH-001"
  statement: "Implement OAuth authentication working with AI as co-learning partner"
  blooms_level: "Apply"
  cefr_level: "B1"
  three_role_integration: