Back to Details

learning-objectives

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

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.
帮助教育工作者创建符合布鲁姆分类法和CEFR语言能力等级的可衡量、可执行的学习目标。此技能可用于：
  • 定义学生将达成的具体能力（而非仅涵盖的主题）
  • 确保目标具体可测，而非模糊笼统
  • 识别前置知识，逐步搭建学习框架
  • 规划合适的评估方法
  • 设计从基础回忆到创造性综合的递进式学习路径
  • 对接国际能力标准（CEFR A1-C2），提升目标的通用性
  • 纳入AI协同学习成果（与AI协作学习，而非仅独立学习）
与Constitution v4.0.1的对齐：此技能采用“评估优先”的目标设计方法——在创建学习目标前先定义成功标准，整合CEFR能力等级（原则5：递进式复杂度），并融入第二部分b（AI三重角色框架）的协同学习成果。

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)

评估优先的目标设计（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
undefined
关键工作流：
  1. 评估优先：在撰写目标前，先查看章节规范中的成功标准
  2. 目标次之：设计能助力评估通过的学习目标
  3. 对齐第三：确保每个目标至少对应一项成功评估指标
  4. 验证最后：验证目标是否可衡量且与评估对齐
模板：
markdown
undefined

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
来源：章节规范位于 
specs/part-X/chapter-Y/spec.md
规范中的成功评估指标：
  1. 75%以上能编写有效的规范（业务目标：减少迭代周期）
  2. 80%以上能识别模糊需求（业务目标：防止范围蔓延）
为达成评估而设计的学习目标：
  • LO-001：编写清晰的规范 → 评估#1
  • LO-002：识别模糊需求 → 评估#2

**禁止**在无以下内容的情况下创建目标：
- ✅ 引用带有成功评估指标的已批准规范
- ✅ 明确的映射关系：目标 → 评估 → 业务目标
- ✅ 与评估标准对齐的可衡量性

Process

操作流程

Step 1: Understand the Context

步骤1：理解上下文

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?)
当收到生成学习目标的请求时，首先明确：
  • 主题或概念是什么？（Python装饰器、OOP、async/await等）
  • 学习者群体是谁？（初学者、中级学习者、高级学习者）
  • 教学时长是多少？（30分钟、2小时、完整单元）
  • 最终目标是什么？（能否构建项目？理解理论？调试代码？）
  • 成功评估指标有哪些？（来自章节规范——什么是成功？）

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

步骤2：回顾布鲁姆分类法（如有需要）

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
若不熟悉特定主题的认知层级，请阅读： 📖 reference/blooms-taxonomy-programming.md
此文档将布鲁姆的6个层级映射到编程场景，包含：
  • 每个层级的动作动词（回忆、理解、应用、分析、评估、创造）
  • 编程示例
  • 每个层级的评估方法

Step 3: Identify Prerequisites

步骤3：识别前置知识

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
阅读关于前置知识分析的指南： 📖 reference/prerequisite-analysis.md
为目标确定：
  • 学习者在学习核心概念前必须掌握哪些知识？
  • 列出回忆/理解层级的前置知识（无需深度掌握）
  • 追溯到基础知识点的依赖链

Step 4: Choose Assessment Methods

步骤4：选择评估方法

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.).
根据每个目标的布鲁姆层级，查看合适的评估方法： 📖 reference/assessment-methods.md
此指南帮助你为目标匹配现实可行的评估方式（应用层级对应代码练习，评估层级对应代码审查等）

Step 5: Generate Objectives with CEFR Proficiency Levels

步骤5：生成带有CEFR能力等级的目标

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)
针对每个主题，创建3-5个目标（通常）：
  • 至少涵盖主题所需的每个层级（从回忆到创造）
  • 复杂度逐步提升
  • 每个目标包含清晰的陈述、上下文、前置知识、评估方法和成功标准
  • 映射到CEFR能力等级（A1/A2/B1/B2/C1）
可参考以下模板： 📄 templates/learning-objective-template.yml
核心原则：每个目标应回答以下问题：
  • 学习者将做什么？（来自布鲁姆层级的动作动词）
  • 在什么情境下？（具体场景或问题）
  • 如何判断他们成功了？（可衡量的标准）
  • 对应什么能力等级？（CEFR A1-C2）

CEFR Proficiency Mapping (Constitution v3.1.2)

