别只让 AI 替你写代码：用Vibe Learning来激活你的大脑

AI 把活干完了，我却没学会

学一门新技术，如今太容易产生一种错觉。

打开 AI 编辑器，输入需求，代码出来了；追问一句，测试也有了；报错贴进去，修复方案跟着来。半小时后程序跑通，成就感满满。可关掉 AI，让自己解释一下为什么这样写、换个条件会怎样、边界在哪里——脑子里一片空白。

代码跑起来了，知识没有长在自己身上。

这就是我对 Vibe Coding 最大的保留。它当然有用：写样板、查 API、做原型都省时间。但如果一路都由 AI 猜意图、替你选择、替你纠错，人只负责按 Tab，那得到的是产出，不是理解。

我更感兴趣的是另一件事：能不能用 AI 激活大脑，而不是绕过大脑？

以前看到一长串公式就想翻页，看到红黑树旋转就头晕，看到 Attention 的矩阵乘法就安慰自己“会调用就行”。今天，我们已经能把公式画出来、把参数做成滑块、把算法一帧帧跑给自己看，再让 AI 追问“为什么”。那些过去望而却步的东西，第一次能变成可以摸、可以试、可以拆开的对象。这比让 AI 多写几千行代码有意思多了。

佛教有六字真言“唵嘛呢叭咪吽”。我不谈信仰，只借这个形式——学习也有一句“六字诀”，念得出、记得住：

问、猜、跑、看、讲、测。

怕记不住，我还凑了一首藏头小诗，每句头一个字连起来就是这六字诀：

问从心头起， 猜向纸上留。 跑他三五遍， 看清脉与由。 讲罢知深浅， 测完不用愁。

英文缩成一个能读出来的词：Q-GRASP（Question、Guess、Run、Assess、Speak、Prove）。GRASP 本义是“抓住、领会”，正好点题：把知识真正抓在手里，而不是看一眼就滑走。后文都是在给这六个字填肉；别的记不住，记住这六个字也不亏。

学习不是把答案搬进脑子

很多人把学习等同于输入：读书、听课、看视频、读 AI 总结。输入当然需要，但它只是让知识进了眼睛和耳朵，离“我会了”还很远。

真正的学习，至少还要发生几件事：

• 从记忆里把概念提取出来，而不是看着答案觉得眼熟；
• 用自己的语言重新组织，而不是复述原文；
• 对结果做预测，再用现实纠正预测；
• 把抽象符号连接到图像、动作和已有经验；
• 换一个条件、一个例子，看看理解还能不能站住。

认知心理学里有几个概念，正好解释了为什么这些动作有效。

但这些不是六个神奇按钮。

比如即时反馈有助于纠错，但“即时”不等于 AI 在你思考之前就把答案糊到脸上——复杂问题不妨先让人挣扎几分钟，再给分层提示。视觉化也一样：无关动画、渐变色和 3D 特效只会增加负担；真正有用的图，是让你看见一个变量怎样影响另一个、状态怎样变化、自己刚才的猜想错在哪。

好的学习工具不是让知识看起来更热闹，而是让思考留下可以观察的痕迹。

推荐两种工具的两种角色

我推荐使用Jupyter Notebook 和 LLM ， 它们都能帮人学习，但分工要清楚：一个让知识跑起来，一个追问你是否真懂。

Jupyter Notebook：5 分钟上手

Project Jupyter 的 Notebook，一个文档里能同时放代码、文字、公式和输出。它厉害的地方不在于能写 Python，而在于把“解释”和“证据”放在一起。

JupyterLab 是现在更常用的界面，安装启动如下：

python -m venv .venv
source .venv/bin/activate       # Windows 使用 .venv\Scripts\activate
python -m pip install jupyterlab numpy matplotlib
jupyter lab

浏览器打开后，新建一个 Python Notebook，就能看到由一个个 Cell 组成的页面。

