Why You Not Student?

高中生用 Claude Code 也能改一个 nano-GPT 跑出"大模型"， 那么一个十几年经验的高级工程师，价值到底在哪里？

一、问题的提出

AI 编程工具（Claude Code、Cursor、Copilot 等）正在抹平"会写代码"这件事的门槛。

• 一个高中生 + Claude Code，几个晚上就能把 nanoGPT 改一改，跑出一个可以"说话"的小模型。
• 一个干了十几年的资深工程师，如果只是"让 AI 写代码、自己点 Accept"，做出来的东西和高中生没有本质区别。

那么，资深工程师存在的意义还剩多少？

📌 Karpathy 在 2026 Sequoia AI Ascent 上的回答（机器之心报道）：

"你可以外包你的『思考』，但你不能外包你的『理解』。"

他还提到几个直接打在这个问题上的判断： - Software 3.0：LLM 是新的计算机，提示词是程序，上下文是内存——"会写代码"已经不再是稀缺技能。 - Jagged Intelligence（锯齿智能）：模型在数学/编程接近"逃逸速度"，但在常识、判断力的山谷里依然摔得很惨。 - 很多 App 根本不该存在：他自己 vibe coding 写的 Menu Gen，在新模型面前直接变成多余的中间层。 - Agentic Engineering：未来招聘看的不是算法题，是你能不能用智能体交付真实项目。 - 认知瓶颈：连 Karpathy 自己都说，他正在成为自己工作流里的瓶颈——瓶颈不在算力，在理解。

这篇 README 想接着 Karpathy 这句话往下推一层： 在 nano-GPT / 大模型训练这个具体场景里， 高中生和资深工程师的区别，到底是不是"理解"？

二、价值区别：不在"写"，在"判断"（即 Karpathy 说的"理解"）

高中生用 CC 做 nano-GPT，能跑通 ≠ 训得好 ≠ 知道为什么这样做。

资深工程师真正不可替代的能力，是 AI 生成不出来的那一层：

1. 专家级别指导模型训练

跑通 nanoGPT 是"复制"，指导一次真正的训练才是"工程"。

2. 知道 AI 生成的代码到底对不对

这是 CC 时代最关键的能力分水岭：

• 高中生只能看代码"能不能跑"。
• 资深工程师要能看代码"对不对、稳不稳、未来会不会爆"。

举几个 nano-GPT/LLM 训练里 AI 经常写错、但跑得通的例子：

• attention mask 的 causal 方向写反 —— loss 照样下降，但模型在偷看未来。
• 位置编码 broadcast 错维度 —— 短序列没事，长序列性能崩。
• mixed precision 下 layernorm 用 fp16 —— 训到一半 NaN。
• gradient accumulation 步数和 lr scheduler 没对齐 —— 学习率曲线全错。
• DataLoader 的 shuffle / seed / drop_last —— 复现性悄悄消失。
• KV cache、RoPE、FlashAttention 的边界条件 —— 推理结果不一样但不报错。

这些 bug AI 不会主动告诉你，只有真正训过、踩过坑的人才能在 diff 里一眼看出来。

CC 把"打字速度"这件事的优势抹平了， 但把"判断力"的价值放大了 10 倍。

⚠️ 杠杆是双向的：AI 同时放大你的能力，和你的错误方向

这是比"AI 写错代码"更危险的一层：

• 方向对 + AI 加速 → 你 1 周做完别人 1 个月的工作。
• 方向错 + AI 加速 → 你 1 周烧掉别人 1 个月才会烧掉的 GPU， 而且因为代码"看起来都跑通了"，你以为自己在前进。

具体在大模型训练里，这种"被放大的错误方向"长这样：

• 选错了 base 模型 / tokenizer，AI 帮你飞快搭好了 pipeline——你越训越偏。
• 数据清洗的判断错了，AI 帮你把脏数据高效地、规模化地喂进了模型。
• 评估指标选错了（比如只看 perplexity），AI 帮你画出了一条漂亮但误导的曲线。
• 早期实验设计错了，AI 帮你把一个本来 3 天就该被砍掉的方向跑了 3 周。

AI 不会问你"你为什么要做这件事"。 它只会非常高效地，把你正在做的事——不管对错——做到底。

所以高级工程师真正的护城河不是"会用 AI"，而是： 在按下 Enter 之前，能判断这个方向值不值得被 AI 放大。

3. 不用 CC，能不能自己手写出来？

这是检验真假高级工程师的终极问题。

