收藏了两百门课，全栈到底要学多少东西才算够？

我的收藏夹里，认真数一数，大概真能凑出两百门课。

前端。后端。Java。Python。Rust。C++。Docker。Kubernetes。CUDA。大模型。Agent。强化学习。计算机网络。操作系统。体系结构。再往下面翻，还有几门嵌入式。每一门收藏的时候，理由都特别充分。

“这个以后肯定有用。”

问题也出在这里。

学计算机有一个特别恐怖的地方：值得学的东西，几乎永远都能为自己找到一个合理的理由。

一开始，你真的只是想做个网页。

就那种标题居中、按钮会动、写进简历都能开心半天的网页。

想让按钮动，得会 JavaScript。

用户数据总得存起来，后端了解一下。

数据不能一直塞内存里，数据库安排上。

项目做完总得给别人访问，Linux、Nginx、Docker 已经排着队冲过来了。

你以为差不多了。

AI 时代又拍了拍你的头。

Python 总得会吧？

大模型总得懂吧？

RAG 听说过没？

Agent 跑过吗？

MCP 又是啥？

模型总得部署吧？

vLLM、SGLang 看不看？

性能再往下抠一点，CUDA、Triton、量化、显存、算子全出来了。

再顺着算子往地底下一挖：

GPU。NPU。编译器。驱动。芯片架构。

旁边还有机器人、边缘设备、嵌入式朝你招手。

恭喜。

本来只想做个网站的萌新，如今已经开始思考要不要顺路考个电气工程师证了（bushi）。

最让人停不下来的，并不是这些东西太多。

是它们看上去真的都有用。

你很难理直气壮地说：

“这个跟我没关系。”

打开 GitHub，有人在用。

打开招聘软件，岗位里真写着。

刷两个技术视频，又有人告诉你：

“这个以后一定是基本功。”

于是再收藏一个。最后收藏夹里一片欣欣向荣。项目目录里一片荒凉。

边界膨胀机制：全栈为什么越学越大

以前大家说全栈，意思还挺明确。前端。后端。数据库。

React 写页面，Node.js 跑接口，MySQL 存数据。

齐活儿。

简历上甚至敢直接印：

Full Stack Developer。

对很多 Web 产品来说，这套东西确实够。

麻烦通常出现在项目从“能跑”往“有人真用”挪的那一步。

鉴权、权限、会话、密码安全、验证码、风控都跟着出来。

数据库也不只是建几张表。

索引、事务、迁移、连接池、备份和恢复开始变得具体。

服务成功启动之后，还有日志、监控、告警、证书、网络、负载均衡、容灾。

任何一个环节都有资格在半夜三点把你叫起来。

软件工程里很多复杂度，在第一天根本不会主动现身。

十个用户的时候，数据库怎么写好像都能跑。

只有一台服务器时，也轮不到你研究服务发现。

请求量没上来以前，“高并发”主要存在于八股文。

规模一上去，原来被藏起来的问题才会一点一点浮上来。

教程很擅长展示 happy path。

工程的麻烦恰好都活在 happy path 外面。

这也是所谓“全栈”越来越难划边界的原因。

前端和后端之间有接口。后端和数据库之间有接口。应用和操作系统之间有接口。服务和网络之间有接口。

AI 接进来之后，这种横向连接又多了一层。

于是一个个人开发者，慢慢承担起了过去一个小团队才会拆开的角色：

前端、后端、运维、数据、AI。

项目做出来没人用？

产品和运营也可以顺手兼职一下。

能力半径机制：AI 让墙变矮以后，你看见了更多山

这里有一个很反直觉的现象。

工具越来越强，人不一定越来越轻松。

AI 写代码、查报错、补文档、搭页面，确实砍掉了大量过去需要亲自完成的工作。

这一点没必要绕。

生成侧的复杂度真的下降了。

以前做一个陌生功能，可能要看半天文档。

现在先让模型给一个能跑的版本，再沿着结果改。

以前完全不会 React，做个后台页面能卡几天。

