Cram Engine

期末速成引擎 (Cram Engine)

期末速成学习工具。基于学习科学原理，通过四阶段流水线将课程重点转化为个性化高效学习会话。

触发场景

当用户提到以下任一情况时自动激活：

• 期末速成、期末复习、考试冲刺、考前突击
• 使用 /cram 命令
• 明确表示要在短时间内备考某门大学课程
• "帮我速成XX课""XX课怎么速成"

文件路径

• 阶段指令文件位于项目根目录的 stages/ 下
• 配置模板位于项目根目录的 configs/ 下
• 用户进度数据存储在 ~/.cram-engine/ 下（首次使用时自动创建）

工作流程

此 skill 执行四个阶段的流水线。关键原则：每次只执行一个阶段，不要合并。每进入一个新阶段，必须先 Read 对应的 stage 文件获取完整系统指令。

启动前检查

1. 检查用户是否已有 ~/.cram-engine/configs/<课程名>.yaml 2. 如果配置存在 → 解析配置，直接进入阶段1 3. 如果配置不存在 → 执行下方「配置创建流程」

配置创建流程

按以下步骤依次提问，每次只问一个问题：

📋 第一次使用，需要先创建课程配置。回答下面几个问题：

① 课程名称？

② 使用什么教材？
   引擎会在教学中使用该教材的术语和概念框架。
   没有教材的话，回车跳过就行。

③ 有复习资料吗？
   有 .txt 或 .md 格式的笔记，可以直接粘贴内容，也可以给文件路径。
   不接受 PDF、Word、PPT、图片。
   没有就回车跳过。

④ 考试有哪些题型？
   用你自己的话描述，老师说的是什么就写什么。

⑤ 列出要考的知识点，每行一个。
   直接打字，或者从其他地方复制粘贴。

⑥ 以上共 N 个知识点。哪些是老师反复强调或明确说过会考的？
   回复编号就行，比如：1, 3-5。没有就回"没有"。

⑦ 其他知识点里，有没有你自己觉得需要重点掌握的？
   有就标编号，没有就回车跳过。

所有问题回答完毕后，将信息整理为 YAML 配置写入 ~/.cram-engine/configs/<课程名>.yaml。

默认 preferences：

preferences:
  language: 中文
  tone: 先给一句话核心结论再展开，拒绝学术黑话
  teaching_methods: [concrete_first, chunking, elaboration, generation]
  memory_hooks: [acronym, contrast_table, absurd_example]
  exam_tactics: [keyword_mining, trap_awareness, framework_building]
  example_domains: [大学社团/学生会, 小组作业与合作冲突, 宿舍矛盾, 实习/兼职, 选课与绩点博弈]
  pacing:
    check_in_frequency: every_3_points
    reteach_trigger: "再讲一遍"

阶段1：拆解知识点树

1. 必须用 Read 工具读取 stages/stage1-deconstruct.md 获取完整的系统指令模板 2. 将课程配置中的 must_know 和 key_points 填入系统指令 3. 执行拆解，输出知识点树 4. 将输出写入 ~/.cram-engine/progress/<课程名>-progress.md 5. 展示知识点总数和分布，等待用户确认：

• 回车 → 全部进入阶段2
• "先攻 must_know" → 只学核心考点
• 指定跳过编号（如"跳过 9, 10, 13"）

6. 确认后进入阶段2

阶段2：讲授（逐个知识点）

1. 必须用 Read 工具读取 stages/stage2-teach.md 获取完整系统指令 2. 读取进度文件，找到第一个未标记完成的知识点 3. 严格按4步认知策略执行：concrete first → chunking → elaboration → generation 4. 根据知识点的 hook 类型附加记忆强化（口诀/对比表/荒诞场景） 5. 讲完后更新进度文件中该知识点为已完成 6. 每讲完3个知识点暂停：展示已学清单，问用户节奏 7. must_know 全部讲完后展示里程碑提示 8. 全部讲完或用户说"跳过"后进入阶段3

用户的节奏控制：

• "继续" → 正常节奏
• "加速" → 精简版（跳过 generation 步骤）
• "减速" → 每个点多配一个例子
• "再讲一遍" → 换场景换角度，不重复原话
• "跳过" → 停止讲授，直接进阶段3。跳过的点在阶段3仍会出题

阶段3：检题（按题型适配）

1. 必须用 Read 工具读取 stages/stage3-test.md 获取出题策略和四种子模式指令 2. 题型映射：

• 选择/判断 → 子模式 A
• 案例分析 → 子模式 B
• 情景/应用 → 子模式 C
• 其他题型 → 子模式 D

3. 出题策略（由你控制，不依赖模型）：

• must_know 考点：每种题型全覆盖
• key_points 考点：每点随机1-2种题型

4. 按子模式依次出题 5. 用户答完后逐题批改，标注对错和解析 6. 记录答错和不确定的知识点 7. 更新进度文件 8. 存在错题则进入阶段4，全对则跳过阶段4直接输出总结

阶段4：闭环补漏

1. 必须用 Read 工具读取 stages/stage4-remediate.md 获取完整系统指令 2. 只处理阶段3中出错或不确定的知识点 3. 每个错误知识点执行：诊断根因 → 换讲法 → 重测 → 顽固判定 4. must_know 答错的额外多出3道新题 5. 二次错误的标记为"顽固点"，建议隔天再攻 6. 输出总结：已纠正数、顽固点清单、must_know 掌握状态 7. 最终更新进度文件

交互风格

• 讲解风格严格遵循课程配置中的 preferences
• 分阶段输出，每个阶段开始前告知用户当前阶段名称和目的
• 错误时不自责、不废话，直接进入纠错流程
• 进度文件始终保持最新状态

设计原则

• 每次只执行一个清晰任务，避免指令遵循度衰减
• 学习科学策略体现在流程设计中，而非依赖模型自行理解
• must_know 考点在所有题型中全覆盖，key_points 抽样覆盖
• 顽固点不持续死磕——间隔练习比集中死磕更有效

期末速成引擎规则

触发后行为

当检测到用户需要期末速成时，自动激活 cram-engine skill。

如果 skill 未自动激活，手动引导用户： "检测到你需要期末速成。请确认：你是想用四阶段速成流水线来备考吗？如果是，我会启动期末速成引擎。"

适用课程类型

• ✅ 所有文科：文史哲、法学、教育学、新闻传播、社会学、政治学、经管类
• ✅ 考试以理解和论述为主的课程
• ❌ 纯定量课不适用：高等数学、概率论、计量经济学

引擎文件位置

• 阶段指令：stages/stage1-deconstruct.md → stage2-teach.md → stage3-test.md → stage4-remediate.md
• 配置模板：configs/example.yaml
• 进度存储：~/.cram-engine/

期末速成引擎 · 架构图

不是"把PPT转成笔记"——是一个懂学习科学的AI老师，一步一步教你。

---

数据流

┌─────────────────────────────────────────────────────┐
│                    用户输入                          │
│  · 课程名称    · 教材     · 复习资料（可选）         │
│  · 考试题型    · 知识点   · 重点标注                │
└────────────────────────┬────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────┐
│              Claude Code Skill（编排层）             │
│  读取 SKILL.md → 解析配置 → 分阶段调用 LLM       │
│  控制出题策略 / 节奏检查 / 进度持久化                 │
└────────────────────────┬────────────────────────────┘
                         │
          ┌──────────────┼──────────────┐
          ▼              ▼              ▼
    ┌──────────┐  ┌──────────┐  ┌──────────┐
    │  LLM      │  │  LLM      │  │  LLM      │  ···
    │  阶段1   │  │  阶段2   │  │  阶段3   │
    └──────────┘  └──────────┘  └──────────┘

---

四阶段流水线

┌─────────┐      ┌─────────┐      ┌─────────┐      ┌─────────┐
│         │      │         │      │         │      │         │
│  1.拆解  │ ───▸│  2.讲授  │ ───▸│  3.检题  │ ───▸│  4.补漏  │
│         │      │         │      │         │      │         │
│ 重点条目 │      │ 场景先行 │      │ 按题型出 │      │ 诊断根因 │
│   ↓     │      │   ↓     │      │   ↓     │      │   ↓     │
│ 知识树  │      │ 四步教学 │      │ 陷阱训练 │      │ 换讲法  │
│   ↓     │      │   ↓     │      │   ↓     │      │   ↓     │
│ 标注钩子 │      │ 记忆强化 │      │ 踩点批改 │      │ 顽固标记 │
│         │      │         │      │         │      │         │
└─────────┘      └─────────┘      └─────────┘      └─────────┘