如果回答是"不能"——那么你和高中生的区别只是： 你比他更会写 prompt、更会读 AI 的输出，仅此而已。

如果回答是"能"——你才有资格去指导 AI、审查 AI、纠正 AI。

你能不能在没有 Claude Code 的情况下， 手敲出 Transformer、Attention、Tokenizer、训练循环、推理 KV cache？

能 → AI 是你的放大器。 不能 → 你只是 AI 的传声筒。

4. 锯齿智能（Jagged Intelligence）下，谁来填山谷？

Karpathy 提醒我们：模型不是均匀变强的，它是参差不齐的山脊线。

• 山峰：写 Transformer 模板代码、做矩阵推导、套 nanoGPT 训练循环——CC 已经接近"逃逸速度"。
• 山谷：判断"这条 loss 曲线该不该停"、"这个 base 模型适不适合这批数据"、"这个评估指标在骗我"——CC 一脚踩空。

高中生看不到山谷，因为他只在山峰上走（CC 把他抬上去的那段）。 资深工程师的价值，就是在山谷里替模型兜底。

锯齿智能的这些山谷，恰好就是"理解"无法被外包的地方。

二·五、从 nanoGPT 到 Claude 的鸿沟

高中生很容易拿 Claude Code 基于 nanoGPT 改出一个特殊 SFT 的小模型， 但他几乎不可能做出一个 Claude 那种级别的模型。

这中间隔的不是"再多写点代码"——是一整个产业。

这道鸿沟里有什么？

为什么 CC 跨不过这条鸿沟？

因为 Claude Code 不会替你做下面这些事：

• 它不会替你决定用什么数据、什么配比、什么课程学习策略。
• 它不会替你承担 $50M 训练失败的代价。
• 它不会替你判断 loss 曲线在第 3 周突然抖一下要不要紧。
• 它不会替你设计 RLHF 的 reward model 该惩罚什么、奖励什么。
• 它不会替你回答"我们要做一个什么样的模型"——这个问题没有训练数据。

Karpathy 那句"理解不能外包"，落到这里就是： 你得知道"为什么 Claude 是 Claude"，而不只是知道"怎么跑通 nanoGPT"。

所以三条线长这样

[ Claude / GPT / Gemini 级别 ]       ← 顶级研究团队 + 算力 + 工程 + 多年迭代
            ▲
            │   ← 99% 的人跨不过去，CC 也帮不了
            │
[ 微调一个垂直 SFT 小模型 ]            ← 高中生 + CC + 一晚上
            ▲
            │   ← CC 把这条线压平了
            │
[ 跑通 nanoGPT demo ]                  ← 任何人 + 一杯咖啡

高中生 + CC 能做的，是把第一条线（demo → SFT 小模型）压平的那一段。 资深工程师真正的战场，是第二条线——CC 跨不过去的那条。

在那条线上： - 算力是真金白银，错一次烧掉一辆法拉利。 - 数据是策略，不是文件。 - 训练是马拉松，不是 python train.py。 - 对齐是哲学问题，不是 reward 函数。

这条线两边的差距，不会因为 CC 越来越强而缩小—— 反而会因为下面那条线被压平，显得越来越宽。

二·六、理解的带宽：AI 时代真正的稀缺资源

Karpathy 说"理解不能外包"—— 那么 如何提高 AI 内容输入到你大脑的"理解效率"，就成了差距的真正关键。

AI 每秒能生成上万 token， 你大脑每秒能"真正理解"多少？

这是被严重低估的瓶颈：

• AI 输出速度 ≈ 无限（愿意付钱就有）
• 你阅读速度 ≈ 每分钟几百字
• 你真正压缩成心智模型的速度 ≈ 远低于阅读速度

高级工程师的真正护城河，不是"读得多"， 而是"同样的输入，理解得比别人更快、更深"。

三种"理解放大器"——把 AI 输出翻译成大脑更擅长处理的形式

1. 图像化（空间认知）

人脑处理 2D 空间关系比顺序阅读快一个数量级。

• AI 丢给你 500 行 Transformer 代码 → 你画成 dataflow 图。
• AI 讲完 RLHF pipeline → 你画成"模型 / 数据 / reward / 反馈"四盒图。
• AI 输出一段长推理 → 你画成因果链 / 决策树。

看完不画 = 没看完。 画出来的那一刻，才是"理解"发生的那一刻。

2. Lisp 化（结构认知）

把任何东西都看成嵌套的 S-表达式——code is data，idea is also data。