Notebook 最容易踩的坑：页面从上到下，Kernel 却记得你乱序执行过什么。第 8 个 Cell 可能偷偷依赖第 12 个 Cell 的变量，在你电脑上能跑，发给别人就翻车。所以分享前先执行一次 Restart Kernel and Run All——能从空白顺序跑通，才算可复现。

几个方便的小工具：%timeit 测运行时间，变量名? 查帮助，%pip install 包名 装依赖到当前 Kernel。初学掌握 Cell、Kernel 和顺序执行就够了。

LLM：别当代笔，改当陪练

通用 LLM 最强的地方不是解释，而是能根据你的回答不断调整问题。你可以要求它：

• 一次只问一个问题；
• 在你预测之前不公布结果；
• 答错时先给一级提示，而不是直接解题；
• 让你举反例、画图、换一种说法；
• 根据你的错误生成一道变式题；
• 最后进行闭卷口试。

这时 AI 不再是答题枪手，而像一个脾气好、时间多的陪练：你出拳，它纠正；你不出拳，它不替你比赛。

两者合起来：把抽象知识变成实验

一个好的学习 Notebook，应该留下这样一条链：

问题 -> 我的预测 -> 公式或规则 -> 最小实验
     -> 图形与数据 -> 我的解释 -> 反例 -> 闭卷测试

这是一份可执行的学习记录。几个月后再打开，你看到的不只是答案，还有自己的认识怎样一步步变化。

一场完整实验：亲手看见梯度下降

拿梯度下降做例子。动公式之前，先弄清它解决什么问题。

想象你半夜被空投到一座陌生山谷，四周漆黑，看不见谷底，只想尽快下到最低处。你能做的，是用脚感受哪个方向最陡，朝下坡最陡的反方向迈一步；到新位置再感受、再迈。只要步子别太大，多走几趟总能挪到谷底附近。

梯度下降干的就是这件事，只是把“山谷”换成一个数学函数，“海拔”换成我们想减小的某个数值。这就带出下山三件套：一片山谷（损失函数）、会看坡（梯度）、决定步子多大（学习率）。 一件件说。

山谷本身：损失函数

想让模型学得更好，先得有把尺子量“它现在错得有多离谱”。这把尺子就是损失函数（Loss Function），记作 \(L(\theta)\)——\(\theta\)（读 theta）是模型里所有可调的参数（权重、偏置），\(L\) 是当前这套参数下模型的总误差。

拿最常见的均方误差（MSE, Mean Squared Error）举例：

别被求和号吓住，一项项拆开看就很朴素：

• \(y_i\) 是第 \(i\) 个样本的真实答案，\(\hat{y}_i\)（读作 y-hat）是模型的预测值；
• \(y_i-\hat{y}_i\) 就是这一个样本猜偏了多少；
• 平方是为了不管猜高还是猜低都算“错”（负号被抹掉），而且错得越离谱，惩罚涨得越快；
• 前面 \(\frac{1}{n}\sum\) 是把 \(n\) 个样本的误差加起来取平均。

说白了，\(L(\theta)\) 就像考试的总扣分：预测越准，扣得越少。所谓“训练模型”一句话——调 \(\theta\)，让 \(L(\theta)\) 尽可能小。 这就是我们要下的那片“山谷”，谷底就是误差最小处。

画出来，梯度下降要干的事就一目了然：从损失很大的高处出发，一步步滚到谷底。

会看坡：梯度

站在山谷里，怎么知道往哪迈？靠梯度（gradient），记作 \(\nabla L(\theta)\)（\(\nabla\) 读“纳布拉”）。记住两句话就够：

• 梯度指向“上升最快”的方向，也就是脚下最陡的上坡方向；
• 那么负梯度就指向“下降最快”的方向——这正是我们想走的下山方向。

它数学上是什么？是损失对每个参数的偏导数排成的一个向量：

“偏导数”听着唬人，其实就是一次只拧一个旋钮：\(\frac{\partial L}{\partial\theta_1}\) 是“只动 \(\theta_1\)、其它按住不动时，\(L\) 往哪变、变多快”。每个参数都问一遍，答案排成一列就是梯度。所以梯度这一个向量里同时装着方向（往哪调）和陡峭程度（该调多猛）。