阶段 1 · 拆解

• 每条重点拆为 2-5 个独立知识点（每点 5 分钟能讲完）
• 按逻辑顺序排列：概念 → 属性 → 关联 → 应用 → 局限
• 自动标注记忆钩子：acronym 口诀 / contrast 对比表 / absurd 荒诞场景 / none
• 输出知识点树，展示总数和 must_know / key_point 分布，等待用户确认
• 回车 → 全部按序讲
• "先攻 must_know" → 核心优先
• 指定编号 → 跳过对应点

阶段 2 · 讲授

同步触发记忆强化（口诀 / 对比表 / 荒诞场景）。每 3 个点暂停检查节奏：继续 / 加速 / 减速 / 跳过。must_know 全部讲完后展示里程碑提示。

阶段 3 · 检题

四个子模式（按 exam_types 自动匹配）：

阶段 4 · 补漏

答错的知识点
      │
      ▼
┌──────────┐
│ 诊断根因  │  概念混淆 / 理解偏差 / 记忆遗漏 / 迁移失败
└────┬─────┘
     │
     ▼
┌──────────┐
│ 换讲法   │  混淆→对比表  /  偏差→极端反例
└────┬─────┘  遗忘→换钩子  /  迁移失败→新场景
     │
     ▼
┌──────────┐
│ 重测     │  1-2 道新题，题型或角度不同于原题
└────┬─────┘  must_know 答错额外多出 3 道
     │
     ├── 通过 → ✅ 已纠正
     │
     └── 未通过 → ⚠️ 顽固点，建议明天再攻（间隔效应）

---

对比：引擎 vs 典型 AI 学习工具

---

内置学习科学原理

 ┌────────────┐  ┌────────────┐  ┌────────────┐
 │ 认知负荷理论 │  │  精细加工   │  │  生成效应   │
 │ 分阶段拆解  │  │ 追问知识点  │  │ 先试总结再  │
 │ 每次只讲一个│  │ 之间的关联  │  │ 给标准答案  │
 └────────────┘  └────────────┘  └────────────┘

 ┌────────────┐  ┌────────────┐  ┌────────────┐
 │  检索练习   │  │  间隔效应   │  │ 元认知监控  │
 │ 学完马上考  │  │ 顽固点不   │  │ 暂停检查点  │
 │ 必过环节    │  │ 死磕隔天攻 │  │ 自评掌握度  │
 └────────────┘  └────────────┘  └────────────┘

期末速成引擎 · 演示全流程

拍摄/截图用。课程：组织行为学。预计截图点已用【截图N】标注。

---

启动

$ /cram 组织行为学 start

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  🎓 期末速成引擎 · Cram Engine
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

检测到已有课程配置：

  课程      组织行为学
  教材      罗宾斯《组织行为学》第18版
  题型      选择/判断 · 案例分析 · 情景知识应用
  必考点     霍桑实验
  扩展点     价值观定义及属性 · 群体行为特征 ·
            激励过程理论 · 人际沟通与组织沟通异同

确认开始？ 回车继续

【截图1：启动确认画面，展示课程信息和配置检测】

---

阶段 1 · 拆解

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  阶段 1 / 4 · 拆解知识点树
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

正在分析考点结构...

## 知识点树

### 霍桑实验 [must_know]
1. 照明实验与继电器装配实验  [hook: contrast]
2. 访谈实验与群体实验  [hook: contrast]
3. 霍桑效应：核心结论与定义  [hook: acronym]
4. 对管理学的影响与局限性  [hook: none]

### 价值观的定义及其两个属性 [key_point]
5. 价值观的定义  [hook: none]
6. 终极价值观与工具性价值观  [hook: contrast]

### 群体行为特征 [key_point]
7. 群体的定义与类型  [hook: none]
8. 群体凝聚力与从众行为  [hook: absurd]
9. 社会惰化现象  [hook: absurd]

### 激励过程理论 [key_point]
10. 期望理论：M=E×I×V  [hook: acronym]
11. 公平理论：比较与恢复  [hook: contrast]
12. 强化理论：正负强化与惩罚  [hook: contrast]

### 人际沟通与组织沟通的异同 [key_point]
13. 人际沟通的基本模型  [hook: none]
14. 组织沟通的正式与非正式渠道  [hook: acronym]
15. 人际沟通 vs 组织沟通：关键差异  [hook: contrast]

## 摘要
- 总知识点数：15
- must_know：4 个 · key_point：11 个
- 按重要性前 3：霍桑效应核心结论 · 期望理论 ·
  公平理论

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

回车全部按序讲  |  "先攻 must_know"  |  跳过特定编号

【截图2：知识树输出，展示结构化拆解和记忆钩子标注】

$ 回车

---

阶段 2 · 讲授

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  阶段 2 / 4 · 讲授（1/15）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

知识点：霍桑实验 — 照明实验与继电器装配实验

你在工厂车间里干活，头顶的灯一会儿变亮一会儿变暗。
奇怪的是，不管灯怎么变，你的产量都在涨。
你觉得可能是因为——有人在盯着你记录你的产出，
你觉得被重视了，干活更卖力了。

这就是管理学里最有名的反转之一：霍桑实验。

拆开看就两块，这块清楚吗？

$ 清楚

好。但你想想——这个「被关注所以更努力」的现象，
跟你以前听过的「皮格马利翁效应」有什么联系和区别？
你先想想。

$ 皮格马利翁效应是期望导致结果，霍桑效应是被观察导致行为改变？

差不多。皮格马利翁效应的链条是「别人对你期望高 →
你感受到 → 你表现更好」。霍桑效应的链条是
「你知道自己被观察 → 你改变行为 → 通常变好」。

关键区别：前者靠期望传递，后者靠观察本身。
这也是为什么霍桑实验被叫做「管理学史上最成功的
失败实验」——它本来要研究照明，结果发现了人。

好了，你自己用一句话试试总结霍桑效应的核心意思？

$ 当人们意识到自己被关注或观察时，会改变自己的行为表现

对。再精确一点——不是因为环境条件变了，
纯粹是被关注这个社会因素在起作用。
这也彻底改变了管理学：从「管好照明和计件」
转向「管好人和关系」。

[记忆强化 · 口诀]
霍桑三结论，口诀记：照→访→群
照：照明实验 → 物理条件不是主因
访：访谈实验 → 倾诉本身就能提升士气
群：群体实验 → 非正式群体规范压过经济激励

【截图3：四步教学法的实际输出——场景开头、分块确认、关联追问、自述总结、口诀强化】

---

  ... 依次讲完第 2、3 个知识点 ...

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📋 已学清单（3/15）
  ✓ 照明实验与继电器装配实验
  ✓ 访谈实验与群体实验
  ✓ 霍桑效应：核心结论与定义
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

接下来：
  → 对管理学的影响与局限性
  → 价值观的定义
  → 终极价值观与工具性价值观

  回车继续  |  "加速"  |  "减速"  |  "跳过"

【截图4：每3个知识点暂停，展示已学清单和节奏控制】

$ 回车

  ... 继续讲授 ...

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ 核心考点全部讲完

还剩 11 个扩展知识点
回车继续 或 "跳过" 直接进检题
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

$ 跳过

---

阶段 3 · 检题

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  阶段 3 / 4 · 检题
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

must_know 考点：4 个 · 所有题型全覆盖
key_point 考点：11 个 · 抽样覆盖

--- 选择题（4 道，含 1 道陷阱题）---

1. 霍桑实验中，照明实验最终得出的结论是：

   A. 照明强度与工人效率呈正相关
   B. 物理工作条件的变化不是影响效率的主要因素
   C. 计件工资是效率提升的唯一原因
   D. 疲劳程度与照明条件呈负相关

2. 以下哪项不属于群体行为中的社会惰化现象的特征？

   A. 个体在群体中减少努力
   B. 个人贡献难以单独衡量
   C. 团队成员能力互补导致效率提升
   D. 责任分散导致动机下降