(system
  (input  ...)
  (compute ...)
  (output ...))

(train
  (data   ...)
  (model  ...)
  (loss   ...)
  (eval   ...))

(argument
  (claim    ...)
  (premise  ...)
  (premise  ...)
  (counter  ...))

Lisp 化逼你做两件事： - 找出"核心动词"——这东西到底在做什么。 - 暴露层级结构——谁是子问题，谁是兄弟节点。

当你能用 30 行 S-expr 重写 AI 给你的 500 行内容时， 你才真的理解了它。

3. 咏春武术化（身体化 / 原则化）

咏春不靠记招式，靠记原则：中线、寸劲、连消带打。 原则少而锋利——所以能在 0.1 秒内调用。

把 AI 喂给你的知识也这样压缩：

招式可以查文档。 原则必须长在身上。 review AI 代码的那 5 秒，你调用的不是知识库，是身体化的原则。

为什么"身体化"才是终态？——杨振宁的"物理直觉"

杨振宁： "培养物理直觉，就是让你的本能反应就是正确的。 天才的本质，就是本能做出最正确的反应。"

物理学史上反复出现一种现象：

• 拉马努金"梦到"公式 → 几十年后被一一证明。
• 狄拉克写出方程 → 推出反物质，后来真的找到。
• 费曼物理直觉先行，数学推导跟在后面。
• 杨振宁本人凭对称性的"直觉感"写下规范场论 → 后来成为标准模型基石。

他们的共同模式是：

直觉先行（本能写下）
       ↓
后续推导验证
       ↓
发现是对的

这不是运气。这是原则被训练到本能层之后的自然产物—— 就像咏春高手不是"想"中线在哪，他的身体就是中线。

迁移到大模型工程：

高手 review AI 代码时，先有"这里不对劲"的直觉，再去推导原因。 这就是杨振宁说的"本能反应就是正确的"。

高中生没有这种直觉——AI 给什么，就是什么。

怎么训出这种直觉？

不是靠读得多，是靠反复在原则上做"压缩练习"：

1. 每次踩坑后，把教训压缩成一条不超过一句话的原则。 （例："fp16 下 layernorm 必爆 → 数值精度不够的地方一定要 fp32"）
2. 反复用这条原则去预判下一段新代码 / 新论文。 （主动找机会"在看推导前先猜结论"）
3. 猜对了 → 原则强化。猜错了 → 原则修正。
4. 持续几年后，原则不再需要"想"——它就是你看代码的方式。

这就是咏春的"黐手"训练——不是练招式，是练反应本身。 写代码的人也一样：练的不是 API，是对代码的直觉。

这是 AI 时代真正稀缺的东西。 AI 可以替你查文档、写代码、跑实验—— 但 AI 不能替你"长"出那种"看一眼就知道不对劲"的本能。 那只能靠你自己，年复一年，把原则训进身体里。

差距的真正来源

高中生 + CC：
   AI 生成 → 直接 Accept → 跑通 → 完成 ✅

资深工程师 + CC：
   AI 生成 → 图像化 / Lisp 化 / 原则化
          → 真正理解 → 判断 → 决定接不接受 ✅

中间多出来的那一步—— "把 AI 输出翻译成大脑能高效消化的形式"—— 就是 Karpathy 说的"理解"， 也是高中生暂时还做不到、但资深工程师必须每天做的事。

AI 越强，输入端的理解带宽就越是瓶颈。 谁在提升这个带宽，谁就在拉开差距。

二·七、高维突破点 × AI 扩充面：人机分工的真正形态

上一节说"把 AI 输出变成你大脑的有效表示"。 再深一层是：基于这个有效表示，提出 AI 自己提不出来的"高维突破点"。

人类不可能在 数据规模、参数量、训练算力 上 PK 大模型—— 但人类可以在更高的维度上突破。

高手的高维武器（这些原则不需要 AI 辅助）

1. 最小作用原理（Principle of Least Action）

物理学的本质原则：自然用最少的动作完成事情。 迁移到工程：

• 这个 feature 的最小实现路径是什么？
• 这个 bug 的最小复现是什么？
• 这次训练能砍掉的最大开销是什么？

高手扫一眼就看得出哪里"动作多余"。 高中生看到的是 AI 给出的 500 行实现，看不到那 50 行就够。

2. 最小可运行（Minimum Viable）

不是"完整版本"，是"能验证假设的最小切片"。