现在给 Agent 一张截图，几个来回就能把架子支起来。

以前部署是很多学生项目走不出去的一道墙。

今天一份日志加一段描述，AI 能陪着你把 Nginx、Docker、证书一路排下去。

问题恰恰在墙变矮以后出现。

以前不会就是不会。

“我不会前端”，是一条很清楚的边界。

“我不会部署”，也可以理直气壮地找别人。

现在越来越多事情变成：

“理论上我好像也能做。”

一个前端不会写一点 Python？

“问 AI 啊。”

后端不会 React？

“让 Agent 搓一下不就行了？”

Docker 没学过？

“先让模型帮你配。”

AI 扩张了一个人的能力半径，也顺手扩张了“我是不是应该会”的心理半径。

以前你只看见眼前那堵墙。

墙矮下去以后，后面的山全露出来了。

这种变化也解释了为什么 AI 焦虑和 AI 普及可以同时发生。

《南方人物周刊》在回顾 AlphaGo“人机大战”十年时，观察到一种很有代表性的转变：最初人们更容易焦虑机器是否会超过自己，今天越来越多人担心的是自己有没有跟上 AI。追工具、补课程、学最新能力，其中很容易混进 FOMO——害怕错过、害怕被甩下。(infzm.com)

以前怕 AI 太快。

现在更怕自己太慢。

验证迁移机制：代码便宜以后，检查代码开始占位置

AI Coding 还有一个容易被“效率提升”四个字盖过去的变化。

生成一个结果便宜以后，工作不会凭空消失。

有一部分被压缩了，另一部分往后移动。

Stack Overflow 2025 年开发者调查里，一个很扎眼的数字是：66% 的受访开发者表示，自己花了更多时间处理那些“差一点就对”的 AI 生成代码。(stackoverflow.blog)

以前最麻烦的是：

“这个怎么写？”

以后越来越常见的问题可能是：

“这东西看起来已经写好了，我敢不敢用？”

写一个 CRUD 便宜了。验证业务边界还在。Nginx 配置生成出来了。你仍然要知道线上为什么 502。AI 能给你三种数据库方案。

总得有人知道哪一种适合现在这个系统。

这里容易冒出一句很诱人的总结：

“执行变便宜，判断变贵。”

这句话只说对了一半。

后面还有一个更麻烦的问题：

如果判断本身，也开始交给 AI 呢？

这个问题躲不过去。

判断侵蚀机制：如果 AI 连“想”也替你想了呢

AI 当然不只会执行。

它也在越来越多地承担比较、筛选、分析、规划、审查甚至决策。

让模型：

“比较这三个方案。”

“检查这段代码有没有风险。”

“替我反驳一下。”

“判断哪种架构最好。”

都已经是很普通的用法。

假如未来模型的代码审查比大多数程序员更准，架构建议也比普通工程师更成熟，那还坚持“人最值钱的是判断力”，多少有点像在给自己找最后一块精神自留地。

这也是我觉得真正需要正面承认的地方：

人的判断力没有永久升值保证。

它同样可能退化。

Microsoft Research 和卡内基梅隆大学的研究者在 CHI 2025 调查了 319 名知识工作者，收集了 936 个真实使用 GenAI 的工作案例。一个很有意思的结果是：对 AI 越有信心的人，报告的批判性思考越少；对自身任务能力越有把握的人，反而更容易主动进行批判性检查。研究者观察到，AI 介入以后，很多思考活动开始转向信息验证、结果整合和任务把关。(microsoft.com)

这给“善用 AI”加了一个挺讨厌的悖论：

AI 越好用，越容易让人失去检查它的动力。

工具越可靠，人越容易把手从方向盘上拿开。

长期下来，如果大量低层判断都不再亲自经历，支撑高层判断的经验从哪里来，也会变成一个真实问题。

这并不意味着每一次都得和 AI 较劲。

如果有一天 AI 对某类常规代码的判断真的达到足够高的可靠度，继续让人逐行重新检查，反而是一种浪费。

人的角色会继续往上移动。

从：