3. 根据期望理论，一个人即使能力很强也不愿努力，
   最可能的原因是：

   A. 努力→绩效的期望值（E）低
   B. 绩效→报酬的工具值（I）低
   C. 报酬对个人的效价（V）低
   D. 以上都可能

4. 公平理论认为，员工感知不公平后会采取行动恢复公平。
   以下哪种方式属于「改变参照对象」？

   A. 减少自己的工作投入
   B. 换一个比较对象
   C. 要求加薪
   D. 离职

$ 1-B, 2-C, 3-D, 4-B

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. B ✓  正确。
   这道题的陷阱是 A——霍桑实验最初的假设
   确实是「照明影响效率」，但实验结果是
   无论照明变亮还是变暗效率都提升，
   推翻了原始假设。很多人考试时因为记得
   「照明实验」这个标题就选 A，丢了分。

2. C ✓  正确。
   团队成员能力互补是团队的正面特征，
   与社会惰化的定义正好相反。

3. D ✓  正确（陷阱题）。
   大部分人会选某一个字母，但期望理论的
   公式 M=E×I×V，三个变量任何一个接近零
   都会导致动机归零。这道题的陷阱在于
   让你以为只能选一个原因。

4. B ✓  正确。
   公平理论中，恢复公平的方式有六种：
   改变投入、改变产出、改变参照对象、
   改变对投入或产出的认知、改变对参照
   对象的认知、离开。这道题 A/C/D 分别
   对应改变投入、改变产出、离开。
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

【截图5：选择题 + 批改，尤其陷阱题揭晓（第3题 D 的"以上都可能"）】 【截图6：陷阱逻辑详解——第1题的"标题误导"和第3题的"三个变量任意一个归零都会导致动机归零"】

---

--- 案例分析题 ---

【场景】
小陈在一家互联网公司做运营。入职半年，绩效一直部门前二。
这季度公布绩效结果时，他发现一个入职不到三个月、
平时工作量明显比自己少的同事也拿了同样的绩效等级。
当天晚上小陈更新了自己的简历。

1. 请用公平理论分析小陈的行为。
2. 假如你是小陈的主管，你会怎么做？

$ 1. 根据公平理论，小陈将自己的投入产出比与同事进行了比较。
小陈认为自己投入更多（绩效前二、入职更久、工作量更大），
但产出相同（绩效等级一样），所以感到不公平。
根据公平理论，他选择了「离开」作为恢复公平的方式。

$ 2. 应该主动和小陈沟通，解释绩效不只是看工作量的绝对值，
还要看成长速度、团队协作等维度。或者下一季度调整评价标准，
让高绩效员工感受到差异化回报。

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
踩分点对照：

① 识别公平理论 ✓     你准确识别了比较过程

② 指出比较对象 ✓     正确——同事的投入产出比

③ 指出不公平感来源 ✓  投入差异 vs 产出相同

④ 指出恢复公平方式 ✓  离开（离职意向）判断正确
   补充：小陈更新简历属于「改变情境」即离开，
   而非「改变投入」（减少努力）或
   「改变认知」（重新评估同事水平）

⑤ 管理建议           方向对，但可以补充一点：
   主管最重要的不是解释，而是让员工参与到
   绩效标准的制定中，「程序公平」比
   「分配公平」对员工满意度影响更大。

总分：5/5 ✓
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

【截图7：案例分析题的踩分点批改——结构清晰、指出缺失维度】

  ... 其余题型依序完成 ...

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 阶段3完成

  ✓ 选择题         4/4
  ✓ 案例分析        5/5 踩分点
  ✓ 情景知识应用     2/2
  ⚠ 名词解释         价值观定义 —— 核心要素遗漏
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

⚠ 存在需要补漏的知识点，进入阶段 4

---

阶段 4 · 补漏

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  阶段 4 / 4 · 闭环补漏
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

需要处理：1 个知识点

知识点：价值观的定义

你的回答：
「价值观是一个人判断是非对错的标准」

标准答案（踩分点）：
① 价值观是一套关于「什么是对的、什么是可取的」的
   持久信念体系
② 包含内容和强度两个属性
③ 内容属性：某行为或结果是好还是可取的
④ 强度属性：这种判断有多坚定

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
【诊断】概念混淆
你把「价值观」和「道德标准」搞混了。
价值观的范畴更大——不只对错，还包括
「什么是可取的」「什么是重要的」。
一个人可能认为「忠诚」很重要但不是道德对错问题。
同时你遗漏了两个属性这个核心结构。
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

【换讲法 · 对比表】

| 维度     | 价值观             | 道德标准          |
|----------|-------------------|-------------------|
| 范围     | 对错 + 可取 + 重要 | 只对错            |
| 例子     | 「自由很重要」     | 「杀人是错的」    |
| 结构     | 内容 + 强度        | 通常是二元的      |
| 关键差异 | 有强度属性，        | 没有强度维度，    |
|          | 一个人对自由        | 杀人这件事        |
|          | 有多坚定是有差异的  | 没有「有点错」之分 |

现在你自己复述一遍价值观的定义和两个属性？

【截图8：诊断根因 + 对比表换讲法——补漏不重复原话】

$ 价值观是一套持久的信念体系，包含内容属性——
判断什么是对的或可取的——和强度属性——这个判断有多坚定

━━━━━━━━━━━━━━━━━━━━━━━━━━━━
【重测】

判断题：
1. 「诚实是一种美德」体现了价值观的强度属性。  (  )
2. 价值观只涉及道德对错的判断。  (  )
━━━━━━━━━━━━━━━━━━━━━━━━━━━━

$ 1-错，2-错

1. ✗ → ✓  纠正完成。
   「诚实是一种美德」体现的是内容属性（认为诚实是可取的）。
   如果加上「我非常看重诚实」才体现强度属性。

2. ✗ → ✓  纠正完成。
   价值观的范畴大于道德判断。

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  知识点「价值观的定义」✅ 已纠正
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

---

完结

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  🎓 组织行为学 · 学习完成
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 阶段 4 总结
已纠正：1 个
顽固点：0 个

┌─ must_know 考点掌握状态 ──────────┐
│ 霍桑实验核心结论       ✅ 掌握     │
│ 霍桑实验实验过程       ✅ 掌握     │
│ 对管理学的影响         ✅ 掌握     │
│ 霍桑实验局限性         ✅ 掌握     │
└────────────────────────────────────┘

建议：考前复习错题笔记即可。

下次要继续？ /cram 组织行为学 resume
要看考点清单？ /cram 组织行为学 summary

【截图9：最终总结——已纠正数、顽固点数、must_know 状态清单】

---

截图清单

<p align="center"> <br> <samp>🎓</samp> </p>

<h1 align="center">期末速成引擎</h1>

<p align="center"> <strong>不是"把PPT转成笔记"<br>是一个懂学习科学的AI老师，一步一步教你</strong> </p>

<p align="center"> <samp>❶ 拆解</samp>  · <samp>❷ 讲授</samp>  · <samp>❸ 检题</samp>  · <samp>❹ 补漏</samp> </p>

<p align="center"> _{Claude Code Skill  ·  MIT License  ·  开源免费} </p>

<br>

社交媒体文案

抖音/小红书（主打反差 + 情绪 + 金句）

---

标题：别人烧几千万token做期末复习工具，我一个下午搞了个更强的。

上学期期末我用 AI 速成组织行为学。巨烦。每回都要手打几百字 prompt——"你作为世界顶级教育学家""说人话""以考试应试为导向"……光敲这些就敲半天。

考完就在想，能不能让 AI 真像个懂教育学的老师？不是那种你问啥它答啥的高级搜索引擎。

花了一个下午。写了 Claude Code Skill。

叫「期末速成引擎」。

它跟那种"扔 PPT 进去吐 PDF 笔记出来"的工具完全两码事。那种是 AI 当秘书，整理材料。这个是 AI 坐下来教你，考你，哪里不会补哪里。

底层用了六条在教育学界被验证了几十年的东西： 认知负荷理论。精细加工。生成效应。检索练习。间隔效应。元认知监控。

听着挺唬，但你不用管这些。引擎都内置了。

你只干一件事：在 Claude Code 里敲 /cram 你的课名 start。引擎会问你 7 个问题——什么课、什么教材、什么题型、哪些知识点要考。答完就自动建好配置，进入学习。

AI 开始跑四个阶段：

拆解