• 训一个 1B 模型验证 trick？不，先训 100M。
• 改 attention 实现要全套测？不，先让 forward pass 数值对得上。
• 试一个新的 RL 思路？不，先在 GridWorld 上验证三天。

高手的第一反应永远是"这事的最小验证版是什么"。 高中生让 CC 生成一个完整工程，然后训不动了。

3. "为什么不行"（反向思维 / 失败先验）

正向问"怎么做" → AI 很会答。 反向问"这个方向为什么不行 / 已经失败过 / 注定会爆" → 这才是高手的雷达。

• 这个架构为什么 OpenAI 三年前试过然后放弃了？
• 这个数据集为什么"看起来很大"但其实没用？
• 这个 metric 为什么会骗人？

高手 5 秒否决一个错误方向，省下 5 周。 高中生让 AI 把这个错误方向完整实现了一遍，然后才发现不行。

人机分工的真正形态：点 × 面

高手：
   提出 1 个有效的突破点（高维 / 难 / 稀缺）
            │
            ▼
   AI：把这 1 个点扩充成 1 个面（低维 / 易 / 量产）
            │
            ▼
   ✅ 一次有效的工作

------------------------------------------------------------

高中生：
   提不出有效的点（不会最小作用 / 不知道为什么不行）
            │
            ▼
   AI：扩充出一个看起来很大、但根上就错的面
            │
            ▼
   ❌ 忙了一周，方向是错的

AI 的优势是 "面的产能"。 人类的优势是 "点的精度"。

一个错的点 × 无限大的面 = 0。 一个对的点 × 无限大的面 = 一切。

所以核心能力链是这样

1. 把 AI 的输出转化成你大脑里的有效表示 （二·六：图像化 / Lisp 化 / 原则化）
2. 基于这个有效表示，提出一个高维度的、有效的突破点 （本节：最小作用 / 最小可运行 / 为什么不行）
3. 让 AI 把这个点扩充成面，再用你的判断接住它 （二、二·五：审判 + 兜底）

这三步，没有一步可以外包给 AI。 这三步，就是 Karpathy 说的"理解"在工程中的真实样子。

二·八、落到地面：在大模型训练里，高手到底在做什么？

前面所有抽象的"判断 / 理解 / 突破点"，落到具体的训练工作里，长这样：

模式对比

三个高手才会做的具体动作

1. SFT 合成数据的迭代设计

不是"找一份数据集训完拉倒"，而是把数据当成可迭代的产品：

v0 数据  →  训练  →  eval 找 bad case
                              │
                              ▼
   设计专门针对 bad case 的合成数据 prompt
                              │
                              ▼
v1 数据（v0 + 针对性增强） →  训练  →  eval
                              │
                              ▼
                  ……步步为营，每轮都更靠近目标

关键不是"生成更多数据"，是"生成正确的下一批数据"。 高中生不知道 bad case 长什么样、也不知道该补什么数据。 高手能从 100 条 bad output 里抽出 3 类失败模式，然后精确地合成对应数据。

2. RL 方法的选型与设计

不是"听说 RLHF 牛就上 RLHF"，而是：

• 这个任务有没有可验证 reward？→ 有 → 直接 RLVR / GRPO。
• 没有 → 能不能用 LLM-as-judge？→ 能 → RLAIF。
• 都不行 → 收人类偏好 → DPO / PPO。
• reward hacking 了？→ 加约束 / 加 KL 惩罚 / 改 reward model 设计。

RL 不是一个"按钮"，是一套系统设计问题。 选错 RL 方法，烧 10 万美金算力换来一个更糟的模型——这种事天天发生。

3. 步步为营的训练节奏

每个 checkpoint 都要回答三个问题：

1. 比上一个 checkpoint 强在哪？弱在哪？
2. 下一步该补什么数据 / 改什么 hyperparam / 加什么 RL 信号？
3. 要不要回退？（高中生从不回退，高手回退是常态）

训练不是一条直线，是一棵有剪枝的搜索树。 高中生在跑直线，高手在走树。

高手设计的是"训练系统"，不是"训练脚本"

高中生 + CC：
   写一个 train.py → 跑 → 出问题贴给 AI → 改 → 跑 → 玩具完成 ✅

高手 + CC：
   设计一个迭代系统：
     ├── 数据生成 / 清洗 / 配比策略
     ├── 训练 / checkpoint / 回退机制
     ├── 评估 / bad case 收集 / 反向喂数据
     ├── RL 设计 / reward 监控 / hacking 防御
     └── 每轮记录假设、实验、结论
   ↓
   不是"一次训练"，是"**会自己进化的训练流程**"