CEFR能力等级映射（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).
将目标与国际能力标准对齐（来自skills-proficiency-mapper v2.0）：
A1（初学者——识别）：
  • 布鲁姆层级：仅回忆/理解
  • 示例："Identify Python syntax for defining a function"
  • 可衡量性：识别，而非生成
A2（初级——引导式应用）：
  • 布鲁姆层级：理解/应用（带脚手架支持）
  • 示例："Complete a function definition with provided hints"
  • 可衡量性：在支持下应用
B1（中级——独立应用）：
  • 布鲁姆层级：独立应用
  • 示例："Implement a function from clear specification without assistance"
  • 可衡量性：无脚手架的实际应用
B2（中高级——分析）：
  • 布鲁姆层级：分析/评估
  • 示例："Compare two implementations and justify which is more maintainable"
  • 可衡量性：带论证的评估
C1（高级——创造/综合）：
  • 布鲁姆层级：评估/创造
  • 示例："Design a system architecture for scalable deployment"
  • 可衡量性：带权衡分析的原创设计
能力进阶规则：章节内的课时应按A1→A2→B1逐步推进（不可从A1直接跳到C1）

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

AI三重角色协作目标（Constitution v4.0.1第二部分b）

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:
    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
关键要求：原生AI学习目标必须包含与AI进行双向协同学习的能力（根据第二部分b的强制要求），而非仅独立学习。
传统目标格式：
LO-001：实现用户认证（独立技能）
原生AI目标格式：
LO-001：与AI作为协同学习伙伴一起实现用户认证
  - 将AI作为教师：从AI的建议中学习安全模式
  - 将AI作为学生：通过清晰的规范优化AI的输出
  - 将AI作为同事：协作迭代出最优解决方案
  - 验证：检查AI生成的代码是否符合安全要求
三重角色目标类型：
1. AI作为教师的目标（学生向AI学习）：
  • "识别AI提出的可提升代码质量的模式"
  • "解释AI提出的方案中的权衡"
  • "将AI建议的模式应用到新场景中"
2. AI作为学生的目标（学生教AI）：
  • "编写能一次性生成正确代码的规范"
  • "提供反馈以优化AI的下一次输出"
  • "当AI请求澄清时，明确需求"
3. AI作为同事的目标（协作迭代）：
  • "与AI协作迭代出最优解决方案"
  • "制定战略决策，由AI负责战术实现"
  • "验证AI输出的正确性和适用性"
原生AI目标示例集：
yaml
- id: "LO-AUTH-001"
  statement: "与AI作为协同学习伙伴一起实现OAuth认证"
  blooms_level: "Apply"
  cefr_level: "B1"
  three_role_integration:
    ai_as_teacher: "从AI的建议中学习刷新令牌轮换模式"
    ai_as_student: "通过清晰的规范引导AI满足安全要求"
    ai_as_coworker: "共同迭代会话管理方案"
  assessment_method: "代码+反思：展示实现方案以及从AI中学到的内容"
  success_criteria:
    - "OAuth实现正常工作"
    - "学生至少能识别一个从AI中学到的模式"
    - "学生展示了对AI输出的验证过程"
原生AI内容的目标平衡：
  • 60-70%：传统技术技能
  • 20-30%：协同学习技能（与AI协作）
  • 10-20%：验证/核查技能

Step 6: Validate for Measurability

步骤6：验证可衡量性

Once you've generated objectives, invoke the validation script to check they're measurable:
bash
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)
生成目标后，调用验证脚本检查其可衡量性：
bash
python .claude/skills/learning-objectives/scripts/validate-objectives.py objectives.yml
脚本检查以下内容：
  • ✅ 目标使用动作动词（而非“理解”“知道”等模糊词汇）
  • ✅ 目标具体且可测试
  • ✅ 动词与布鲁姆层级匹配
  • ✅ 包含必填字段（上下文、评估方法、成功标准）
若验证失败，查看错误信息并优化：
  • 用布鲁姆层级对应的具体动作动词替换模糊动词
  • 添加缺失的上下文或成功标准
  • 让陈述更具体（而非仅提及主题名称）

Step 7: Refine and Finalize