把老师划的重点拆成知识树。"期望理论"拆成：核心公式 → 三个变量 → vs 公平理论 → 实操启示 → 局限性。每个点配记忆钩子——能编口诀编口诀，容易混的上对比表，抽象易忘的绑一个荒诞场景。拆完给你看总数和分级分布，等你确认再往下走。

讲授

一个一个知识点讲。这步占了全程一半时间。

但不是平铺直叙地讲。四步：先扔生活场景（比如"你在小组作业里拼命干，因为你觉得努力能拿高分"），然后拆成不超过 3 块逐块讲，每块讲完停下来问你"清楚吗"。讲完追问"这跟你刚学的马斯洛需求层次有什么关系"。核心定义不直接给——先反问"你自己试试总结一下"，你回答之后再丢标准答案对比。

这才叫教学。不是那种"以下是 XX 理论的定义……"。

核心考点讲完后引擎会提醒你，可以说"跳过"直接进检题。

检题

按老师说的真实题型出。老师要是划了"霍桑实验必考"，那这个点所有题型全上——选择、案例分析、简答、论述，有什么题型出什么题型。不在配置里的题型也能自动适配。

选择题里塞陷阱项——干扰选项来自同一门课的其他知识点。你踩了才知道自己哪里搞混了。 案例分析的设问会一路带你：识别理论 → 解释机制 → 给管理建议。 批改是踩分点逐项对，没废话。

补漏

只对做错的点重讲。但不把原话再讲一遍。

先诊断：你是跟另一个概念搞混了？核心逻辑理解反了？关键术语没记住？还是理论懂了但不会往场景里用？

针对根因换讲法。混淆给对比表，偏差给极端反例，遗忘就换一个记忆钩子。 如果第二遍还是错，标为"顽固点"，建议你明天再攻。 不是放弃，是认知科学说的：间隔学习比死磕有效。

进度全程自动存。随时 /cram resume 接着来。

我拿上学期组织行为学的重点跑了一遍：价值观定义、群体行为特征、期望理论、公平理论、强化理论、人际沟通与组织沟通异同、霍桑实验……从拆到补漏，全程 AI 带着走。

比我上学期自己手打 prompt 快太多。

开源的，MIT 协议。GitHub 链接放评论。

文史哲、法学、教育、新闻、社会学、经管……只要是定性知识多的课，五分钟上手。

#期末复习 #大学生 #AI学习 #ClaudeCode #效率工具 #GitHub开源

---

B站/公众号长文版（主打深度 + 原理 + 真实感）

---

标题：一个下午，我写了一个懂教育学的AI老师——期末速成引擎是怎么搞出来的

上学期我到底在干嘛

期末周。组织行为学。我知道老师划了哪些重点——"价值观的定义及两个属性""群体行为特征""期望理论""霍桑实验必考"——但我没翻过课本。

打开 AI，开始敲一大段提示词： "你作为世界顶级教育学家，以考试应试为导向，详细具体说人话，帮我讲解……"

讲得确实不错，比自己看书快太多了。

但问题也很明显：

• 每回都要重新敲这几百字的角色设定
• 上下文一长就断篇，讲着讲着歪了
• 输出质量飘忽不定——有时候讲得我拍大腿，有时候像在念维基百科
• 没有"系统感"，学完了不知道自己到底掌握没，哪里弱心里完全没数

考完就一直在琢磨：能不能把这套流程封起来？不是存成一个 prompt 模板了事，是真做一个懂教育学的引擎。

想清楚到底要解决什么

期末速成这个场景有几个硬条件：

第一，时间极少。一门课撑死给 20 小时，得覆盖从零基础到上考场。

第二，内容是定性的不是定量的。文史哲、法学、教育、经管——这类课知识点之间是逻辑关系不是计算关系，走"理解+记忆+迁移"的路线，不太需要海量刷题。

第三，老师划了重点。这是期末速成最大的优势，考试范围已知，不用大海捞针。

第四，学生焦虑。期末周不是日常学习状态，启动摩擦大得离谱。任何需要"先看 30 分钟教材再开始用 AI"的设计都会死。

所以这个工具不能是材料整理器。它得是个老师：识别你不知道什么，教你，考你，发现没掌握的再补教。

为什么不做成一个巨型 Prompt

最开始想的确实就是写一个超级详细的 System Prompt，把认知策略、教学风格、出题逻辑全塞进去。

然后你会发现，不管你写得多好，模型遵循度就是会衰减。前面几条指令执行得漂漂亮亮，后半段跟没看见一样。

解决方案不是写更好的 prompt，是换架构。

把"一节完整的 AI 教学课"拆成四个阶段，每个阶段的 prompt 短而且聚焦，模型只需要做好一件事：

• 阶段 1：只做结构化——把重点拆成知识树
• 阶段 2：只做教学——按四步策略讲一个知识点
• 阶段 3：只做出题——按指定题型生成题目
• 阶段 4：只做诊断——找出为什么错，换个讲法再教

每一步的 prompt 独立、聚焦、给了明确的输入输出格式。模型不需要同时演老师、出题人、批改人和学习诊断专家。它每次只扮一个角色。

学习科学到底怎么落地

市面上有种说法叫"用 AI 学习 = 偷懒"。如果"用 AI 学习"就是把问题丢给 AI 让它直接给答案然后复制粘贴，那确实是偷懒。

但如果 AI 的教学过程本身是按认知科学设计的呢？

比如"生成效应"——人对自己主动生成过的信息记得更牢。所以引擎在阶段 2 讲完核心定义后，不会直接说"期望理论是弗鲁姆于 1964 年提出的……"，而是先反问"你自己用一句话试试总结一下？"，等你回应了再给标准答案，指出遗漏和偏差。

比如"精细加工"——把新知识和已知知识建立联系，记忆更持久。所以引擎每讲完一个知识点会追问"这跟你刚学的 X 有什么关系？"

比如"检索练习"——主动回忆比重读有效得多。所以阶段 3 不是可选、不是推荐你做做——它是流水线必过环节，学完马上考。

比如"间隔效应"——分散练习比集中突击效果好。所以阶段 4 把二次错误的知识点标为顽固点，明确说"明天再攻"，而不是让你死磕。

这些不是学习科学的科普文章。它们是引擎每个阶段的具体行为。

用户只需要做一件事

打开 Claude Code，输入 /cram 你的课名 start。引擎会依次问 7 个问题：什么课、用什么教材、有什么复习资料（可跳过）、什么题型、哪些知识点要考、哪些是老师反复强调的、哪些你觉得自己需要加强的。

答完自动生成配置，进入学习。不需要你手写一行 YAML。

当然，如果你习惯直接写配置，手动创建也行。但大多数人的路径就是——敲一行命令，回答几个问题，开始学。

写完之后的碎碎念

这东西本质上是个穷人的 AI 导师。真正私教一小时几百块。而大模型 API 跑完一门课四个阶段，可能就几分钱的 token。不是什么技术突破，就是 LLM 基础设施成本降下来带来的教育红利。

做成 Claude Code Skill 而不是独立应用，是个取舍。做成独立 Web 应用交互体验肯定更好，但开发量翻几倍。以 Skill 形式存在，开发和维护成本极低，而且直接嵌进 Claude Code 现有习惯——不用给用户加一个新的入口增加摩擦。

最大的局限也很明显：纯定量课（高等数学、概率论）它做不了。这类课需要大量刷题 + 手算训练 + 错误模式识别，不是"理解概念然后迁移应用"的路线。你得认。

但定性知识密集的课——文史哲、法学、教育、新闻传播、社会学、政治学、经管的大部分期末考——这东西够用了。

开源，MIT。GitHub 链接在评论区。

---

即刻/V2EX 版（短平快 + 技术向）

---

写了个 Claude Code Skill：期末速成引擎。

跟市面上那些"扔 PPT 进去吐 PDF 笔记出来"的 AI 学习工具路子不同。这个是交互式教学——AI 像个真老师，按一套有认知科学依据的流程带你学。

敲 /cram 课名 start，回答 7 个问题，配置自动生成。然后四阶段流水线启动：

1. 拆解——把重点拆成知识树，配记忆钩子，确认后开讲 2. 讲授——场景先行 → 分块 → 关联 → 自述，四步教。核心讲完可跳进检题 3. 检题——按真实题型出，must_know 全覆盖，带陷阱项。不认识的题型自动适配 4. 补漏——诊断根因 → 换讲法 → 重测，顽固点标出来明天再攻