“这行代码对不对？”

移动到：

“这个任务值不值得做？”

“这里错一次的代价有多大？”

“这个场景能不能放心交给 AI？”

“什么时候应该提高验证强度？”

“模型正在一个熟悉分布里工作，还是已经跑到了边界外？”

再往未来，这些元判断也可能继续被自动化。

那就再往上移。

没有哪一层天然属于人类。

更现实的策略，是在每一次能力迁移发生时，保留足够的理解，让自己知道哪些判断已经可以放心外包，哪些地方依然值得亲自握住。

“判断力”如果还有价值，价值就在这里。

不是永远比 AI 判断得准。

是知道什么时候可以相信它，什么时候不该。

能力错觉机制：AI 帮你做过一个项目，不代表这项能力已经长在你身上

AI 还有一个特别容易让人上头的地方。

它可以极快制造“我已经会了”的感觉。

以前做一个网站，前端不会就卡在前端。

后端不会就卡在接口。

部署不会，项目基本出不了 localhost。

现在告诉 Agent：

“帮我做一个 XX。”

一下午。页面有了。接口有了。数据库有了。Dockerfile 也有了。整个过程反馈极快，成就感也是真的。

这也是 Vibe Coding 很容易让人沉进去的原因。

游戏的反馈周期很短。

做任务、升级、拿奖励。

AI 编程第一次让现实世界里的很多任务，也有了类似的即时反馈。

不同之处在于：

游戏里升到一百级，关掉游戏以后，等级留在那里。

AI 帮你做出的系统，是真的可以上线。

真的可以被访问。

甚至真的可能赚钱。

借助 Agent 完成过去做不到的事情，能力半径确实扩大了。

可“我完成了这个项目”和“我拥有独立完成这类项目的能力”，之间仍然有距离。

南京大学蒋炎岩老师的《生成式软件工程》课程最近因为“没有付费 Token 就退学”的玩笑引发了不少讨论。真正值得看的其实是后面的课程目标：学生不仅要让 AI 写代码，还需要拆任务、挑模型、控制成本、验证结果；课程规则同时明确写着“不需要 Tokenmaxxing”。

Token 烧得多，不自动等于会用 AI。

项目生成得多，也不自动等于工程能力增长。

真正带得走的，是 AI 卡住以后你会怎么查，是换一个项目后你还认不认得问题，是抽掉当前模型以后你有没有办法解释自己为什么这么设计。

“做过”正在因为 AI 变得越来越便宜。

“理解自己做了什么”没那么容易降价。

技术通胀机制：十年前叫 Framework Fatigue，现在整个行业一起 Fatigue

今天这种“怎么永远学不完”的感觉，其实并不新。

2015 年，JavaScript 社区就认真讨论过一个词：

Framework Fatigue。

框架疲劳。

Tero Parviainen 当时描述的状态，放到今天看几乎没有年代感。

新框架不断冒出来。

你明知道不可能全部跟上，又忍不住想：

现在学的是对的吗？

有没有更好的？

这个东西过半年会不会没人用了？

我是不是正在把时间花在错误的地方？

他当时还提出一个特别实用的概念：

known unknowns。

知道一项东西存在，也知道自己目前不懂它，本身就是一种有效的知识状态。(teropa.info)

同一时期，Allen Pike 把 JavaScript Framework Fatigue 和一个更经典的心理学概念联系在了一起：

Paradox of Choice。

选择悖论。(allenpike.com)

Barry Schwartz 更早以前就在 TED 演讲里讲过：选择增加并不保证人会更满意。选项多到一定程度以后，人可能更难行动，也更容易怀疑自己的选择。(ted.com)

放到程序员身上很好理解。

选择少的时候，烦恼是：

“没有合适的工具。”

选择多的时候，烦恼变成：

“会不会还有更好的工具？”

十年前主要是 Angular、React、Ember 在打架。

今天再叫 Framework Fatigue，多少有点委屈 JavaScript 了。