步骤7：优化并定稿

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:
yaml
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"
以清晰、结构化的格式呈现学习目标：
yaml
topic: "主题名称"
objectives:
  - id: "LO-001"
    statement: "动作动词 + 学习者将完成的内容"
    blooms_level: "回忆/理解/应用/分析/评估/创造"
    context: "具体场景或问题"
    prerequisites:
      - "前置知识1"
      - "前置知识2"
    assessment_method: "评估方式"
    success_criteria:
      - "标准1"
      - "标准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)
  • 包含规范引用（章节规范路径和目标ID）
  • 目标数量≤5；仅使用可衡量的动词
  • 每个目标带有布鲁姆标签（如L2-Understand、L3-Apply）
  • 每个目标包含“证据”映射到评估项或任务
  • 目标符合复杂度层级约束（见Constitution）

Objective snippet

目标片段示例

- [ID: LO-001 | Bloom: L3-Apply]
  Statement: Implement X in Y context
  Evidence: Quiz Q3, Task T2
- [ID: LO-001 | Bloom: L3-Apply]
  Statement: 在Y场景中实现X
  Evidence: 测验Q3，任务T2

Examples

示例

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

示例1：Python列表推导式（1课时）

User Request: "Create objectives for teaching Python list comprehensions to beginners"
Generated Objectives:
yaml
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"
用户请求：“为初学者创建Python列表推导式的学习目标”
生成的目标：
yaml
topic: "Python List Comprehensions"
objectives:
  - id: "LO-C1-001"
    statement: "定义列表推导式并识别其基本语法"
    blooms_level: "Remember"
    context: "列表推导式入门"
    prerequisites:
      - "了解Python列表语法和索引"
      - "能编写基础for循环"
    assessment_method: "快速测验：匹配语法与用途"
    success_criteria:
      - "能在代码中识别列表推导式"
      - "能标注语法的各个部分（括号、for、if）"

  - id: "LO-C1-002"
    statement: "解释列表推导式如何替代for循环模式"
    blooms_level: "Understand"
    context: "比较传统循环与列表推导式"
    prerequisites:
      - "理解for循环迭代"
    assessment_method: "转述：用自己的话解释"
    success_criteria:
      - "能描述任何列表推导式对应的等效for循环"
      - "能逐步解释执行过程"

  - id: "LO-C1-003"
    statement: "使用列表推导式过滤和转换数据"
    blooms_level: "Apply"
    context: "完成各种数据转换任务"
    prerequisites:
      - "能编写带过滤条件的列表推导式"
      - "理解字符串/数字方法"
    assessment_method: "代码练习：根据需求编写列表推导式"
    success_criteria:
      - "代码无错误执行"
      - "输出与预期结果匹配"
      - "使用列表推导式（而非for循环）"

  - id: "LO-C1-004"
    statement: "通过检查效率和可读性比较列表推导式与传统循环"
    blooms_level: "Analyze"
    context: "选择数据处理方案"
    prerequisites:
      - "能熟练实现列表推导式"
      - "理解基本时间复杂度"
    assessment_method: "代码分析：比较两种实现方案"
    success_criteria:
      - "识别效率差异（空间/时间）"
      - "考虑可读性和可维护性"
      - "论证何时使用每种方案"

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

示例2：OOP类设计（3小时模块）