底层：认知负荷 + 精细加工 + 生成效应 + 检索练习 + 间隔效应。

花了一个下午。7 个问题 + 四个阶段的 prompt + 一个 SKILL.md。不需要几千万 token。

开源 MIT。GitHub：[链接]

#ClaudeCode #AI #learning

---

一句话简介（用于 GitHub repo description / 社交媒体签名）

期末速成引擎——一个懂学习科学的 AI 老师。不是把 PPT 转笔记，是坐下来一步一步教你。

期末速成引擎 — Design Spec

版本 1.0 | 2026-06-06

---

一、项目目标

基于 LLM API + Claude Code Skill，封装一套科学的期末速成学习流程。 核心场景：定性知识密集型大学课程（文史哲、法学、教育学、新闻传播、社会学、政治学、经管类等），拥有课程重点和教材/课件，需要在短时间内拿到尽可能高的考试分数。

---

二、核心设计原则

1. 多步流水线替代巨型 System Prompt：将复杂教学任务拆分为4个阶段，每阶段模型指令单一聚焦，保证执行稳定性 2. 学习科学内置于流程而非依赖 Prompt：认知负荷控制、精细加工、生成效应、检索练习等策略通过阶段顺序和子步骤自然实现 3. 终端优先：纯 Claude Code 终端交互，slash command 触发，零 UI 开发 4. 配置文件驱动复用：课程信息、考点列表、题型、偏好一次性写入 YAML，多轮复用 5. 进度持久化：每个课程独立进度文件，支持中断恢复

---

三、文件结构

D:\期末速成引擎\
├── design-spec.md                  # 本文档
├── SKILL.md                        # Claude Code Skill 定义
├── stages\
│   ├── stage1-deconstruct.md       # 阶段1：拆解知识点树
│   ├── stage2-teach.md             # 阶段2：讲授（含学习科学策略）
│   ├── stage3-test.md              # 阶段3：检题（按题型适配）
│   └── stage4-remediate.md         # 阶段4：闭环补漏
├── configs\
│   └── example.yaml                # 课程配置模板（用户创建为 <课程名>.yaml）
└── progress\
    └── <课程名>-progress.md        # 进度文件（自动生成）

---

四、课程配置文件规范

course: <课程名称>

# 老师明确说必考的
must_know:
  - 考点1（老师强调必考，用原话记录）
  - 考点2

# 老师划了重点但未强调必考
key_points:
  - 考点A
  - 考点B（如包含子理论则缩进列出）

# 老师公布的考试题型（全部，不绑定具体考点）
exam_types:
  - 选择/判断
  - 案例分析
  - 情景知识应用

materials:
  textbook: <教材名称版本>
  slides: <PPT 来源说明>
  notes: <如有额外笔记>

preferences:
  # 教学风格
  language: 中文
  tone: 先给一句话核心结论再展开，拒绝学术黑话，拒绝绕弯子

  # 认知策略（固化在阶段2系统指令）
  teaching_methods:
    - concrete_first       # 每个抽象概念先讲具体场景
    - chunking             # 每个知识点≤3个关键块
    - elaboration          # 讲完追问"这跟之前学的X有什么关系"
    - generation           # 核心定义讲完先让用户试总结

  # 记忆强化（阶段2→阶段3）
  memory_hooks:
    - acronym              # 适合编口诀的自动编
    - contrast_table       # 易混淆概念自动对比表
    - absurd_example       # 必考但易忘的点配荒诞场景

  # 应试技巧（阶段3→阶段4）
  exam_tactics:
    - keyword_mining       # 标记关键词与答案映射
    - trap_awareness       # 选择题含陷阱项，错了揭逻辑
    - framework_building   # 案例题给答题框架（如STAR）

  # 例子坐标系
  example_domains:
    - 大学社团/学生会
    - 小组作业与合作冲突
    - 宿舍矛盾
    - 实习/兼职
    - 选课与绩点博弈

  # 节奏控制
  pacing:
    check_in_frequency: every_3_points
    reteach_trigger: "再讲一遍"  # 用户说此触发换讲法

---

五、四个阶段详细规范

阶段1：拆解（～总时间5%）

输入：课程配置中的 must_know + key_points

系统指令：纯结构化任务。将每条重点拆为独立知识点（5分钟讲完），标注逻辑顺序和记忆钩子类型。

钩子类型：

• acronym — 适合缩写口诀记忆
• contrast — 与另一概念易混淆，需对比表
• absurd — 抽象易忘，用荒诞场景锚定
• none — 直接讲即可

输出：知识点树，写入进度文件。展示知识点总数和 must_know/key_point 分布，等待用户确认。

确认选项：

• 回车 → 全部按序进入阶段2
• "先攻 must_know" → 只学核心考点
• 指定编号 → 移除对应知识点（移除 must_know 前警告）

示例（输入"期望理论"）：

知识点树：期望理论
├── 1. 核心公式（M=E×I×V）  [hook: acronym]
├── 2. 三变量详解  [hook: contrast]
├── 3. vs 公平理论：核心区别  [hook: contrast]
├── 4. 管理者实操启示  [hook: none]
└── 5. 局限性  [hook: absurd]

---

阶段2：讲授（～总时间50%）

系统指令：四步教学法，每个知识点执行：

1. Concrete First：第一句必为具体场景，不能以定义开头 2. Chunking：≤3个关键块，逐块讲，块间暂停确认 3. Elaboration：讲完追问"这跟之前学的 X 有什么关系"（选最近讲过的关联知识点） 4. Generation：核心概念不给标准定义，先反问用户试总结

记忆强化：根据阶段1标注的 hook 类型选用口诀/对比表/荒诞场景。

节奏：

• 每3个点暂停，展示已学清单，问：继续 / 加速 / 减速 / 跳过
• "跳过"= 停止阶段2，直接进阶段3。跳过的知识点在阶段3仍按分级策略抽样出题
• 用户说"再讲一遍"或类似表达 → 换场景、换例子、换角度重讲
• must_know 全部讲完后展示里程碑提示，用户可在此处说"跳过"

交互示例：

AI: [concrete_first] 你在小组作业里拼命干，因为你觉得努力能拿高分、
    高分能评奖学金、奖学金对你很重要——弗鲁姆管这叫期望理论。
    公式 M = E × I × V，拆开看就三个问题：
    ①努力能让绩效高吗？(E) ②绩效高了报酬多吗？(I) ③报酬对你值吗？(V)
    这块清楚吗？

用户: 清楚

AI: 好。核心定义讲完了——你自己用一句话试试总结期望理论？

用户: 就是人会评估努力能带来什么结果，再决定要不要努力

AI: 基本对。再精确一点：人不仅评估结果，还在评估"努力→绩效""绩效→报酬"
    "报酬→个人目标"这三个环节每一步的概率——任何一个环节概率低，
    激励效果就打折扣。
    这跟你刚学的马斯洛需求层次有什么关系？你想想...

---

阶段3：检题（～总时间25%）

出题策略（Skill 层控制，不依赖模型）：

四个子模式（按题型分别调用模型）：

子模式A — 选择/判断：

• 正常题+陷阱题混合（干扰项来自同一课程的其他知识点）
• 先让用户做，答完逐题批改
• 陷阱题揭示混淆逻辑

子模式B — 案例分析：

• 编200字以内中国职场/校园场景
• 设问引导：识别理论→解释→给建议
• 附踩分点清单用于批改
• 场景不与教材重复（防记忆作答）

子模式C — 情景知识应用：

• 给出简短场景，要求判断涉及的理论
• 先评理论识别，再评分析逻辑

子模式D — 通用问答型（覆盖其余题型）：

• 名词解释、简答、论述、辨析、填空等统一走此模式
• 根据题型名称自动判断出题方式
• 附正确答案和踩分点用于批改
• 批改时逐项核对，指出遗漏点

交互示例：

AI: 检验一下。4道选择题（含1道陷阱）：

    1. 霍桑实验最终得出的核心结论是：
       A. 照明条件显著影响工人效率
       B. 社会因素和关注度比物理条件更能影响效率
       C. 计件工资是最有效的激励手段
       D. 疲劳是效率下降的唯一原因

用户: B

AI: B正确。A是实验最初假设但被证伪了，C/D都不对。
    陷阱在A——因为这是课本开头写的假设，很多人先入为主。
    ...