决定步子：学习率

知道朝哪走，还得定一步迈多大，这就是学习率（learning rate），记作 \(\eta\)（读 eta）。步子太小，下山慢；步子太大，可能一脚跨过谷底甚至越走越高。后面实验会让你亲眼看到这三种情况。

三件套齐了，把“看负梯度、迈一步、再看”写成一行数学，就是梯度下降的核心公式：

翻译成大白话：站在当前参数 \(\theta_{\text{old}}\)，朝负梯度方向（下坡最快）迈一步，步长由学习率 \(\eta\) 决定，落到新参数 \(\theta_{\text{new}}\)。 那个负号就是把“最陡上坡”掉头成“最陡下坡”的关键。

这套“看方向、迈一步、再看”的笨办法为什么重要？因为现实里绝大多数函数没法像中学题那样一步解出最小值——一个神经网络动辄上亿参数，根本没有解析解。梯度下降给了条通用出路：不必一次求出答案，只要能算出“往哪调一点会更好”，就能一步步逼近。

所以从线性回归、逻辑回归，到反向传播，再到大模型训练，背后的优化引擎几乎都是梯度下降及其变体（SGD、Momentum、Adam）。今天大半个机器学习里的“学习”，指的就是让模型沿梯度一步步下山。

把公式落到一个能上手的例子

上面的 \(\theta\) 是“全部参数打成的一个包”，可能上亿个，脑子里不好想象。为了看清楚，我们把它缩到一个参数：这时 \(\theta\) 就是个普通的数，改用更熟的 \(x\) 写，损失 \(L\) 简写成一元函数 \(f(x)\)。核心公式变成：

