learning-objectives

学习目标技能

目的

帮助教育工作者制定可衡量、可执行的学习目标，并使其与布鲁姆分类法和 CEFR 熟练度等级保持一致。此技能有助于：

• 明确学生将取得什么成果（而不只是会学习哪些主题）
• 确保目标具体且可测试（而非含糊不清）
• 识别先修知识，并逐步搭建学习支架
• 规划恰当的评估方法
• 将学习内容按从基础记忆到创造性综合的顺序编排
• 与国际熟练度标准（CEFR A1-C2）对应，以便于移植
• 纳入 AI 协同学习成果（与 AI 合作，而不仅是独立完成）

与 Constitution v4.0.1 保持一致：此技能采用评估优先的目标设计方式——在制定学习目标之前先定义成功标准，整合 CEFR 熟练度等级（原则 5：渐进复杂度），并纳入第 IIb 节（AI 三种角色框架）的协同学习成果。

何时启用

在以下情况下使用此技能：

• 规划课程或课程设计，需要定义学习成果
• 创建评估内容，并希望使其与明确的目标保持一致
• 设计课程，并需要可衡量的认证成果
• 教育工作者要求“定义目标”“制定学习目标”“设定成果”或询问“学生应该取得什么成果？”
• 审查现有目标，并想知道它们是否足够具体
• 设计课程，不确定学生在结束时应该能够做什么

评估优先的目标设计（Constitution v4.0.1）

关键工作流：

1. 评估优先：在编写目标之前，先查看章节规范中的成功标准
2. 其次制定目标：设计能够达成评估成功的学习目标
3. 再次确保对齐：确保每个目标至少对应一项成功评估
4. 最后验证：确认目标可衡量且彼此对齐

模板：

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

请勿在缺少以下内容时制定目标：

• ✅ 对已批准且包含成功评估的规范的引用
• ✅ 明确的对应关系：目标 → 评估 → 业务目标
• ✅ 与评估标准一致的可衡量性

流程

步骤 1：了解背景

收到生成学习目标的请求时，首先了解：

• 主题或概念是什么？（Python 装饰器、OOP、async/await 等）
• 学习者是谁？（初学者、中级、高级）
• 教学时长是多少？（30 分钟、2 小时、完整单元）
• 最终目标是什么？（他们能构建某个东西吗？理解理论吗？调试代码吗？）
• 成功评估是什么？（来自章节规范——成功的定义是什么？）

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

如果你不熟悉特定主题的认知层次，请阅读： 📖 reference/blooms-taxonomy-programming.md

此文档将布鲁姆分类法的 6 个层次映射到编程情境，其中包括：

• 各层次的动作动词（记忆、理解、应用、分析、评价、创造）
• 编程示例
• 各层次的评估方法

步骤 3：识别先修知识

阅读先修知识分析指南： 📖 reference/prerequisite-analysis.md

针对你的目标，确定：

• 学习者在学习主要概念之前必须掌握什么？
• 列出记忆/理解层次的先修知识（无需深入掌握）
• 梳理依赖链，追溯到基础知识

步骤 4：选择评估方法

根据每个目标所属的布鲁姆层次，查看适当的评估方法： 📖 reference/assessment-methods.md

此指南帮助你为目标配对切实可行的评估方式（例如，为应用层次设计代码练习，为评价层次设计代码审查等）。

步骤 5：根据 CEFR 熟练度等级生成目标

针对每个主题，通常创建 3-5 个目标：

• 至少包含该主题所需每个等级的目标（从记忆到创造）
• 难度逐步提升
• 每个目标都应有清晰的陈述、背景、前置条件、评估方法和成功标准
• 映射到 CEFR 熟练度等级（A1/A2/B1/B2/C1）

请参考以下模板： 📄 templates/learning-objective-template.yml

核心原则：每个目标都应回答以下问题：

• 学习者将做什么？（布鲁姆等级对应的动词）
• 在什么背景下？（具体情境或问题）
• 如何判断他们是否成功？（可衡量的标准）
• 属于什么熟练度等级？（CEFR A1-C2）