User Request: "I'm teaching OOP fundamentals. What should students be able to do?"
Generated Objectives:
yaml
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"
用户请求：“我正在教授OOP基础，学生应该具备什么能力？”
生成的目标：
yaml
topic: "Object-Oriented Programming Fundamentals"
objectives:
  - id: "LO-OOP-001"
    statement: "定义类、实例、方法和属性，并区分它们"
    blooms_level: "Remember"
    context: "OOP术语入门"
    prerequisites:
      - "理解Python中的函数和变量"
    assessment_method: "匹配练习和简短定义"
    success_criteria:
      - "能正确定义每个术语"
      - "能将定义与代码示例匹配"

  - id: "LO-OOP-002"
    statement: "解释__init__如何初始化实例，以及self为何引用当前对象"
    blooms_level: "Understand"
    context: "理解对象实例化"
    prerequisites:
      - "了解类定义语法"
      - "理解函数参数和返回值"
    assessment_method: "Walkthrough：逐行解释代码"
    success_criteria:
      - "能追踪__init__方法的执行过程"
      - "能解释self代表什么"

  - id: "LO-OOP-003"
    statement: "为特定领域设计并实现带有属性和方法的类"
    blooms_level: "Apply"
    context: "现实世界对象需求（如Student、BankAccount、Car）"
    prerequisites:
      - "能编写带__init__的类定义"
      - "理解实例与类的作用域"
    assessment_method: "代码练习：根据需求实现类"
    success_criteria:
      - "类能正确建模领域"
      - "属性适当地存储状态"
      - "方法执行预期行为"
      - "代码遵循PEP 8命名规范"

  - id: "LO-OOP-004"
    statement: "分析类层次结构并识别继承关系"
    blooms_level: "Analyze"
    context: "理解代码组织和复用模式"
    prerequisites:
      - "能熟练实现基础类"
      - "理解继承语法"
    assessment_method: "代码分析练习：识别类关系"
    success_criteria:
      - "正确识别父/子关系"
      - "解释使用继承的原因"
      - "识别被重写的方法"

  - id: "LO-OOP-005"
    statement: "评估类设计并论证可维护性和可扩展性的改进方案"
    blooms_level: "Evaluate"
    context: "现有类结构的代码审查"
    prerequisites:
      - "能分析继承模式"
      - "理解设计原则（DRY、SOLID）"
    assessment_method: "设计评审：提出改进方案并论证"
    success_criteria:
      - "识别可消除的重复代码"
      - "提出合适的继承改进方案"
      - "基于维护需求论证改进的合理性"

  - id: "LO-OOP-006"
    statement: "为复杂领域问题设计OOP解决方案"
    blooms_level: "Create"
    context: "构建包含多个交互类的小型系统"
    prerequisites:
      - "掌握所有之前的OOP概念"
      - "能实现并评估类设计"
    assessment_method: "创建包含多个类的迷你项目"
    success_criteria:
      - "解决方案能正确建模领域"
      - "适当使用继承"
      - "代码组织良好且可复用"
      - "设计决策有文档记录和论证"

Common Patterns

常见模式

Pattern 1: Short Tutorial (30 minutes)

模式1：短教程（30分钟）

  • 1 Understand objective
  • 1 Apply objective
  • 1 Analyze objective
  • ~Total: 3 objectives
  • 1个理解目标
  • 1个应用目标
  • 1个分析目标
  • ~总计：3个目标

Pattern 2: Standard Lesson (1-2 hours)

模式2：标准课时（1-2小时）

  • 1 Remember objective (if foundational topic)
  • 1 Understand objective
  • 2 Apply objectives (different contexts/complexities)
  • 1 Analyze objective
  • ~Total: 4-5 objectives
  • 1个回忆目标（如果是基础主题）
  • 1个理解目标
  • 2个应用目标（不同场景/复杂度）
  • 1个分析目标
  • ~总计：4-5个目标

Pattern 3: Full Unit (3-5 hours)

模式3：完整单元（3-5小时）

  • 1 Remember (terminology)
  • 1 Understand (concepts)
  • 2-3 Apply (varied contexts)
  • 1 Analyze (relationships)
  • 1 Evaluate (quality)
  • 1 Create (synthesis)
  • ~Total: 7-8 objectives
  • 1个回忆目标（术语）
  • 1个理解目标（概念）
  • 2-3个应用目标（不同场景）
  • 1个分析目标（关系）
  • 1个评估目标（质量）
  • 1个创造目标（综合）
  • ~总计：7-8个目标

Pattern 4: Capstone/Project Course

模式4：顶点项目/项目课程

  • 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)
问题：为1课时创建了15个目标
解决方案：减少到3-5个目标。思考：
  • 哪些是核心目标？（保留）
  • 哪些是“锦上添花”的？（移除或移至拓展内容）
  • 哪些是冗余的？（合并）

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"
问题：前置知识包含“精通Python”和“理解所有设计模式”
解决方案：保持极简。思考：“学习者开始学习此内容前绝对需要知道什么？”
  • 过深：“掌握所有数据结构”
  • 合适：“理解列表的索引用法”

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?"
问题：仅创建了回忆和应用层级的目标
解决方案：
  1. 阅读blooms-taxonomy-programming.md的第4-6节，获取分析/评估/创造层级的示例
  2. 思考：“学习者能用这些知识做什么？”（指向创造层级）
  3. 添加分析问题：“比较此方案与X...”
  4. 添加评估问题：“此方案是否适用于Y？为什么？”

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)

前沿主题：Agentic AI与Model Context Protocol（MCP）

As books increasingly cover advanced AI topics, use this skill to define learning objectives for:
随着书籍越来越多地涵盖高级AI主题，使用此技能为以下内容定义学习目标：

Agentic AI Learning Objectives Example

Agentic AI学习目标示例