高中生让 AI 帮他写代码。 高手让 AI 帮他实现系统的某一部分——但系统是他自己设计的。

这才是 Karpathy 说的"导演"： 镜头 AI 来扛，剧本你来写。

二·九、Harness（马具）工程：缰绳即护城河

当下最前沿的 agent 思想，叫 harness 工程——马具之意。 用好 AI 就像给烈马上缰绳： 没有马具，AI 是脱缰的野马；有了马具，AI 才是能拉车、能打仗的力量。

为什么需要马具？

高中生用 CC：让 AI 自己跑——跑哪儿是哪儿。 高手用 CC：先设计 harness——AI 在缰绳里跑，每一步都是有效的。

Harness 不只是推理时的脚手架——它直接进训练

这是新一代 agent 思想最深的一层：

传统视角：
   训练 → 模型 → 套个 agent 框架去用

新视角（harness × RL 协同设计）：
   ┌─→ 设计 harness ──┐
   │                   ├─→ harness 当训练环境 → RL → 模型天生适配
   └─→ 设计训练目标 ──┘

具体例子：

• 可验证 reward（RLVR）：需要 harness 能自动判定对错——agent 的 verifier 直接成为训练信号。
• 工具使用能力：不是预训练学来的，是在带工具的 harness 里 RL 训出来的。
• 长程任务规划：需要 harness 提供合理的子任务边界——边界设计错了，RL 学不到东西。
• Constitutional AI：那个"宪法"本身就是 harness 的一部分——它既约束推理，也约束训练。
• Claude Code 的能力：来自于 Anthropic 把 Claude Code 的 harness 直接当成训练环境去 RL。

模型 ≠ 产品。 模型 + harness = 产品。 而且 harness 设计得好不好，反过来决定模型该长什么样。

整体化优化：合力打出去才是王道

高中生的画面：
   [模型]  独自挥拳 → 没招式 → 打哪算哪

高手的画面：
        ┌──── harness（马具 / 招式）─────┐
        │                                  │
  [数据] [模型] [RL] [eval] [tools] [memory]
        │                                  │
        └─────────── 协同优化 ─────────────┘
                       │
                       ▼
                  一记真正的"合力拳"

整体化优化 = 数据 / 模型 / RL / harness / eval 同时调。 任何一个单独优化都没用—— 真正的工程是合力打出去。

落回到 nano-GPT vs Claude 的鸿沟

训练一个 SFT 小模型 vs 训出 Claude，差的从来不是参数量。 差的是马具，是合力，是整套缰绳。

高中生还在练拳，高手已经在设计马场。

二·十、自循环递归训练：用 agent 反向喂养模型

上一节说 harness 是模型的缰绳。 再深一层：harness 还能反过来——用 agent 去训练这个模型自己。

这是当下最前沿的"自进化模型"思想—— 模型自己造数据、自己评分、自己迭代、自己变强。

三种训练范式的演进

不是"AI 替人写代码"。 是 "AI 替人训练 AI"。

具体例子：SWE-agent × RL

设计一个 SWE 智能体，让它：

1. 拿一堆真实 GitHub issue。
2. 在沙盒里读代码、改代码、跑测试。
3. 测试通过 → reward = 1；不通过 → reward = 0。
4. 把这些 trajectory 喂给 RL → 模型学会"在真实仓库里 debug"。

真实 issue ──→ SWE-agent 尝试解决 ──→ 自动跑测试
                                          │
                                          ▼
                            通过 / 不通过 = 自动 reward
                                          │
                                          ▼
                          RL 训练  → 模型 debug 能力 ↑
                                          │
                                          ▼
                     更强模型 → SWE-agent 表现更好 → ……（递归）

关键：reward 不需要人类来标，测试套件就是 verifier。 人类被踢出了执行回路——只剩下"设计这个回路"的工程师。

这一思想的家族（最近 2 年的前沿都在这里）

共同结构：

找一个能自动判对错的环境 → 把 agent 扔进去 → 让 agent 的成功率成为训练信号 → 模型在这个环境里递归自我提升。

为什么这是高手才做的事？

设计一个自循环训练系统，要回答的问题没有一个 AI 能替你答：