CEFR 熟练度映射（Constitution v3.1.2）

将目标与国际熟练度标准对齐（来自 skills-proficiency-mapper v2.0）：

A1（初学者 - 识别）：

• 布鲁姆等级：仅限记忆/理解
• 示例：“识别用于定义函数的 Python 语法”
• 可衡量标准：识别，而非产出

A2（基础 - 有指导的应用）：

• 布鲁姆等级：在脚手架支持下进行理解/应用
• 示例：“根据提供的提示补全函数定义”
• 可衡量标准：在支持下应用

B1（中级 - 独立应用）：

• 布鲁姆等级：独立应用
• 示例：“根据明确的规范，在无需协助的情况下实现函数”
• 可衡量标准：无脚手架支持的真实场景应用

B2（中高级 - 分析）：

• 布鲁姆等级：分析/评价
• 示例：“比较两种实现，并论证哪种更易维护”
• 可衡量标准：带有论证的评价

C1（高级 - 创造/综合）：

• 布鲁姆等级：评价/创造
• 示例：“设计用于可扩展部署的系统架构”
• 可衡量标准：原创设计，并分析权衡取舍

熟练度进阶规则：课程应在一个章节内按 A1→A2→B1 的顺序递进（不要从 A1 跳到 C1）。

三角色 AI 协作目标（Section IIb，Constitution v4.0.1）

重要：原生 AI 学习目标必须包含与 AI 建立双向协作学习伙伴关系的能力（依据 Section IIb 的强制机制），而不能仅限于独立完成任务。

传统目标格式：

LO-001: Implement user authentication (independent skill)

原生 AI 目标格式：

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

三类角色目标：

1. AI 作为教师的目标（学生向 AI 学习）：

• “识别 AI 提出的、能提升代码质量的模式”
• “解释 AI 提出的方案中的权衡取舍”
• “将 AI 建议的模式应用到新的情境中”

2. AI 作为学生的目标（学生教 AI）：

• “编写能让 AI 首次尝试就生成正确代码的规范”
• “提供反馈以改进 AI 的下一次迭代”
• “当 AI 请求消除歧义时，澄清需求”

3. AI 作为协作者的目标（协作迭代）：

• “与 AI 迭代协作，逐步找到最优方案”
• “在 AI 负责战术性实现时做出战略决策”
• “验证 AI 输出的正确性和适用性”

原生 AI 目标集示例：

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

原生 AI 内容的目标占比：

• 60-70%：传统技术技能
• 20-30%：协作学习技能（与 AI 协作）
• 10-20%：验证/核验技能

步骤 6：验证目标是否可衡量

生成目标后，请调用验证脚本，检查目标是否可衡量：

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

脚本会检查：

• ✅ 目标是否使用了行动动词（而非“理解”或“知道”等模糊词语）
• ✅ 目标是否具体且可测试
• ✅ 动词是否与布鲁姆等级匹配
• ✅ 是否包含必填字段（背景、评估、成功标准）

如果验证失败，请查看错误消息并进行完善：

• 将模糊动词替换为布鲁姆等级中的具体行动动词
• 补充缺失的背景或成功标准
• 让陈述更加具体（而不仅仅是主题名称）

第 7 步：优化并定稿

根据验证反馈：

• 修改有误的目标
• 确保目标顺序合理（逐步递进）
• 确认先修知识必要且不过多
• 检查评估方法在可用时间内是否切实可行

输出格式

以清晰、结构化的格式呈现学习目标：

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"

验收检查

• 包含 SpecRef（章节规范路径和目标 ID）
• 目标不超过 5 个；仅使用可测量的动词
• 每个目标都包含布鲁姆分类标签（例如，L2-理解、L3-应用）
• 每个目标都包含与评估条目或任务对应的“Evidence”
• 目标符合复杂度等级限制（参见 Constitution）

目标片段

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

示例

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

用户请求：“为初学者编写 Python 列表推导式教学目标”