前端在变。云原生在变。AI 在变。推理框架在变。Agent 在变。芯片生态也在变。模型几个月一代。开发工具一星期来几个。AI 没有创造“学不完”这件事。

它把原本已经存在的技术通胀又推快了一截。

生态扩张机制：新东西一直来，旧东西却没有整齐退场

更麻烦的一点是，技术行业并没有朝“一种万能技术”慢慢收敛。

GitHub Octoverse 2025 里，TypeScript 首次成为 GitHub 使用最多的编程语言；Python 同时继续保持 AI 项目的核心地位。Java、C#、C++ 等生态也没有因为 AI 到来而消失。(github.blog)

这件事真正值得看的，不是谁排第一。

是：

旧栈没有退，新栈一直加。

Web 还在。数据库还在。操作系统还在。网络还在。Java 企业栈还在。C++ 系统栈还在。

头顶又多了模型、Agent、向量检索、推理框架、GPU/NPU。

老楼没有拆。楼层一直往上盖。电梯还堵。

这也是为什么 Python 用着用着，人很容易开始想 Java。

做 AI、数据、大模型，Python 当然舒服。

模型有。

框架有。

论文刚出来，社区里很快有人给你搓个包。

十几行代码，一个想法先跑起来。

哪天摸到大型商业后端，再看 Java 世界：

Spring。消息队列。服务治理。注册中心。配置中心。

名词密度高到让人怀疑自己是不是进错考场了。

一种不踏实很快就会冒出来。

“Python 用起来这么轻，是不是不够工程？”

“不会 Java，是不是能力不完整？”

再刷两个视频。C++ 是基本功。收藏。Rust 是未来。收藏。Go 才适合云原生。继续收藏。

最后又有人说 AI 时代 Python 才是主力。

绕了一圈回到原点。

这里其实没有一个全局答案。

你天天做模型、评测、数据管线，Python 就是主力枪。

以后真的开始长期扛大型企业服务，Java 自己会跑到你的面前。

技术栈不是宝可梦。

犯不着为了图鉴 100% 收集率，把所有语言挨个抓一遍。

真正该问的是：

你手里现在拧的，是哪颗螺丝。

抽象泄漏机制：然后，硬件来了

上面的争论至少还属于软件圈内部的家庭矛盾。

真正的次元壁，往往在硬件那里。现在越来越多项目开始跨界。机器人要软硬件协同。边缘 AI 要抠设备资源。

NPU/GPU 部署得看显存、算子、精度、吞吐。

工业现场还有 PLC、传感器等着你。

这时候你会突然意识到：

软件世界从来没有悬在空中。

每一行代码最后都踩在某块硬件上。只不过云服务长期把地基藏得很好。接口写完，点一下部署。服务器跑了。

CPU 什么架构？

网络怎么走？

磁盘怎么挂？

驱动在干什么？

大部分时候完全没必要知道。

抽象层本来就是用来帮你忘掉下面这些东西的。

直到某天，真的把模型部署到一块 NPU 板子上。

一跑。

算子不支持。

顺着文档往下查：

算子适配。量化精度。编译链。运行时。驱动。芯片架构。板子就在手边，风扇呼呼转。你知道它正在干活。

就是不知道该从哪儿把软件接进去，也不知道眼前这个错到底怪模型、框架、环境还是驱动。

这时候很容易产生一种冲动：

“是不是该把体系结构和电子工程全补一遍？”

不至于。

你只是走到了另一个专业的门口。

门槛可以迈进去看看，坑没必要替人家填满。

比较放大机制：算法给你制造了一个不存在的超级同龄人

技术供给之外，还有另一种压力。别人的进度。打开 GitHub。

有人周末搓个项目，两天几千 Star。

打开 B 站。《大学四年必须学完的计算机路线》。刷到 X。有人十八岁写编译器。有人高中做 Agent。有人本科发顶会。

真正改变体验的，并不是厉害的人突然变多了。

厉害的人一直存在。

算法第一次把所有人的高光时刻，持续送到了同一个屏幕里。

甲 C++ 最强的那天。乙论文接收的那天。丙创业融资的那天。