• 找 verifier：哪些任务有可自动验证的"对"？（debug 有：跑测试。聊天没有：所以才需要 reward model。）
• 设计 agent：什么样的 harness 能采到高质量 trajectory？
• 防 reward hacking：模型会不会找到 verifier 的漏洞而非真的解决问题？（极常见，也极致命）
• 课程设计：先训简单 issue 还是先训难的？是否做难度排序？
• 数据多样性：怎么避免模型在自循环里"坍塌"成单一模式（mode collapse）？
• 防过拟合到 verifier：测试通过 ≠ 代码真的对。
• 算力分配：探索 vs 利用、agent rollout vs RL update 的比例如何？

这些问题的答案 决定了整个系统能不能自我进化—— 答错一个，模型在循环里越训越蠢（mode collapse / reward hacking / verifier 漂移）。

高中生连这些问题都问不出来。

AI 时代工程能力的三层抽象

第一层：用 AI 写代码                        ← 高中生 + CC
                                              │
                                              ▼
第二层：用 AI 跑 agent，完成任务              ← 入门工程师
                                              │
                                              ▼
第三层：用 agent 反过来训练 AI，让 AI 自己变强 ← 最前沿研究员 / 高级工程师

每往下一层，人类被移出回路一次—— 但设计这个回路的工程能力，反而越来越稀缺、越来越值钱。

       价值 ↑
            │                    ⭐ 设计自循环
            │                  /
            │                /
            │             ⭐ 设计 agent harness
            │           /
            │         /
            │      ⭐ 用 AI 写代码
            │    /
            └──────────────────→  人类被移出回路的程度

人类离执行越远，离设计越近，价值越高。

落回到主线

Karpathy 说"理解不能外包"。 在自循环训练这里，最不能外包的"理解"就是：

"我设计的这个循环，到底会让模型变强，还是变蠢？"

这个问题没有任何 AI 能替你回答。 这就是高级工程师在 AI 时代真正的位置—— 不是写代码的人，不是跑 agent 的人，是设计"AI 自我进化回路"的人。

三、所以高级工程师在 AI 时代的定位

不是"写得更快的码农"，而是 Karpathy 说的那种"导演"：

1. 训练的指导者：知道往哪个方向调、为什么这么调、什么时候停。
2. 代码的审判者：在 AI 输出的 diff 里，能 5 秒抓出那条会让训练悄悄出错的语句。
3. 从零构建的能力者：CC 是杠杆，不是拐杖；杠杆断了，你照样能走路。
4. 锯齿山谷的填补者：在模型摔下去的地方，用"理解"接住它。
5. 方向的判断者：在按下 Enter 之前，决定这个方向值不值得被 AI 放大。

四、给自己的检查清单

关于"手写"（手 vs AI）

• [ ] 不用 CC，我能在 2 小时内手敲出一个最小可训练的 Transformer 吗？
• [ ] 我能解释 nano-GPT 每一行代码背后的数学原因吗？

关于"判断"（看 AI 输出对不对）

• [ ] 给我一段 AI 写的训练代码，我能在不跑它的情况下找出 3 个潜在 bug 吗？
• [ ] 我能从 loss 曲线判断："这次训练已经废了，不用等 epoch 跑完"吗？
• [ ] 我能设计一个实验，把"模型变好"归因到具体的某个改动上吗？

关于"理解带宽"（把 AI 输出转成大脑的有效表示）

• [ ] 看完 AI 给的复杂代码 / 论文，我能在 5 分钟内画出一张图来概括它吗？
• [ ] 我能用 30 行 S-表达式重写 AI 给的 500 行内容吗？
• [ ] 我能从一段技术细节里抽出"招式 vs 原则"，并只把原则记下来吗？

关于"高维突破点"（提出 AI 提不出来的问题）

• [ ] 不用 AI，我能在 5 分钟内提出 3 个"这个方向为什么不行"的理由吗？
• [ ] 面对一个新需求，我的第一反应是"最小可运行版本是什么"吗？
• [ ] 我能在 AI 给我"看起来完整"的方案前，先看出哪里"动作多余"吗？

答得出来，你就还在 AI 之上。 答不出来，你就在被高中生追上。

"Why you not student?"——不是嘲讽，是提醒： 当工具把每个人都变成"学生"，你凭什么继续是"老师"？

参考

• 机器之心，《Karpathy：很多 App 就不该出生、人类唯一护城河只剩理解、CPU 将沦为配角》，2026-05-01 （Andrej Karpathy 在 Sequoia AI Ascent 2026 的炉边对谈）

全文金句：

"你可以外包你的『思考』，但你不能外包你的『理解』。" —— Andrej Karpathy