生成的目标：

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"

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

用户请求：“我正在讲授 OOP 基础知识。学生应该能够做什么？”

生成的目标：

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"

常见模式

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

• 1 个理解目标
• 1 个应用目标
• 1 个分析目标
• ~总计：3 个目标

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

• 1 个记忆目标（如果是基础主题）
• 1 个理解目标
• 2 个应用目标（不同情境／复杂度）
• 1 个分析目标
• ~总计：4-5 个目标

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

• 1 个记忆目标（术语）
• 1 个理解目标（概念）
• 2-3 个应用目标（多种情境）
• 1 个分析目标（关系）
• 1 个评价目标（质量）
• 1 个创造目标（综合）
• ~总计：7-8 个目标

模式 4：综合课程／项目课程

• 基础目标要求较低（记忆／理解）
• 多个复杂度逐步提高的应用目标
• 重点关注分析／评价／创造
• 以综合项目作为最终评估

故障排查

目标过于模糊

问题：“理解装饰器”

问题所在：无法测量。“理解”意味着什么？你如何知道他们是否理解？

解决方案：使用具体的动作动词并补充上下文

• ✅ “解释装饰器如何包装函数以改变其行为”
• ✅ “实现一个记录函数调用的自定义装饰器”

目标过多

问题：为 1 小时课程创建了 15 个目标

解决方案：减少到 3-5 个目标。请思考：

• 哪些是必需的？（保留）
• 哪些是“锦上添花”的？（删除或移至拓展内容）
• 是否有些目标重复？（合并）

先修知识要求过高

问题：先修知识包括“精通 Python”和“理解所有设计模式”

解决方案：尽量精简。请思考：“开始学习这个主题所需的绝对最低知识是什么？”

• 过高：“精通所有数据结构”
• 恰当：“理解列表如何使用索引”

想不到更高层次的布鲁姆分类目标

问题：只创建了记忆和应用目标

解决方案：

1. 阅读 blooms-taxonomy-programming.md §4-6，查看分析／评价／创造的示例
2. 思考：“学习者能用这些知识做什么？”（有助于提出创造目标）
3. 添加分析问题：“将这种方法与 X 进行比较……”
4. 添加评价问题：“这个解决方案适用于 Y 吗？为什么适用／不适用？”

与其他技能集成

此技能适用于以下技能：

→ exercise-pack 技能：制定学习目标后，使用该技能创建与每个目标的布鲁姆分类层次相符的练习题

→ technical-clarity 技能：使用该技能检查目标陈述是否清晰

新兴主题：Agentic AI 和 Model Context Protocol（MCP）

随着书籍越来越多地涉及高级 AI 主题，可使用此技能为以下主题定义学习目标：

Agentic AI 学习目标示例

主题：“构建自主 AI Agent”

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）学习目标示例

主题：“将 MCP 集成到 Python 应用程序中”

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"

进阶主题的关键注意事项：

• 这些主题可能需要更深入的先修知识（扎实的 Python 基础、API 设计知识）
• 采用螺旋式学习：以不断加深的层次重温概念（基础 Agent → 高级编排）
• 兼顾理论（理解架构）与实践（实现工具）
• 评估应着重考查实际问题解决能力，而不仅仅是定义

---

成功秘诀

1. 从目标出发：学习者应该能够做什么，而不是你将要教什么？
2. 让目标可测试：问问“我如何判断是否达成了这个目标？”
3. 保持布鲁姆分类法层级递进的一致性：从简单到复杂逐步构建
4. 列出先修条件：帮助学习者自我评估是否已做好准备
5. 经常验证：使用验证脚本找出含糊的表述
6. 让真实学习者试用：根据实际使用情况，目标往往需要调整

---

准备好生成目标了吗？ 请提供：

• 要教授的主题／概念
• 目标学习者的水平（初级／中级／高级）
• 可用的教学时间
• 最终目标（构建项目？理解理论？调试代码？）

或者粘贴现有目标，我会帮你让它们更易于衡量！