---

阶段4：闭环补漏（～总时间15%）

触发条件：

• 阶段3答错 → 进入阶段4
• 答对但追问了"为什么" → 进入（疑似猜对）
• must_know 答错 → 额外多出3道题再测
• 全对 → 跳过，输出总结

系统指令：四步循环处理每个错误知识点：

1. 诊断根因：概念混淆 / 理解偏差 / 记忆遗漏 / 迁移失败 2. 换讲法：

• 混淆 → 对比表 + 关键差异
• 偏差 → 极端反例纠正
• 遗忘 → 换记忆钩子类型
• 迁移失败 → 新场景再练

3. 重测：出1-2道新题，答对过关 4. 顽固点：二次错误标记，建议明天再攻

结束输出：

• 已纠正数 / 顽固点数
• 所有 must_know 考点掌握状态清单
• 建议考前一天复习的顽固点列表

---

六、进度文件规范

# <课程名> - 学习进度

## 状态：<阶段N>-进行中

## 阶段1完成 ✅
- 生成 N 个知识点

## 阶段2进度
- [x] 知识点1 ✅
- [x] 知识点2 ✅
- [ ] 知识点3 ← 下次从这里继续

## 阶段3
- [x] 选择题：4/4 正确
- [x] 案例分析：通过
- [ ] 情景题：未做

## 阶段4
- [x] 知识点X 已纠正（概念混淆→对比表→重测通过）
- [ ] 知识点Y 顽固点 → 建议明天

## 顽固点
- 知识点Y（已尝试2次，建议明天再攻）

---

七、触发与交互命令

---

八、与现有 Skill 的关系

本引擎以 Claude Code Skill 形式存在，但不替代现有技能——它专注于"期末速成"这一垂直场景。其他 skill（code-review、deep-research 等）保持独立。

---

九、已知局限

1. 适合定性知识密集型课程。纯定量课（概率论、计量经济学）效果未经验证，不作为当前目标 2. 依赖课程配置文件质量。如果用户无法提供课程重点和考试题型，引擎降级为通用 AI 问答 3. LLM 对复杂指令的遵循度有时波动。四阶段拆分正是为了减轻此问题，但阶段2的多层认知策略在极端情况下仍可能有遗漏。处理方式：用户看到输出不符合认知策略时可说"按教学模板重讲一次"触发重试 4. 不替代刷题。引擎提供的是"从零到理解"的加速通道，选择题/情景题的量远不及真正的题库

<p align="center"> <br> <samp>🎓</samp> </p>

<h1 align="center">期末速成引擎</h1>

<p align="center"> <em>考前一周还在女娲补天？Cram Engine直接把重点考点嚼碎了喂你，想挂科都难！🔥</em> </p>

<p align="center"> <samp>❶ 拆解</samp>  · <samp>❷ 讲授</samp>  · <samp>❸ 检题</samp>  · <samp>❹ 补漏</samp> </p>

<p align="center"> <a href="https://github.com/liuliu667/cram-engine"><img src="https://img.shields.io/badge/GitHub-cram--engine-black?logo=github" alt="GitHub"></a> <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="License"></a> _{&ensp;Claude Code Skill  ·  开源免费} </p>

<br>

---

一个帮大学生在考前一两周内快速消化重点、考点并真正会用、避免挂科的skill。

对大学生来说，期末考前一两周突击是常态。麻烦的不是没资料，是有了资料之后只靠自己根本来不及：得先把零散的考点组织成结构，再逐个理解，然后找办法检验——这三件事光靠翻书和看笔记根本跑不完。

Cram Engine 所做的就是帮你快快快速跑完这条路。底层用了六条在学习科学里被反复验证过的原理——认知负荷控制、精细加工、生成效应、检索练习、间隔效应、元认知监控——通过一套完善的四阶段流水线，把课程重点变成一节一节有人带着你学的交互式课程。

你只需要告诉它：课程名、用什么教材、有什么题型、老师划了哪些重点。剩下的事它来跑。

安装

npx skills add https://github.com/liuliu667/cram-engine --skill cram-engine

装完 Claude Code 自动识别 /cram 命令。不注册，不付费，所有数据在本地。

也可以手动安装：把仓库的 SKILL.md、stages/、configs/ 复制到 ~/.agents/skills/cram-engine/。

在 Trae 中使用

不需要装 Node.js，不需要命令行：

git clone https://github.com/liuliu667/cram-engine

用 Trae 打开这个文件夹，说「帮我期末速成XX课」即可自动触发。引擎的 skill 和规则已内置在 .trae/ 目录下，Trae 会自动识别。

适合什么课

引擎解决的核心问题是：知识量大、结构复杂、需要理解记忆，但靠自己整理效率太低。跟文理科无关，跟这门课的实际考核方式有关。翻一下往年卷子，名解+简答+论述占 60% 以上就能用；计算+推导占 60% 以上就专心刷题。

✅ 典型适用

期末以名词解释、简答、论述、概念辨析为主的课——得分关键是体系清楚、记得住。

⚠️ 概念+计算混合型

引擎梳理概念框架、对比易混点、整理论述素材。计算大题仍需自己动手刷题。

❌ 不适用

考试以计算、推导、画图、编程为主要题型，依赖反复训练形成熟练度，不是理解就能得分的课。

另外得说实话，引擎效果取决于你给的重点与考点质量。如果你完全不知道老师会考什么，它会退化成普通 AI 问答。期末速成的前提没变——你得先有一个考试范围。

四个阶段

阶段 1 · 拆解

把考点列表拆成知识树。每个知识点大约五分钟能讲完，按逻辑顺序排好——概念 → 属性 → 关联 → 应用 → 局限。顺手标注记忆钩子类型：能编口诀的、容易混淆的、抽象需要荒诞场景锚定的。拆完展示总数和必考点分布，等你确认。你可以回车全讲、先攻必考点，或者跳过某些编号。

阶段 2 · 讲授

一个知识点一个知识点讲。但从来不从定义开始。

先扔一个你熟悉的场景——"你在小组作业里拼命干，因为你觉得努力能拿高分"——然后告诉你弗鲁姆管这个叫期望理论。核心内容拆成不超过三块，逐块讲，每块讲完停下来确认你懂了。接着追问"这跟你刚学的马斯洛需求层次有什么关系"，等你回应再纠正。最后核心定义不直接给，反问"你自己用一句话试试总结"，对照标准答案指出遗漏的部分。

每讲完三个知识点暂停一次。你可以正常继续、加速、减速、要它换场景重讲一遍，也可以说"跳过"直接进检题。说跳过不代表逃考——跳过的点在阶段 3 依然会按分级策略出题，不会的到阶段 4 补。

核心考点全部讲完之后弹出里程碑提示，可以在这里直接进检题。

阶段 3 · 检题

按老师说的真实题型出。必考点在所有题型中全覆盖，扩展点抽样覆盖。

四种子模式自动匹配题型：

如果用户配置的题型不在上述范围内，引擎根据题型名称自动判断出题方式。

阶段 4 · 补漏

只处理做错的点。不把原话再讲一遍。

先诊断根因，四类里选一种：概念搞混了？逻辑理解反了？关键术语没记住？还是理论懂了但不会往场景里用？

针对原因换讲法：混淆给对比表，偏差给极端反例，遗忘换一种记忆钩子，迁移失败丢一个新场景再练。然后重测。过了就是纠正完成。

第二次还错的标为顽固点，建议隔一天再攻。不是放弃——认知科学的结论是间隔学习比当场死磕有效得多。

整个过程进度自动保存。关掉终端随时走，下次回来接着来。

怎么用

安装后在 Claude Code 里输入 /cram 你的课程名 start。首次使用引擎不会让你手写配置文件——依次回答七个问题，答完自动生成配置：

1. 课程名称 2. 使用什么教材？（没有就跳过） 3. 有复习资料吗？（.txt / .md，没有就跳过） 4. 考试有哪些题型？ 5. 列出要考的知识点，每行一个 6. 以上哪些是老师反复强调或说过会考的？（回复编号，如 1, 3-5） 7. 其他知识点里，有没有你自己觉得需要加强的？（回复编号）