下标 \(t\) 是“第几步”，\(f'(x_t)\) 是一元情形下的梯度——参数只有一个时，梯度退化成普通导数（多参数才需要那个偏导向量）。这就是后面实验反复出现的更新式。

手算一步，把公式坐实

光看公式还是虚，拿后面要做实验的函数亲手算一步。取

它是一条开口向上的抛物线，最低点在 \(x=3\)。假设起点 \(x_0=-6\)（谷底左边很远处），学习率 \(\eta=0.1\)，那么：

第一次更新是：

参数从 \(-6\) 移到 \(-4.2\)，向最低点 \(x=3\) 靠近了一步。两个负号不是故意为难人：当前位置在最低点左侧，梯度为负，减去负数就向右移动。

别急着背，先在 Jupyter 里做场小实验。完整实验和 LLM 陪练代码已放进 Notebook：下载并运行 ai_activated_learning_gradient_descent.ipynb。

第一步：问

还用那条抛物线 \(f(x)=(x-3)^2+2\)，当成一个单参数的“迷你损失函数”。它的最低点在哪？学习率 \(\eta\) 较小、较大但仍收敛、越过收敛边界时，迭代轨迹分别会怎样？

第二步：猜

先别运行代码，写下预测：

我的预测：

1. 最低点大约在 x = ____。
2. eta = 0.1 时，轨迹会 ____。
3. eta = 0.8 时，轨迹会 ____。
4. eta = 1.05 时，轨迹会 ____。
5. 我目前的信心：____ / 5。

别嫌幼稚。没有预测，图一出来人很容易说“果然如此”；有了预测，错误才无处藏身。

第三步：跑

下面这段代码只依赖 NumPy 和 Matplotlib（pip install numpy matplotlib）。关键几步都写在注释里；只想看结论的可以直接跳到代码后的“这张图怎么读”。

import numpy as np
import matplotlib.pyplot as plt


def f(x):
    return (x - 3) ** 2 + 2   # 要下的“山谷”，海拔越低越好，最低点在 x=3


def grad(x):
    return 2 * (x - 3)        # 山谷在 x 处的坡度（梯度）；真实训练里通常由框架自动求导


def gradient_descent(x0, eta, steps=20):
    xs = [x0]                                       # 记下起点
    for _ in range(steps):                          # 走 20 步
        # 核心就这一行：新位置 = 旧位置 - 学习率 × 坡度
        # 正是公式 x_{t+1} = x_t - eta * ∇f(x_t)，减号=往下坡走，eta=步子多大
        xs.append(xs[-1] - eta * grad(xs[-1]))
    return np.array(xs)                             # 返回这 20 步每一步的位置


# 只改学习率这一个变量：偏小 / 偏大但还没出界 / 已越线，其它全部按住不动
rates = [0.1, 0.8, 1.05]

# 两行三列画布：每种学习率占一列，方便横向对比
fig, axes = plt.subplots(2, 3, figsize=(15, 8))

for col, eta in enumerate(rates):
    xs = gradient_descent(x0=-6, eta=eta)           # 起点统一放在谷底左侧远处 x=-6
    left = min(-8, xs.min() - 1)                    # 横轴范围随轨迹自动伸缩
    right = max(12, xs.max() + 1)
    grid = np.linspace(left, right, 400)

    # 上排：抛物线 + 下山脚印
    path_ax = axes[0, col]
    path_ax.plot(grid, f(grid), color="steelblue")  # 光滑的“山谷”曲线
    path_ax.plot(xs, f(xs), color="#b0b0b0", alpha=0.6)  # 灰线连起相邻两步
    # 用 viridis 按迭代先后上色：深紫=早，黄绿=晚，区分度比 autumn 高得多
    path_ax.scatter(xs, f(xs), c=np.arange(len(xs)), cmap="viridis",
                    s=55, edgecolors="white", linewidths=0.6)
    path_ax.set_title(f"eta = {eta}")
    path_ax.set_xlabel("x")
    path_ax.grid(alpha=0.25)

    # 下排：误差 |x-3| 随迭代的变化，用对数纵轴
    error_ax = axes[1, col]
    error_ax.plot(np.arange(len(xs)), np.abs(xs - 3), marker="o")
    error_ax.set_yscale("log")   # 对数刻度：收敛=向下直线，发散=向上直线
    error_ax.set_xlabel("iteration")
    error_ax.grid(alpha=0.25)

axes[0, 0].set_ylabel("f(x)")
axes[1, 0].set_ylabel("|x - 3|")
plt.tight_layout()
plt.show()

代码只有一处值得多看几眼：xs[-1] - eta * grad(xs[-1])，就是公式 \(x_{t+1}=x_t-\eta\nabla f(x_t)\) 一字不差抄成的代码。没有任何机器学习框架，梯度下降的核心逻辑就这一行，其余都是画图用的脚手架。

这张图怎么读

先别下结论，把坐标和元素认清，第四步再解读现象。

注意：三列的坐标范围并不相同（代码里 left/right 按各自轨迹自动算）。别只看“点铺得开不开”，要结合坐标轴数值——\(\eta=1.05\) 那列横轴拉到了正负几十，正是发散的信号。

第四步：看

别只说“第一张收敛，第三张发散”，尽量描述你真正看到了什么：

• \(\eta=0.1\) 时，每一步不大，轨迹单调地靠近最低点；
• \(\eta=0.8\) 时，点会跨过最低点，在两侧来回摆动，但振幅逐渐缩小；
• \(\eta=1.05\) 时，每次跨越后离最低点更远，轨迹开始发散。

对照那张图：\(\eta=0.8\) 这列，下排误差曲线仍向下（在收敛），可上排的点已在 \(x=3\) 两侧来回横跳——“误差在缩小”和“轨迹很稳”并不是一回事，这正是只看一张图容易漏掉的。

这时回到公式。因为：

所以更新可以改写为：

对当前这个一维二次函数，在固定学习率、梯度计算准确的前提下，要让“距离最低点的误差”一次次缩小，就需要：

也就是：

现在，公式不再是一句要背的规定，它解释了图上为什么慢慢靠近、为什么左右摇摆、为什么越跑越远。

但别把 \(0<\eta<1\) 当成通用定理。换个函数，收敛范围会随曲率变化；到了非凸问题，即使收敛也不保证找到全局最小值。这个实验的价值是展示怎样从具体函数推导和验证边界，不是发一张万能学习率许可证。

第五步：讲

关掉上面的文字，对着橡皮鸭或 LLM，用自己的话解释：

为什么梯度下降要减去梯度？为什么学习率太大会发散？为什么 \(\eta=0.8\) 会左右振荡却仍能收敛？

只能重复公式，说明理解还停在符号层；能用“位置、斜率、步长、误差缩小比例”串起来，才算有了自己的模型。

第六步：测

最后换题，别重复原题：

不运行代码，先回答：

1. 最低点在哪里？
2. 梯度是什么？
3. 学习率满足什么范围才能收敛？
4. 如果从最低点右侧出发，第一次更新往哪个方向走？

然后再让 Notebook 或 LLM 验算。

到这里，学习才形成闭环。无他，手、眼、脑都得上场。

公式、算法、数据结构，都可以“活”起来

梯度下降只是样例。这套方法真正有意思的地方，是能把许多过去只能硬啃的内容变成实验。

关键不是做动画，而是让视觉变化对应一个可验证的问题。

比如展示红黑树旋转时，别只看节点飞来飞去，每一帧都停一下问自己：

1. 当前违反了哪条性质？
2. 如果不旋转，只改颜色行不行？
3. 旋转后哪些节点的黑高发生了变化？
4. 换一个插入顺序，动作是否相同？

图像把变化摊在眼前，问题把变化送进脑子。只有图没有问题，学习就退化成看技术烟花。

一套可复制的六步闭环：问、猜、跑、看、讲、测

把前面的过程压缩，就是开篇那句 Q-GRASP——问、猜、跑、看、讲、测。逐个说清每个字要你做什么。

1. 问（Question）：把主题改写成可验证的问题

“学习 Transformer”太大，“Attention 为什么要做缩放”才是一个能动手的问题。

一个好问题最好包含对象、变量和判断标准：

当维度 d_k 增大时，QK^T 的数值分布怎样变化？
除以 sqrt(d_k) 是否能让 Softmax 的输出不那么饱和？

2. 猜（Guess）：在 AI 开口前留下自己的判断

预测不必正确，甚至可以很粗糙。重要的是给反馈建立一个参照物。

可以写三样东西：

• 我猜结果是什么；
• 我为什么这样猜；
• 我的信心是 1 到 5 中的几分。

3. 跑（Run）：只做能区分猜想的最小实验

别一上来让 AI 生成五百行“教学平台”。先写十几行，控制变量，一次只验证一个问题。学习用的 Notebook 不是产品代码，不必先搭三层架构——老程序员也得克制设计欲，不然实验还没开始，工厂先建了三个月。

4. 看（Assess）：记录现象，不急着套结论

把观察和解释分开写：

观察：eta = 0.8 时，x 在 3 的两侧交替出现，距离逐步缩小。

解释：误差每轮乘以 -0.6，负号造成换边，绝对值小于 1 造成收敛。

这一步能防止自己把“我认为”伪装成“我看到”。

5. 讲(Speak)：脱离材料，重新组织一次

可以写一段话、录两分钟语音，也可以让 LLM 扮演一个会追问的初学者。

讲不清的地方，通常就是理解断掉的地方。AI 在这里最有用的动作，不是替你润色，而是追问：“你刚才说的‘稳定’，数学上到底指什么？”

6. 测(Prove)：换条件、换表示、隔一段时间再来

当场会做不算数，刚才的上下文可能还在工作记忆里。第二天关掉 Notebook 再做一道变式题，才更接近真实掌握。

一个简单节奏：当天小测，第二天闭卷复述，一周后做变式题。可按难度调整，目的只有一个：别让“刚看懂”冒充“已经会”。

问，让学习有方向；猜，让大脑先出场；跑和看，让现实给反馈；讲和测，决定知识是不是你的。

三组可以直接使用的提示词

AI 能不能激活大脑，很大程度取决于你给它安排什么职位。下面三组都是模板，把 {{...}} 占位符换成你的主题即可。它们不挑学科——梯度下降、Raft、傅里叶变换能用，法律概念、历史成因、商业模式，甚至读一本书，同样能用。

用法说明：{{主题}} 填你要学的东西；{{最小实验}} 填一个能给你反馈的最小动作——写代码的可以是一段 Jupyter 实验，不写代码的可以是手算一个例子、画一张图、找一个真实案例、做一道题。核心不变：让 AI 少替你想，多逼你想。

提示词一：建材料地图，不要漂亮摘要

我会提供几段带编号的材料（可能是教材、论文、文档、书摘或笔记）。
请只依据这些材料，为 “{{主题}}“ 建立一张学习地图。

要求：
1. 列出必须先懂的 5 个前置概念，每条标出材料编号；
2. 找出不同来源表述不一致、或适用条件不同的地方；
3. 给出 3 个我可以自己动手验证的问题（{{最小实验}}）；
4. 不要替我写最终总结；
5. 材料中没有依据的内容，明确说 “不在所给材料中“ ；
6. 不要编造出处、页码或链接，我会回原文核对。

提示词二：苏格拉底式陪练

你是我的学习陪练，不是答题人。我正在学习 “{{主题}}“ 。

规则：
1. 一次只问一个问题；
2. 在我给出预测或回答前，不公布答案；
3. 答错时先给最小提示，最多分三级（方向 → 关键概念 → 半成品步骤）；
4. 要求我用不同方式各解释一次（例如：口语、类比、以及公式/图示/例子中适用的一种）；
5. 发现我用词含糊时，追问它的准确定义；
6. 最后出一道改变前提或条件的变式题，检查我能否迁移；
7. 根据我的回答指出一个真正的知识缺口，不要泛泛鼓励。

先问我一个能暴露 “{{主题}}“ 核心的开放问题，然后等我回答。

提示词三：生成一个 “留白“ 的学习脚手架

请为 “{{主题}}“ 生成一个学习脚手架，用来引导我自己动手，而不是替我完成。

脚手架只包含这些区块：
- 学习目标（1-2 句）；
- 预测区：列出我应当先自己回答的问题，留空让我填；
- 一个最小的可操作例子或实验（{{最小实验}}），拆成尽量小的步骤，每步只验证一件事；
- 观察记录区：留空让我记录真正看到的现象；
- 三个递进提示，供我卡住时逐级查看；
- 闭卷解释题一道 + 变式题一道。

不要在预测区和解释区填答案。步骤保持简短，一步只做一件事。
（如果 {{主题}} 适合用代码验证，就输出 Jupyter Notebook 的 Cell 结构；否则用普通清单即可。）

这三组提示词的共同点，是故意给 AI 戴上手铐。它少做一点，人脑才能多做一点。

一个 90 分钟学习模板

如果不知道怎样开始，可以拿一个晚上试试这套安排：

九十分钟不一定“精通”一个算法，但足够完成一次可回看、可复测的实验。比起看三小时视频后觉得自己啥都懂，这样慢一点，却踏实。

五个常见坑

1. AI 抢答太快

问题刚打完，答案已经铺满屏幕。看答案很舒服，生成答案很费脑，而大脑偏偏喜欢前者。

解决办法很简单：强制“先预测，后提示，最后答案”。

2. Notebook 成了代码垃圾场

AI 生成一大段代码，运行成功，截图保存，然后再也没有打开。这样的 Notebook 不是实验记录，只是另一种下载目录。

每个实验至少补三块：我的预测、我的观察、我的解释。

3. 把可视化当成理解

图很漂亮，滑块很好玩，录成视频更漂亮。可是问“横轴是什么、颜色代表什么、哪个变化支持你的判断”，答不上来。

视觉效果是路标，不是目的地。

4. 材料越多越安心

一次把十篇论文和一整本书塞给 LLM，像随身带了座图书馆。问题是上下文太杂、版本不同、术语冲突，模型还可能把补充混进原文，最后熬成一锅知识浓汤。

一个小问题，两到四份高质量材料足够：教材讲骨架，论文讲证据，官方文档讲实现，自己的笔记讲疑问，各司其职。

5. 忘了安全和边界

别把公司机密、个人隐私、未公开代码和受限数据随手上传外部 AI，也别上传自己无权复制或交给第三方处理的教材论文。先确认组织政策、版权许可、数据分类和服务条款（个人账号和组织账号可能不同）。学习效率再高，也不值得拿一次安全事故或版权纠纷来换。

另外，AI 生成的代码仍要检查依赖、输入边界和资源消耗。学习环境可以宽松，安全习惯不能下班。

怎样判断自己真的学会了

别问“我看懂了吗”，这个问题太容易得到乐观答案。换成这张验收表：

• [ ] 我能不用原文，用自己的话讲清核心概念；
• [ ] 我能把文字、公式和图像互相转换；
• [ ] 我能手算或手推一个最小例子；
• [ ] 我能预测参数或输入变化后的结果；
• [ ] 我能说出方法失效的边界和至少一个反例；
• [ ] 我能修改 Notebook，设计一个新的对照实验；
• [ ] 我能在隔了一段时间后完成一道变式题；
• [ ] 我能指出哪些结论来自资料，哪些只是自己的推测；
• [ ] 我能把这个知识用到一个真实问题里。

只会复述定义，是刚进门；能跑通例子，是到了院子；能解释边界、设计反例并迁移到新问题，才算成竹在胸。

Vibe Coding 没错，只是别停在那里

我不反对 Vibe Coding。快速做原型，让后端程序员试着画界面，让不熟 Python 的人跑起数据分析，都是实实在在的进步。

可人这一辈子，不能只追求“我让机器做出了什么”，还要关心“这件事让我变成了什么样的人”。

如果 AI 让我们越来越依赖提示、越来越怕公式、越来越没耐心追问 why，那代码产量再高，大脑也在省电模式。反过来，如果它帮我们找可靠材料、陪我们拆问题、画出抽象关系、指出误解，再逼我们闭卷讲一遍，那它就不只是生产力工具，也是一副认知脚手架——脚手架不是让人永远挂在上面，而是为了有一天能独立站住。

今晚不妨挑一个你拖了很久的问题：反向传播、红黑树、傅里叶变换、Raft、Attention，随便哪个。别让 AI 先讲答案，就照那六个字走一遍——问、猜、跑、看、讲、测：写下一个问题和一个猜想，打开 Jupyter 跑个最小实验，看清现象，讲给自己听，隔天再测。

让公式动起来，让算法跑起来，让自己的脑子重新忙起来。

六字真言念给别人听是祈愿；这六个字念给自己听，是把知识一寸寸抓回手里。这才是我想要的 Vibe Learning。

参考资料

1. Project Jupyter 官方网站：Jupyter Notebook 与交互式输出
2. Agarwal 等：Retrieval Practice Consistently Benefits Student Learning
3. Kobayashi：The Retrieval Practice Hypothesis in Research on Learning by Teaching
4. Bjork 与 Bjork：Creating Desirable Difficulties to Enhance Learning
5. Mutlu-Bayraktar 等：Cognitive Load in Multimedia Learning Environments: A Systematic Review

全文思维导图

@startmindmap
* AI 激活大脑
** 核心转变
*** AI 不替代思考
*** 缩短学习反馈闭环
*** Vibe Coding 到 Vibe Learning
** 两种工具
*** LLM
**** 追问、提示、变式
*** Jupyter
**** 公式、代码、图形、实验
** 六步闭环
*** 问
*** 猜
*** 跑
*** 看
*** 讲
*** 测
** 认知机制
*** 主动提取
*** 生成与预测
*** 控制认知负荷
*** 多重表征
*** 适度困难
** 验收
*** 能解释
*** 能预测
*** 能找反例
*** 能迁移
@endmindmap

本作品采用知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议进行许可。欢迎在我的个人网站 https://www.fanyamin.com 访问原文并评论。