Agent Skills: Learning Objectives Skill

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:

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

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

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

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

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:

- id: "LO-AUTH-001"
  statement: "Implement OAuth authentication working with AI as co-learning partner"
  blooms_level: "Apply"
  cefr_level: "B1"
  three_role_integration:
    ai_as_teacher: "Learn refresh token rotation pattern from AI suggestion"
    ai_as_student: "Guide AI through security requirements via clear spec"
    ai_as_coworker: "Iterate on session management approach together"
  assessment_method: "Code + reflection: Show implementation AND what you learned from AI"
  success_criteria:
    - "OAuth implementation works correctly"
    - "Student identifies at least one pattern learned from AI"
    - "Student demonstrates validation of AI output"

Objective Balance for AI-Native Content:

• 60-70%: Traditional technical skills
• 20-30%: Co-learning skills (working WITH AI)
• 10-20%: Validation/verification skills

Step 6: Validate for Measurability

Once you've generated objectives, invoke the validation script to check they're measurable:

python .claude/skills/learning-objectives/scripts/validate-objectives.py objectives.yml

The script checks:

• ✅ Objectives use action verbs (not vague words like "understand" or "know")
• ✅ Objectives are specific and testable
• ✅ Verbs match the Bloom's level
• ✅ Required fields present (context, assessment, success criteria)

If validation fails, review the error messages and refine:

• Replace vague verbs with specific action verbs from Bloom's level
• Add missing context or success criteria
• Make statements more specific (not just topic names)

Step 7: Refine and Finalize

Based on validation feedback:

• Revise any objectives with errors
• Ensure the objective sequence makes sense (build progressively)
• Verify prerequisites are necessary but not excessive
• Check that assessment methods are realistic for the time available

Output Format

Present learning objectives in clear, structured format:

topic: "Topic Name"
objectives:
  - id: "LO-001"
    statement: "Action verb + what learner will do"
    blooms_level: "Remember/Understand/Apply/Analyze/Evaluate/Create"
    context: "Specific situation or problem"
    prerequisites:
      - "Prerequisite 1"
      - "Prerequisite 2"
    assessment_method: "How this will be assessed"
    success_criteria:
      - "Criterion 1"
      - "Criterion 2"

Acceptance Checks

• [ ] SpecRef present (path to chapter spec and objective IDs)
• [ ] ≤ 5 objectives; measurable verbs only
• [ ] Each objective has Bloom tag (e.g., L2-Understand, L3-Apply)
• [ ] Each objective includes an “Evidence” mapping to assessment items or tasks
• [ ] Objectives align with complexity tier constraints (see Constitution)

Objective snippet

- [ID: LO-001 | Bloom: L3-Apply]
  Statement: Implement X in Y context
  Evidence: Quiz Q3, Task T2

Examples

Example 1: Python List Comprehensions (1-hour lesson)

User Request: "Create objectives for teaching Python list comprehensions to beginners"

Generated Objectives:

topic: "Python List Comprehensions"
objectives:
  - id: "LO-C1-001"
    statement: "Define list comprehension and identify its basic syntax"
    blooms_level: "Remember"
    context: "Introduction to list comprehensions"
    prerequisites:
      - "Know Python list syntax and indexing"
      - "Can write basic for loops"
    assessment_method: "Quick quiz: match syntax to purpose"
    success_criteria:
      - "Can identify list comprehension in code"
      - "Can label parts of syntax (brackets, for, if)"

  - id: "LO-C1-002"
    statement: "Explain how list comprehension replaces for loop patterns"
    blooms_level: "Understand"
    context: "Comparing traditional loops with comprehensions"
    prerequisites:
      - "Understand for loop iteration"
    assessment_method: "Paraphrase: explain in own words"
    success_criteria:
      - "Can describe equivalent for loop for any list comprehension"
      - "Can explain what's happening step-by-step"

  - id: "LO-C1-003"
    statement: "Implement list comprehensions to filter and transform data"
    blooms_level: "Apply"
    context: "Given various data transformation tasks"
    prerequisites:
      - "Can write list comprehensions with filter conditions"
      - "Understand string/number methods"
    assessment_method: "Code exercise: write comprehensions for provided requirements"
    success_criteria:
      - "Code executes without errors"
      - "Output matches expected results"
      - "Uses list comprehension (not a for loop)"

  - id: "LO-C1-004"
    statement: "Compare list comprehension with traditional loops by examining efficiency and readability"
    blooms_level: "Analyze"
    context: "Choosing approaches for data processing"
    prerequisites:
      - "Implement list comprehensions fluently"
      - "Understand basic time complexity"
    assessment_method: "Code analysis: compare two implementations"
    success_criteria:
      - "Identifies efficiency differences (space/time)"
      - "Considers readability and maintainability"
      - "Justifies when to use each approach"

Example 2: OOP Class Design (3-hour module)

User Request: "I'm teaching OOP fundamentals. What should students be able to do?"

Generated Objectives:

topic: "Object-Oriented Programming Fundamentals"
objectives:
  - id: "LO-OOP-001"
    statement: "Define class, instance, method, and attribute and distinguish between them"
    blooms_level: "Remember"
    context: "Introduction to OOP vocabulary"
    prerequisites:
      - "Understand functions and variables in Python"
    assessment_method: "Matching exercise and short definitions"
    success_criteria:
      - "Can define each term correctly"
      - "Can match definitions to examples in code"

  - id: "LO-OOP-002"
    statement: "Explain how __init__ initializes instances and why self references the current object"
    blooms_level: "Understand"
    context: "Understanding object instantiation"
    prerequisites:
      - "Know class definition syntax"
      - "Understand function parameters and returns"
    assessment_method: "Walkthrough: explain code line-by-line"
    success_criteria:
      - "Can trace execution of __init__ method"
      - "Can explain what self represents"

  - id: "LO-OOP-003"
    statement: "Design and implement a class with attributes and methods for a specific domain"
    blooms_level: "Apply"
    context: "Real-world object requirements (e.g., Student, BankAccount, Car)"
    prerequisites:
      - "Can write class definitions with __init__"
      - "Understand instance vs class scope"
    assessment_method: "Code exercise: implement class from requirements"
    success_criteria:
      - "Class correctly models the domain"
      - "Attributes store state appropriately"
      - "Methods perform expected behaviors"
      - "Code follows PEP 8 naming conventions"

  - id: "LO-OOP-004"
    statement: "Analyze class hierarchies and identify inheritance relationships"
    blooms_level: "Analyze"
    context: "Understanding code organization and reuse patterns"
    prerequisites:
      - "Implement basic classes fluently"
      - "Understand inheritance syntax"
    assessment_method: "Code analysis exercise: identify class relationships"
    success_criteria:
      - "Identifies parent/child relationships correctly"
      - "Explains why inheritance is used"
      - "Identifies methods that are overridden"

  - id: "LO-OOP-005"
    statement: "Evaluate a class design and justify changes for maintainability and extensibility"
    blooms_level: "Evaluate"
    context: "Code review of existing class structures"
    prerequisites:
      - "Analyze inheritance patterns"
      - "Understand design principles (DRY, SOLID)"
    assessment_method: "Design critique: suggest improvements with justification"
    success_criteria:
      - "Identifies duplication that could be eliminated"
      - "Suggests appropriate inheritance changes"
      - "Justifies changes based on maintenance concerns"

  - id: "LO-OOP-006"
    statement: "Design an OOP solution for a complex domain problem"
    blooms_level: "Create"
    context: "Building a small system with multiple interacting classes"
    prerequisites:
      - "Master all previous OOP concepts"
      - "Can implement and evaluate class designs"
    assessment_method: "Create a mini-project with multiple classes"
    success_criteria:
      - "Solution correctly models the domain"
      - "Uses inheritance appropriately"
      - "Code is well-organized and reusable"
      - "Design decisions are documented and justified"

Common Patterns

Pattern 1: Short Tutorial (30 minutes)

• 1 Understand objective
• 1 Apply objective
• 1 Analyze objective
• ~Total: 3 objectives

Pattern 2: Standard Lesson (1-2 hours)

• 1 Remember objective (if foundational topic)
• 1 Understand objective
• 2 Apply objectives (different contexts/complexities)
• 1 Analyze objective
• ~Total: 4-5 objectives

Pattern 3: Full Unit (3-5 hours)

• 1 Remember (terminology)
• 1 Understand (concepts)
• 2-3 Apply (varied contexts)
• 1 Analyze (relationships)
• 1 Evaluate (quality)
• 1 Create (synthesis)
• ~Total: 7-8 objectives

Pattern 4: Capstone/Project Course

• Lightweight foundational objectives (Remember/Understand)
• Multiple Apply objectives with increasing complexity
• Strong Analyze/Evaluate/Create focus
• Capstone project as final assessment

Troubleshooting

Objective Too Vague

Problem: "Understand decorators"

Why it's bad: Not measurable. What does "understand" mean? How will you know if they understand?

Solution: Use specific action verb and add context

• ✅ "Explain how a decorator wraps a function to modify its behavior"
• ✅ "Implement a custom decorator that logs function calls"

Too Many Objectives

Problem: Created 15 objectives for 1-hour lesson

Solution: Reduce to 3-5 objectives. Ask:

• Which are essential? (Keep)
• Which are "nice to have"? (Remove or move to extension)
• Are some redundant? (Consolidate)

Prerequisites Are Too Deep

Problem: Prerequisites include "Master Python" and "Understand all design patterns"

Solution: Be minimal. Ask: "What's the absolute minimum they need to know to start learning this?"

• Too deep: "Master all data structures"
• Just right: "Understand how lists work with indexing"

Can't Think of Higher Bloom's Levels

Problem: Only created Remember and Apply objectives

Solution:

1. Read blooms-taxonomy-programming.md §4-6 for Analyze/Evaluate/Create examples
2. Ask: "What can learners do with this knowledge?" (Points toward Create)
3. Add analysis question: "Compare this approach with X..."
4. Add evaluation: "Would this solution work for Y? Why/why not?"

Integration with Other Skills

This skill works well with:

→ exercise-designer skill: Once you have learning objectives, use that skill to create practice exercises aligned to each objective's Bloom's level

→ technical-clarity skill: Use to review the clarity of your objective statements

→ code-example-generator skill: Use to create examples that demonstrate Apply-level objectives

Emerging Topics: Agentic AI & Model Context Protocol (MCP)

As books increasingly cover advanced AI topics, use this skill to define learning objectives for:

Agentic AI Learning Objectives Example

Topic: "Building Autonomous AI Agents"

topic: "Agentic AI Fundamentals"
objectives:
  - id: "LO-AGENT-001"
    statement: "Define autonomous agents, distinguish them from traditional chatbots, and explain key characteristics (goal-seeking, state management, tool use)"
    blooms_level: "Understand"
    context: "Introduction to agentic AI concepts"
    prerequisites:
      - "Understand AI basics and language models"
    assessment_method: "Short answer or concept mapping"
    success_criteria:
      - "Can list key differences between agents and chatbots"
      - "Can explain goal-directed behavior and autonomy"

  - id: "LO-AGENT-002"
    statement: "Implement a simple autonomous agent that uses tools to accomplish a specified goal"
    blooms_level: "Apply"
    context: "Building working agents with Python"
    prerequisites:
      - "Understand agent architecture and tool-use patterns"
      - "Can write Python functions and handle API calls"
    assessment_method: "Code exercise: implement agent from requirements"
    success_criteria:
      - "Agent autonomously reaches its goal"
      - "Correctly selects and uses available tools"
      - "Handles tool responses and iterates"

  - id: "LO-AGENT-003"
    statement: "Analyze agent behavior and identify when agents succeed, fail, or enter loops; propose fixes"
    blooms_level: "Analyze"
    context: "Debugging and improving agent performance"
    prerequisites:
      - "Can implement basic agents"
      - "Understand agent decision-making patterns"
    assessment_method: "Debug exercise: analyze agent logs and improve behavior"
    success_criteria:
      - "Identifies root causes of agent failures"
      - "Proposes specific improvements (better prompts, new tools, constraints)"

MCP (Model Context Protocol) Learning Objectives Example

Topic: "Integrating MCP into Python Applications"

topic: "Model Context Protocol (MCP) Integration"
objectives:
  - id: "LO-MCP-001"
    statement: "Explain MCP architecture, the role of servers and clients, and how MCP extends model capabilities"
    blooms_level: "Understand"
    context: "Introduction to MCP concepts"
    prerequisites:
      - "Understand Python modules and client-server patterns"
    assessment_method: "Explanation exercise: describe MCP client-server relationship"
    success_criteria:
      - "Can explain what MCP servers provide"
      - "Can describe the client-server protocol flow"

  - id: "LO-MCP-002"
    statement: "Install and configure existing MCP servers and integrate them into a Python application"
    blooms_level: "Apply"
    context: "Using MCP in real applications"
    prerequisites:
      - "Understand MCP architecture"
      - "Can write Python clients and manage dependencies"
    assessment_method: "Code exercise: integrate MCP server into working application"
    success_criteria:
      - "Correctly configures MCP client"
      - "Application successfully calls MCP server tools"
      - "Responses are properly handled and integrated"

  - id: "LO-MCP-003"
    statement: "Design and implement a custom MCP server that provides tools for a specific domain"
    blooms_level: "Create"
    context: "Building reusable MCP tools"
    prerequisites:
      - "Can integrate existing MCP servers"
      - "Understand server-side architecture and tool definitions"
    assessment_method: "Project: implement MCP server with documentation"
    success_criteria:
      - "Server correctly implements MCP protocol"
      - "Tools are well-defined with clear descriptions"
      - "Client can successfully call server tools"
      - "Code is documented and maintainable"

Key Considerations for Advanced Topics:

• These topics may require deeper prerequisites (solid Python, API design knowledge)
• Use spiral learning: revisit concepts at increasing depth (basic agent → advanced orchestration)
• Include both theory (understanding architecture) and practice (implementing tools)
• Assessment should emphasize real problem-solving, not just definitions

Tips for Success

1. Start with the end in mind: What should learners be able to DO, not what will you teach?
2. Make them testable: Ask "How would I know if this objective was met?"
3. Use consistent Bloom's level progression: Build from simple to complex
4. Include prerequisites: Help learners self-assess readiness
5. Validate often: Use the validation script to catch vague language
6. Test with real learners: Objectives often need refinement based on actual usage

Ready to generate objectives? Provide:

• Topic/concept to teach
• Target learner level (beginner/intermediate/advanced)
• Available teaching time
• End goal (build project? understand theory? debug code?)

Or paste existing objectives and I'll help make them more measurable!