丁项目上 Trending 的那天。

戊拿 Offer 的那天。

最后拼成一个并不存在的：

超级同龄人。

你再拿这个人跟自己的星期三下午四点比。

当然觉得自己什么都不会。

后浪研究所 2026 年对 1008 名年轻人的调查里，接近七成受访者表示每天使用 AI，但按照调查自己的评分方式，仍有 30.5% 落入“高 AI 焦虑”组。调查里，“周围人都比我更懂 AI”的感受也和更高焦虑明显关联。(thepaper.cn)

AI 用得更多，并没有自动生成安全感。

因为“够不够”如果始终由别人决定，终点就会一直移动。

信息流驱动机制：学习什么时候开始脱离问题

比较机制再和推荐算法叠起来，学习很容易发生一个变化。

本来只是项目数据库慢，准备研究一下索引。

打开视频平台。《Rust 将重写一切》。点进去。

下一条：

《为什么现在不会 Agent 已经晚了》。

再下一条：

《程序员必须补的底层能力》。

再下一条：

《真正拉开差距的是 CUDA》。两个小时以后。索引没看。倒是新增了十四项学习计划。这里的区别很细。一种学习是问题把知识拉进来。

另一种学习，是信息流把知识推给你以后，你开始替它寻找一个“我为什么应该学”的理由。

前一种天然有优先级。后一种没有。于是人会很忙。一直看。一直收藏。一直规划。

半年以后，主线没长粗，旁边堆出一大片“以后可能有用”。

这已经很接近技术型囤积了。

Learning Maxxing 机制：最容易上瘾的是不断重新开始

现在 AI 圈很喜欢在词后面加一个 maxxing。

Tokenmaxxing。Context maxxing。各种 maxxing。

蒋炎岩那门课反倒明确强调：

不需要 Tokenmaxxing。

Token 烧得多，不代表 AI 用得好。

学习也是一样。

有些人的问题已经不是不用功。

是开始 Learning Maxxing。

Java 来一点。Rust 来一点。CUDA 补一点。Agent 再补一点。课程数量拉满。收藏数量拉满。每天学习时间拉满。

仿佛吞吐够高，就能追上整个技术世界。

人的大脑又不是推理集群。

形成真正的能力，需要在同一个问题上停留。

遇到错误。看不懂。试错。重新理解。再做一次。

这些环节有一个共同特点：

慢。

而新的技术永远更容易给人即时成就感。

第一小时最爽。看架构图。跑 Hello World。项目启动成功。

“我懂了。”

第十五个小时开始不一样。报错没有教程。抽象开始泄漏。文档只讲了一半。你第一次需要自己判断下一步往哪挖。真正的学习经常从这里才开始。

可新框架永远在旁边提供另一个第一小时。

于是很多人没有输在不会开始。

输在太擅长重新开始。

注意力预算机制：每个人其实只有几枚 Learning Token

工程圈里有篇很经典的文章：

Choose Boring Technology。

Dan McKinley 在里面提出过一个很好玩的比喻：

团队只有有限数量的 Innovation Tokens。

数据库上一套所有人都不熟的新东西，花一枚。

运行时也追新，继续花。基础设施再来一套。很快整个系统都建立在陌生组件上。

真正拖累团队的，往往是这些未知组合以后出现的认知成本、维护成本和故障模式。(mcfunley.com)

放到个人身上，同样成立。

一个人一年真正能投入几百小时，最后学到“能打”的东西，大概不会有三十项。

那就假装自己手里只有三枚 Learning Token。

今年一枚给 AI。一枚给安全。一枚给系统。用完了。Java 当然重要。Rust 也不错。CUDA 有价值。

Kubernetes 以后可能会遇到。

机器人前景很好。这些判断可以同时成立。可预算还是只有三枚。

真正成熟的学习规划，本身就包含放弃。

什么值得狠狠干三个月？

什么看完 Overview，知道它能解决什么就够？

什么留一个链接？

什么哪怕很重要，今年也先不碰？

最难的往往是最后一个。