Topic: "Building Autonomous AI Agents"
yaml
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)"
主题：“构建自主AI Agent”
yaml
topic: "Agentic AI Fundamentals"
objectives:
  - id: "LO-AGENT-001"
    statement: "定义自主Agent，区分其与传统聊天机器人，并解释关键特征（目标导向、状态管理、工具使用）"
    blooms_level: "Understand"
    context: "Agentic AI概念入门"
    prerequisites:
      - "理解AI基础和语言模型"
    assessment_method: "简答题或概念映射"
    success_criteria:
      - "能列出Agent与聊天机器人的关键区别"
      - "能解释目标导向行为和自主性"

  - id: "LO-AGENT-002"
    statement: "实现一个使用工具完成指定目标的简单自主Agent"
    blooms_level: "Apply"
    context: "用Python构建可运行的Agent"
    prerequisites:
      - "理解Agent架构和工具使用模式"
      - "能编写Python函数并处理API调用"
    assessment_method: "代码练习：根据需求实现Agent"
    success_criteria:
      - "Agent能自主达成目标"
      - "正确选择并使用可用工具"
      - "处理工具响应并迭代"

  - id: "LO-AGENT-003"
    statement: "分析Agent行为，识别其成功、失败或进入循环的情况；提出修复方案"
    blooms_level: "Analyze"
    context: "调试和提升Agent性能"
    prerequisites:
      - "能实现基础Agent"
      - "理解Agent决策模式"
    assessment_method: "调试练习：分析Agent日志并改进行为"
    success_criteria:
      - "识别Agent失败的根本原因"
      - "提出具体的改进方案（更好的提示词、新工具、约束）"

MCP (Model Context Protocol) Learning Objectives Example

MCP（Model Context Protocol）学习目标示例

Topic: "Integrating MCP into Python Applications"
yaml
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
主题：“将MCP集成到Python应用中”
yaml
topic: "Model Context Protocol (MCP) Integration"
objectives:
  - id: "LO-MCP-001"
    statement: "解释MCP架构、服务器和客户端的角色，以及MCP如何扩展模型能力"
    blooms_level: "Understand"
    context: "MCP概念入门"
    prerequisites:
      - "理解Python模块和客户端-服务器模式"
    assessment_method: "解释练习：描述MCP客户端-服务器关系"
    success_criteria:
      - "能解释MCP服务器提供的功能"
      - "能描述客户端-服务器协议流程"

  - id: "LO-MCP-002"
    statement: "安装并配置现有MCP服务器，并将其集成到Python应用中"
    blooms_level: "Apply"
    context: "在实际应用中使用MCP"
    prerequisites:
      - "理解MCP架构"
      - "能编写Python客户端并管理依赖"
    assessment_method: "代码练习：将MCP服务器集成到运行中的应用"
    success_criteria:
      - "正确配置MCP客户端"
      - "应用成功调用MCP服务器工具"
      - "正确处理响应并集成"

  - id: "LO-MCP-003"
    statement: "为特定领域设计并实现自定义MCP服务器"
    blooms_level: "Create"
    context: "构建可复用的MCP工具"
    prerequisites:
      - "能集成现有MCP服务器"
      - "理解服务器端架构和工具定义"
    assessment_method: "项目实现带文档的MCP服务器"
    success_criteria:
      - "服务器正确实现MCP协议"
      - "工具定义清晰，描述明确"
      - "客户端能成功调用服务器工具"
      - "代码有文档且可维护"
高级主题的关键考虑因素：
  • 这些主题可能需要更深的前置知识（扎实的Python基础、API设计知识）
  • 使用螺旋式学习：逐步加深对概念的理解（基础Agent → 高级编排）
  • 同时包含理论（理解架构）和实践（实现工具）
  • 评估应强调实际问题解决，而非仅定义

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!
  1. 以终为始：学习者应能做什么，而非你将教什么？
  2. 确保可测试：问自己“如何判断此目标已达成？”
  3. 保持布鲁姆层级的递进一致性：从简单到复杂
  4. 包含前置知识：帮助学习者自我评估准备情况
  5. 经常验证：使用验证脚本捕捉模糊语言
  6. 与真实学习者测试：目标通常需要根据实际使用情况优化
**准备好生成目标了吗？**请提供：
  • 要教授的主题/概念
  • 目标学习者水平（初学者/中级/高级）
  • 可用教学时长
  • 最终目标（构建项目？理解理论？调试代码？）
或者粘贴现有目标，我会帮助你使其更具可衡量性！