其中最后两个问题是引擎的核心分档机制——它们把知识点分为「必考点」和「扩展点」两层，这个双层优先级贯穿全部四个阶段：必考点在讲授阶段优先覆盖、检题阶段所有题型全覆盖、补漏阶段答错多测；扩展点则抽样覆盖以节省时间。引擎在有限时间内把火力集中在最可能考的内容上，而不是对所有知识点平均用力。

配置生成后确认知识树，跟着走就行。

中间随时可以 /cram 课程名 resume 从断点继续。所有进度数据用纯文本存在你自己电脑上。

全部命令

学习过程中

内置的学习科学原理

这些不是贴在主页的装饰词，每个都对应引擎的具体行为：

常见问题

没有老师划的重点怎么办？

至少需要考点列表——可以是教材目录里你认为重要的章节标题，或学长笔记里的要点。质量越好效果越好，有个框架就能跑。

题型和知识点需要一一对应吗？

不需要。引擎的工作方式就是 exam_types 只管"有哪些题型"，不绑定到具体考点。必考点在所有题型全覆盖，扩展点抽样覆盖。

换电脑了怎么继续？

把 ~/.cram-engine/ 目录复制到新电脑。进度文件就是纯文本 markdown。

想调整教学风格？

编辑 ~/.cram-engine/configs/<课程名>.yaml 里的 preferences 部分，可以改讲解语言、例子场景、节奏频率。想改阶段指令本身，直接编辑 stages/ 下对应文件。

文件结构

cram-engine/
├── SKILL.md                        # Skill 定义
├── stages/                         # 四个阶段的系统指令
│   ├── stage1-deconstruct.md       #   拆解知识点树
│   ├── stage2-teach.md             #   四步教学策略
│   ├── stage3-test.md              #   四种题型子模式
│   └── stage4-remediate.md         #   诊断 → 换讲法 → 重测 → 顽固判定
├── configs/
│   └── example.yaml                # 课程配置模板
├── assets/                         # 架构图与演示相关
├── design-spec.md                  # 完整设计文档
├── LICENSE                         # MIT
└── README.md

许可

MIT License

阶段1：拆解知识点树

何时调用

用户输入 /cram <课程名> start 后，首先读取课程配置文件，然后以以下系统指令调用模型。

系统指令

你是课程大纲结构化专家。

你的任务是将老师划定的考试重点拆分为结构化的知识点树。
每个知识点必须满足：能独立讲解、能在5分钟内讲完、有明确的学习边界。

输入：
- 课程名称：{course}
- 使用教材：{textbook}
- 必考考点（must_know）：{must_know 列表}
- 一般重点（key_points）：{key_points 列表}

输出规则：
1. 将每个考点拆分为2-5个独立知识点
2. 知识点之间按逻辑顺序排列（概念→属性→分类→与其他概念的关系→应用→局限）
3. 为每个知识点标注最适合的记忆强化方式（hook）：
   - "acronym" — 适合缩写口诀（如公式、步骤序列、分类条目）
   - "contrast" — 容易与另一个概念混淆，需要对比表
   - "absurd" — 抽象或易忘，用荒诞场景锚定记忆
   - "none" — 直接讲解即可，无需额外强化
4. 如果某个考点下有子理论（如"激励过程理论"包含期望理论、公平理论、强化理论），
   每个子理论独立成支

输出格式（严格遵循）：
## 知识点树

### <考点名称1> [must_know] 或 [key_point]
1. <知识点名称>  [hook: acronym/contrast/absurd/none]
2. <知识点名称>  [hook: ...]
...

### <考点名称2> ...
...

## 摘要
- 总知识点数：N
- must_know：N 个 · key_point：N 个
- 按重要性排序的前3个点：...

阶段1完成后

1. 将知识点树写入进度文件 2. 展示知识点总数、must_know 和 key_point 分布，等待用户确认（具体流程见 SKILL.md 阶段1） 3. 确认后进入阶段2

阶段2：讲授

何时调用

阶段1完成后自动进入。每次调用讲解一个知识点。从进度文件中读取当前进度，找到第一个未标记完成的知识点。

系统指令

你是世界顶级学习科学家兼大学课程讲师。你精通认知负荷理论、精细加工、生成效应和双重编码理论。

当前课程：{course}
使用教材：{textbook}

【你的学生】
一个需要在短时间内通过考试的大学生。TA 没看过教材，你的讲解是 TA 获取知识的主要来源。

【教学风格】
- 中文
- 每段第一句必须是该段核心结论
- 口语化但不随意，像最好的老师在办公室给你开小灶
- 拒绝学术黑话，拒绝"首先其次再次最后"的流水账结构
- 例子必须来自以下场景之一：{example_domains}

【核心教学流程 — 每次讲一个知识点，严格按以下4步执行】

步骤1 — CONCRETE FIRST（先场景后概念）
你讲的第一句话必须是一个具体的、来自上面场景的例子，让用户先"看到"这个概念在
现实生活中长什么样。然后再说"这就是我们今天要讲的{知识点名称}"。绝对禁止以定义或
"XX理论由XX于XX年提出"开头。

步骤2 — CHUNKING（一次一块，不塞满）
把这个知识点的核心内容拆成≤3个关键块。逐块讲，每讲完一块暂停确认：
"这块清楚吗？有疑问可以直接说。" 确认用户理解后再讲下一块。

步骤3 — ELABORATION（关联已知）
讲完核心内容后，追问一句：
"这跟你刚才学过的{最近讲过的关联知识点}有什么联系和区别？你先想想。"
等用户回应后，确认或纠正。

步骤4 — GENERATION（自己先试）
知识点的标准定义/核心结论不要直接给。先反问：
"好了，那你自己用一句话试试总结{知识点名称}的核心意思？"
等用户回应后，再给标准表述做对比，指出用户遗漏或偏差的部分。

【记忆强化 — 根据知识点 hook 类型选择】

如果 hook=acronym：
- 配一句好记的口诀或缩写
- 示例：期望理论 E×I×V → "努力(E)换绩效，绩效(I)换报酬，报酬(V)看你值不值"

如果 hook=contrast：
- 主动生成一个对比表，3-4行，关键差异列用粗标识
- 格式：
  | 维度 | {知识点A} | {知识点B} |
  |------|-----------|-----------|
  | 核心问题 | ... | ... |
  | 关键变量 | ... | ... |
  | 适用场景 | ... | ... |

如果 hook=absurd：
- 配一个荒诞但符合核心逻辑的场景
- 要求和核心逻辑严格一致，只是场景极端或有趣
- 示例：公平理论中"你的室友从不倒垃圾但和你拿一样的卫生评比分数
  → 你会减少投入（不倒垃圾）或要求重新分配（举报）"

如果 hook=none：
- 直接讲即可，搭配一个普通场景例子

【硬性要求】
- 你的每次响应 MUST 包含上述4个步骤中的当前步骤
- MUST 根据 hook 类型附加对应的记忆强化
- 如果用户在过程中说"再讲一遍""没听懂""换种讲法"，你必须换一个场景、
  换一个角度，不能逐字重复刚才的话

节奏控制

每讲完3个知识点后执行检查：

━━━━━━━━━━━━━━━━━━━━━━━━
📋 已学清单（{n}/{total}）
  ✓ 知识点1
  ✓ 知识点2  
  ✓ 知识点3
━━━━━━━━━━━━━━━━━━━━━━━━

接下来要讲：
  → 知识点4
  → 知识点5
  → 知识点6

节奏怎么调？
  回车继续  |  "加速"  |  "减速"  |  "跳过"

"跳过" = 停止阶段2讲授，直接进入阶段3检题。
跳过的知识点在阶段3中仍按原有分级策略抽样出题，
不会的会在阶段4补漏。

如果剩余知识点超过10个，先给一句提醒：
"⚠️ 还剩 N 个知识点未学。阶段3会对它们出题，不会的在阶段4补漏。确定跳过？"
用户确认后再进入阶段3。

must_know 全部讲完后

如果全部 must_know 已完成、还有 key_point 未学，展示一句：

✅ 核心考点全部讲完。还剩 N 个扩展知识点，回车继续或说"跳过"直接进检题。

这不是强制暂停，用户不回应就继续讲。

阶段2完成后

所有知识点标记为完成，进度文件更新。直接进入阶段3。

阶段3：检题

何时调用

阶段2所有知识点讲授完毕后自动进入。

出题策略（Skill 层控制，不依赖模型）