允许一个重要的东西，暂时和自己无关。

技术分层机制：知识不只有“会”和“不会”

很多焦虑来自一个过分简单的技能模型。

Rust。会 / 不会。CUDA。会 / 不会。数据库。会 / 不会。

只要没有系统学过，就觉得技能树上有个大洞。

真实工程里的知识层次细得多。听过名字。知道它解决什么。知道主要取舍。能判断大概适不适用。能跑 POC。能独立开发。能排常见错误。能处理复杂问题。能设计。能改底层。

Tero Parviainen 说的 known unknowns，在这里就特别有价值。

知道“这里有一个我目前不懂的东西”，并且知道真遇到问题应该往哪里找，已经是一种有效状态。(teropa.info)

地图上标了一个城市，不代表现在就得搬过去住。

我更习惯把个人技术地图粗暴分成三层。

第一层：主战场，要能打

这是吃饭的家伙。

不能停在：

“我用过。”

“跟着教程跑过。”

“AI 帮我写过。”

比如主场是大模型、安全、评测、数据管线。

Python、模型调用、数据处理、推理部署得真正能用。

框架报错，敢顺着日志往下刨。

效果不对，知道先看数据、参数还是系统。

性能有问题，能拆出模型、预处理、显存、通信几个方向。

换一个项目，这些能力还能带过去。

这一层需要深度。

十门语言都写过 Hello World，替代不了一个真正能往下挖的方向。

第二层：系统接口，要接得上

做 AI 平台，前端不一定是主业。

你不用研究浏览器渲染引擎，但组件、请求、状态、鉴权最好认得。

数据库也不需要研究到内核。

索引、事务、连接池把服务拖死的时候，至少知道往哪里看。

Linux、Docker、Nginx、网络一样。

这里最重要的能力是定位。

问题大概在哪一层？

日志在哪？

第一步看什么？

怎么缩小范围？

什么时候继续自己查？

什么时候摇人？

很多老司机并不是每层都会修。

他只是看到报错以后，不会只剩一句：

“怎么坏了？”

第三层：邻近专业，认得路

做 NPU，下面还有算子、编译器、驱动。

机器人往下是控制、电机、传感器。

安全往下可能撞内核、逆向、密码学。

走到这些边界时，不用条件反射地把整个专业补完。

先把接口画清楚。

输入是什么？

输出是什么？

最关键的约束是什么？

哪类错误自己还能继续定位？

什么情况已经明显进入专业人士的地盘？

对于 NPU 部署，你可以不懂芯片设计。

但知道模型怎么变成算子、算子怎么编译、运行时和驱动大概站在哪，已经足够解决很多实际问题。

认得路，不等于每条路都要自己修。

触发升级机制：一项技术什么时候值得进主线

Java、Rust、C++ 到底什么时候补？

我现在越来越喜欢一个很朴素的判断：

看它解决的问题，有没有反复出现在你身上。

做 AI 应用，Python 一直够用。

Java 可以暂时停留在“知道它擅长什么”。

直到企业核心业务、复杂服务治理长期缠上来，Java 自然会从地图边缘往中心移动。

推理性能、内存、运行时、算子反复成为瓶颈。

C/C++ 优先级自己就上去了。

真开始维护一套既在乎性能、又很在意内存安全的系统工具。

Rust 这时候再从：

“见过一面”

升级成：

“咱俩处处吧。”

项目最大的好处，是它会替知识排序。

以前教程里看：

“这里涉及线程安全。”

脑子：

“哦。”

线上真炸过一次。

再看到线程安全：

“哦！！！！”

到那个时候的学习，不叫收藏。

叫灭火。

而人在着火的时候，学习效率一般都挺高。

主线聚合机制：同样十项技术，一个是一棵树，一个是一地树枝

全栈走到最后，真正困难的地方经常不是技术。

是聚合。前端有人说前端有未来。安全有人说安全永远刚需。AI 有人说这是最大的浪潮。机器人又有人说具身智能才是下一站。

去芯片圈坐两天，可能听到：

“底层才是真东西。”

再去理论的人那里坐两天：

“数学才是灵魂。”

这些话放回各自语境里，很多并没有错。

麻烦在于一个人没法同时活在所有语境里。

如果主线是大模型安全：

Python 用来做模型和评测。

前端为了把平台搭出来。

Linux 和网络为了让系统跑起来。

NPU 和性能优化为了把模型落到真实算力上。

以后需要 Java，就补。需要 Rust，再补。需要读一点编译器，也可以看。表面上技能很杂。

Python、Vue、Docker、Nginx、MySQL、Linux、NPU……

可它们都围着同一个问题生长。

另一个人同样会这十样。

每一项都来自：

“刷到别人说有用，所以学了两天。”

数量一样。

结构完全不同。

一个是一棵树。

一个是一地树枝。

树之所以是树，不靠枝条数量。

靠的是它们最后都连在同一根主干上。

停止条件机制：真正困难的是决定哪里可以不挖

回到最开始的问题。

全栈到底要学多少，才算够？

“够”很难对应一个技能数量。

更像三个状态。主战场里，有一块真的能打。周围系统接口，接得上。继续往外，知道地图和边界。

做到这些以后，依然会有无数自己不会的东西。

这很正常。

技术越往后学，人越容易产生一种幻觉：

再补一门语言。再刷一个框架。再看一套课程。

然后就会抵达那个传说中的状态：

“准备好了。”

这个状态大概不会来。因为知识供给已经发生了彻底变化。以前一本好书难找。新论文难找。专家难找。资料零散。互联网解决了一轮。开源解决了一轮。视频平台又解决了一轮。生成式 AI 再来一轮。

今天想知道一个概念，几乎随时能得到解释。

想入门一个框架，半小时就有 Demo。

凌晨三点卡在指针上，也有模型陪你继续问。

知识越来越像无限供应。人的一天依然只有二十四小时。注意力没有跟着模型版本升级。工作记忆没有。精力没有。人生更没有。于是学习里的稀缺性开始倒过来。

以前珍贵的是：

“我还能学到什么？”

今天越来越珍贵的，是：

“我决定把什么留到以后。”

AI 很重要。安全很重要。数学很重要。操作系统很重要。C++ 很重要。沟通重要。商业重要。健康更重要。全部都对。

“重要”并不能自动生成你的时间表。

以后再刷到一个新热词，可以先问一个很简单的问题：

它离我现在正在解决的问题有多远？

就在眼前。学。已经挡路了。狠狠干。在系统旁边。弄清楚它解决什么，知道怎么接。更远一些。留下坐标。别急。技术世界不会停。

GitHub Trending 明天还会刷新。

新的论文继续发。

新的框架继续告诉你：

“我是未来。”

Agent 还会升级。

AI 连判断都可能继续帮你接管。

你没有办法靠学得足够快，让整个世界慢下来。

真正能控制的，是自己把多少注意力交出去，以及在什么地方重新把控制权拿回来。

主战场，挖深。周围接口，接上。更远的地方，认得路。然后继续做东西。世界上值得学的技术永远学不完。这件事不需要解决。

真正需要解决的是：

下一铲子，往哪里挖。

有一天，现在很远的问题真的找上门。到时候再学。放心。那时候你学得通常比今天快。

因为摆在面前的已经不再是一门：

“以后可能有用的课。”

而是一个：

今天必须解决的问题。

而人在着火的时候，学习效率一般都挺高。

参考资料与来源

GitHub · Octoverse 2025
Dan McKinley · Choose Boring Technology
Barry Schwartz · The Paradox of Choice
Tero Parviainen · Overcoming JavaScript Framework Fatigue
Microsoft Research / CHI 2025 · The Impact of Generative AI on Critical Thinking
Stack Overflow · 2025 Developer Survey
《南方人物周刊》· “人机大战”十年：从焦虑AI，到焦虑跟不上AI
后浪研究所 · 1008个年轻人的AI生存实录
量子位 · “没有Token的CS学生，应立即退学”