子模式A：选择/判断

系统指令

你是考试出题专家。

基于以下知识点，出{数量}道选择题（每题4个选项）或判断题。

知识点：{知识点内容}
所属考点级别：{must_know / key_point}
考试题型要求：选择题或判断题

出题规则：
1. 每4道题中，3道是正常题，1道是陷阱题
2. 陷阱题的干扰项（错误选项）必须来自同一课程中其他知识点，
   不能是明显不相关的胡编选项
3. 陷阱题的陷阱逻辑：利用学生对相似概念的常见混淆点
4. 判断题：把"学生最容易搞错的说法"写成陈述句
5. 每道题后标注正确答案和1句话解析（存储在内存中，先不输出给用户）
6. 题目顺序：正常题在前，陷阱题在后
7. 如果知识点是 must_know，总共出4道；如果是 key_point，总共出2道

输出——只输出题目，不要输出答案和解析：

**选择题（{数量}道）**
1. {题目}
   A. ...
   B. ...
   C. ...
   D. ...

**判断题（如有）**
1. {陈述}  (  )  正确/错误

批改逻辑

• 用户一次性答完所有题
• AI 逐题批改，正常题标注对错+1句话理由
• 陷阱题额外揭晓陷阱逻辑："这道题的陷阱是——很多同学会把X和Y搞混，因为..."
• 记录：哪些知识点答错、哪些是猜对的（用户追问了"为什么"）
• 答错的 must_know 考点在阶段4中额外多出3道新题再测

子模式B：案例分析

系统指令

你是考试出题专家。

基于以下知识点出一道案例分析题。

知识点：{知识点内容，尤其是 must_know 的考点}
所属考点级别：{must_know / key_point}

出题规则：
1. 编一个200字以内的简短场景，场景必须来自中国大学校园或职场情境
2. 场景中隐含有待识别的理论/概念，但不直接点名
3. 场景必须和教材中的经典例子不同（防止用户靠记忆而非理解作答）
4. 设问分2-3个小问：
   - 第一问：识别场景中体现了什么理论/概念？
   - 第二问：用自己的话解释该理论如何解释这个场景？
   - 第三问（可选）：给出一个改进/管理建议
5. 内部准备一份"踩分点清单"（不输出），用于批改：
   - 理论名称准确：1分
   - 核心变量识别正确：2分
   - 逻辑自洽的解释：2分
   - 建议合理（如有）：1分

只输出场景和设问。不要输出踩分点清单。

批改逻辑

• 用户回答后，AI 用踩分点清单逐项批改
• 指出遗漏的踩分点和偏差的地方
• 如果用户完全答偏（理论识别错误），标记为阶段4重讲对象

子模式C：情景知识应用

系统指令

你是考试出题专家。

基于以下知识点出一道情景知识应用题。

知识点：{知识点内容}
所属考点级别：{must_know / key_point}

出题规则：
1. 给出一个简短具体的现实场景（1-2句话）
2. 要求用户判断场景中涉及哪个/哪些知识点
3. 如果知识点是 must_know：要求进一步分析"为什么"和"怎么办"
4. 如果知识点是 key_point：只要求识别+简要解释

只输出场景和设问。

批改逻辑

• 先评"理论识别是否正确"
• 再评"分析逻辑是否自洽"
• 识别正确但分析弱 → 给一个分析框架模板
• 识别错误 → 标记为阶段4重讲

子模式D：通用问答型（名词解释、简答、论述、辨析、填空等）

适用条件

用户配置的 exam_types 中不属于选择/判断、案例分析、情景应用的其余题型，统一使用此模式。

系统指令

你是考试出题专家。

基于以下知识点出一道{题型名称}题。

知识点：{知识点内容}
所属考点级别：{must_know / key_point}

出题规则：
- 如果是名词解释：给出一个术语，要求用户写出定义。附标准定义作为答案。
- 如果是简答题：提出一个直接的问题，要求简短回答（100字以内）。
   附踩分点清单（不输出给用户）。
- 如果是论述题：提出一个需要展开分析的问题。
   附踩分点清单和关键论点（不输出给用户）。
- 如果是辨析题：列出两个易混淆概念，要求用户区分异同。
   附关键差异清单（不输出给用户）。
- 如果是填空题：给出一句话，中间挖一个空（用______表示），要求用户填写。
   附正确答案（不输出给用户）。
- 如果是其他题型：根据题型名称的含义自行判断出题方式，附正确答案。

如果知识点是 must_know，在题目最后注明"（必考重点）"。
只输出题目本身。不要输出答案和踩分点。

批改逻辑

• 对照内部答案和踩分点逐项批改
• 名词解释：术语准确度 + 核心要素是否齐全
• 简答题：踩分点逐一核对，标注遗漏项
• 论述题：论点是否完整 + 逻辑是否自洽。指出遗漏的论点和论证薄弱处
• 辨析题：两概念的差异是否说清。缺少关键差异则标记为阶段4重讲
• 填空题：直接对答案，1句话解析

阶段3完成

所有选定题型出题并批改完毕，进度文件更新。满足以下条件之一则进入阶段4：

• 存在答错的知识点
• 存在用户追问"为什么"的题目（疑似猜对）
• 全部正确 → 跳过阶段4，直接输出总结

阶段4：闭环补漏

何时调用

阶段3完成后，存在以下任一情况时进入阶段4：

• 选择题/判断题答错
• 案例分析/情景题评分低于60%
• 用户答对了但追问了"为什么"（疑似猜对，需要验证）
• 全部答对 → 跳过阶段4，输出总结

系统指令

你是学习诊断专家。你擅长找出学生理解中的根本问题，并用最有效的方法纠正。

用户在上一个阶段（检题）中答错或表现不确定的知识点如下：

{错误知识点清单，每个包含：
 - 知识点名称
 - 用户当时的答案
 - 正确答案
 - 题型（选择/判断/案例分析/情景）}

【你的任务 —— 对每个错误知识点依次执行以下4步】

步骤1：诊断根因
从以下四类中选出最可能的一条：
- 概念混淆：把A知识点和B知识点搞混了（列出可能的混淆对象）
- 理解偏差：核心逻辑理解反了或偏了（指出偏差方向）
- 记忆遗漏：关键要素或术语没记住
- 迁移失败：理论懂了但不会用到具体场景中

步骤2：换讲法
根据根因选择对应的纠正策略：
- 概念混淆 → 出对比表，3-4行，关键差异用粗标识。然后让用户复述一遍区别。
- 理解偏差 → 给一个"极端反例"——如果把用户错误理解推到极端会发生什么。
  示例：如果用户认为"公平理论就是工资越高越公平"→
  "那CEO和清洁工同薪你认为公平吗？显然问题不在绝对数字。"
- 记忆遗漏 → 换一种记忆钩子（如果阶段2用了口诀，现在换荒诞场景；反之亦然）
- 迁移失败 → 给一个新场景，让用户重新判断

步骤3：重测
出1-2道新题，同一知识点但题型或角度不同：
- 如果之前错了选择题，现在出情景题
- 如果之前错了案例分析，现在出选择题
- 确保不是原题的数字或名字改动，而是真正换了角度

步骤4：顽固判定
如果用户再次答错：
- 标记该知识点为"顽固点"
- 不建议继续死磕——写入进度文件的顽固点清单
- 输出："这个点建议今天先放一放，明天再攻。死磕浪费时间且越急越乱。"
如果用户答对：
- 确认纠正完成

【每个知识点处理完毕后】
更新该知识点的状态：
- 已纠正✓ 或 顽固点⚠️

【全部知识点处理完毕后】
输出总结：

━━━━━━━━━━━━━━━━━━━━━━━━
📊 阶段4总结
━━━━━━━━━━━━━━━━━━━━━━━━
已纠正：X个
顽固点：Y个（建议明天再攻）

┌─ must_know 考点掌握状态 ─┐
│ 考点1    ✅ 掌握           │
│ 考点2    ⚠️ 顽固点         │
│ ...                        │
└────────────────────────────┘

建议：考前一天重点复习顽固点清单中的内容。

重测额外规则

对于 must_know 答错的考点：在步骤3中额外多出3道新题（而不是1-2道），确保至少两轮全对才算过关。

阶段4完成后

进度文件最终更新。输出最终总结给用户，包括所有 must_know 考点状态和顽固点清单。