一个还没发布的新模型,已经让 Anthropic 内部感受到了“断层式”的变化。

在最新的播客对话里,Claude Cowork 工程负责人 Felix Rieseberg 提到,他们内部正在用的一款新模型 Mythos Preview,带来的不是常规提升,而是一次明显的“断层式跃迁”。对工程师来说,这种差别很直观:同样是读代码、找漏洞、写实现,这一代模型的理解深度和解题方式,已经和上一代拉开了一截。

但变化不只在模型本身。随着执行成本被压到很低,Anthropic 内部已经可以同时跑上百个产品原型。以前一个想法要排期、评审、验证,现在有人提一句,十分钟就能做出一个能用的版本。在这种节奏下,Claude Code、Claude Cowork 这些产品,更像是从一堆原型里筛出来的结果,而不是按部就班“做出来”的项目。

更有意思的是,连他们自己也没完全预料到哪些东西会真正起作用。比如 skills——本质上只是一些写清楚“该怎么做事”的文本文件——却成了最有效的杠杆之一。

近日,Anthropic 的 Claude Cowork 工程负责人 Felix Rieseberg 在播客节目中,与主持人 Matt Turck 一起,讲清了这一切是怎么发生的。本文基于该播客视频整理,经 InfoQ 编辑。

  

核心观点如下:

  • 模型能力的增长速度,已经开始超过我们把它变成产品的能力。

  • 最终真正成功的产品,往往不是“加了什么”,而是“去掉了什么”。它更关乎一种感觉:用起来是什么体验。

  • 现在有一个全新的变化:执行成本几乎为零。如果你带着 10 个想法来找我,我现在的反应是:那我们就把 10 个全做出来试试,看看哪个更好。

  • 以前是你必须精通“计算机的语言”,而未来,你会更倾向于做一个精通“人类语言”的人,软件将真正地“为人而造”。

  • 现在的 AI 产品就像是移动电话刚出现的“傻瓜机时代”。运气好的话,我们现在做的可能只是“诺基亚 3310”,它是个好手机,但它还不是智能手机,更不是 iPhone。

阶跃式变迁的新模型

Matt:我们从刚刚公布的 Project Glasswing 和你在推特上提到的 Claude Mythos preview 聊起,你说这个模型在 Anthropic 内部带来了“很难被夸大的阶跃式变化”,这是什么意思?

Felix:Mythos 是一个还没发布的 frontier model,本质上是一个通用模型,并不是专门为 cyber security、coding 或软件开发某个单一场景训练的。但我们发现,它在 cyber security 这个方向上的能力“异常突出”,而且这种能力很可能会对软件和基础设施安全产生深远影响。

我的那条推文里其实想表达两点。首先,这个模型我们内部已经用了有一段时间了。作为软件工程师,过去几年大家大概都有类似的经历:第一次接触 AI 时,其实并没有那么惊艳。我第一次用 AI 还是 2013 年,那时候还没有大语言模型。我当时在 Microsoft,内部有个叫 project Oxford 的项目,本质上是一个 n-gram 模型。你给它一个 token,比如 “world”,它可能返回 “worldwide web”,那在当时已经算是语言模型的前沿能力了。

而这几年,大家逐渐会有那种“哦,这个模型比我想象中更强”的时刻。Mythos preview 对我们这些工程师来说,是一个明显的跃迁,相比过去几代模型,它的提升是那种“断层式”的。举个例子,这个模型在发现代码里的安全漏洞方面,表现得非常出色。它分析问题更深入,思路更聪明,写代码的能力也更强,让我们的工作效率大幅提升。但与此同时,看着一个明显比上一代模型“聪明很多”的系统,也会让人隐隐有点不安。

训练模型其实是一件很有意思的事。我们常说,模型更像是“长出来的(grown)”,而不是“被构建出来的(built)”。所以你事先并不完全知道它会特别擅长什么,也不一定知道它会在哪些地方表现一般,这两点都常常带来惊喜。而在这个案例里,它最突出的能力之一,就是发现现有软件里的安全问题,Project Glasswing 其实也是围绕这个能力展开的一个响应。

Matt:这会对 Cowork 产生什么影响吗?

Felix:我认为它很可能会显著改变我们在公司内部构建软件的方式。不过,对于一直关注 AI 发展的人来说,这种能力的持续提升,其实并不算意外。我们一直是在“往上爬”的过程,模型能力和可用性不断增强。

几年前,模型可能只是帮你做一些小任务;现在我们给它的任务规模在变大,时间跨度在变长,复杂度也在提升,这次只是又向这个方向迈进了一步。当然,这一步可能比我们内部预期的更大一些,对外界来说就更是如此。

但在 AI 研究者群体里,其实一直有个共识:这种“更大的跃迁”迟早会出现,而且跃迁本身也会越来越大。从这个角度看,我们其实是在按预期前进。但当你真的看到这些能力被“演示出来”时,还是会有点让人不寒而栗。

比如我们公开过一个例子:研究人员把模型放进一个沙盒,给它一个“尝试逃出去”的任务,然后研究员去吃午饭了。就在他吃三明治的时候,模型给他发了一封邮件,说:“我已经逃出来了。”而这个模型本来是不应该拥有互联网访问能力,也没有邮箱账户。

Matt:目前官方的说法是,这个模型至少在短期内会完全封闭,不对公众开放,未来可能只会提供给企业客户,对吗?

Felix:是的。Project Glasswing 的目标,是把这个模型优先提供给那些构建和维护我们数字基础设施的人和组织,比如 Linux Foundation。我们的想法是:这些人维护着我们每天使用电脑、手机时所依赖的底层系统,我们希望给他们一个“领先优势”,让他们先用这个模型去加固防御,在大众还无法使用类似能力之前,就提前发现并修复潜在的安全漏洞。

Matt:所以它并不属于 Sonnet 系列?不是 Sonnet 4.7 的延续?

Felix:对,目前它是一个独立分类下的 preview 模型。

Matt:听起来确实像是一个“断层式”的时刻。而你刚才提到“有点可怕”,也不仅仅是修辞。

Felix:是的。我觉得 Anthropic 一直以来的立场都很明确:AI 可以非常强大、非常有益,但同时也存在风险,必须严肃对待。而这一次,我们算是第一次真正在实践中看到这种情况。当你拥有一个很擅长攻破软件系统的模型时,你就必须认真思考:这意味着什么?我们该怎么使用它?如何负责任地处理它?

对我个人来说,这反而让我挺有成就感的,我很自豪公司在这件事上的处理方式非常克制、负责。而且,这并不是我们突然“偶然发现”一个强大模型,其实我们已经掌握它一段时间了。如果是一个更激进的公司,可能早就把它推向市场,定个高价,然后迅速变现。

Matt:在 Anthropic 这种公司内部,新模型发布时是怎么运作的?因为在行业里,每次有新模型出来,harness 制定者、应用团队都会迅速适配。你们内部也是这样吗?需要重新跑所有 eval?

Felix:某种程度上是的,但方式稍微不一样。我们在训练模型时,本来就会把产品需求考虑进去。产品会影响研究方向,研究反过来也会塑造产品,这是一个双向过程。

一方面,我们会尝试让模型具备那些真正能为人类创造价值的能力;另一方面,就像我刚才说的,我们也无法完全预知模型会擅长什么,所以这更像是一种“共舞”。我们通过产品去观察:用户真正受益的是什么;同时,如果模型突然展现出某种意料之外的能力,那可能就是我的工作去思考:我们如何把这个能力转化成一个用户真正能用的东西。

不过随着模型越来越强,我反而觉得“产品侧的滞后”比模型更明显。换句话说,模型能力的增长速度,已经开始超过我们把它变成产品的能力。

如果你看整个行业,不只是 AI 原生公司,而是整个软件行业、知识工作领域,甚至制造业、科研、医疗,你会发现,现在的模型已经非常强大了。它们可以处理长周期任务,也能处理非常复杂的问题。但我们还处在一个阶段:努力弄清楚如何“包装”这些能力,以最好的形式交付给用户。同时,整个行业也在摸索:在这样一个“模型驱动”的世界里,工作该如何重新组织,才能最大化利用这些能力。

我经常去见客户,很少有那种情况是我走出他们办公室时觉得:“我们需要把模型在某个能力上再训练得更强一点。”更常见的情况是:我会被他们组织工作的方式惊到,原来可以这样用模型;或者我很确信,他们的问题其实现在的模型就能解决,只是我们还没有提供合适的 UI、合适的能力封装、或者足够顺滑的 onboarding,让他们轻松用起来。

10 天做出 Claude Cowork

Matt:外界一直流传一个说法,说 Cowork 基本是在 10 天左右“写出来的”。真实情况是什么?那 10 天到底发生了什么?Cowork 真的是完全靠 Claude Code 搭出来的吗?

Felix:我能理解为什么这个说法会在软件圈传开,毕竟现实是没有任何软件是“从零开始”的。

当时大家引用的是我说过的一句话:“我的团队在最后大概 10 天时间里做了一次冲刺”,这句话本身是准确的。我们确实是在发布前 10 天左右聚在一起,我当时跟团队说:“我们差不多该发点东西了,那我们到底要发什么?长什么样?叫什么名字?能做什么?”

但任何做过软件的人都知道,你不会从 0 和 1 开始写起。你会用各种已有的 library,也会基于过去积累的 research。在 Anthropic 内部,关于我当时想解决的核心问题——“如何让 Claude Code 的能力更容易在非编程场景比如更广义的知识工作中使用”,其实已经有很多非常聪明的人思考了很久。

所以说 Anthropic 之前没有考虑过这个问题,是不准确的;但说我完全是“空降”这个问题、没有受益于之前的积累,也同样不对。

Matt:这个产品的起源是什么?你们一开始已经有 Claude Code,那是什么时候开始意识到需要做 Cowork?是用户使用方式带来的变化吗?

Felix:我真正形成这个判断,其实是在 2025 年 12 月。

我在社交媒体上开始看到越来越多“非开发者”在用 Claude Code,有人写新闻稿,有人做教程,教完全不会编程的人:“我教你怎么打开终端,怎么用 Claude Code,它会帮你做很多事情。”

确实有一小部分非开发者,用它来“直接做软件开发”,但那只是其中一种用法。我还注意到我们原本的开发者用户,那些每天用 Claude Code 写代码的人,始用它做一些完全不是软件开发的事情。这其实释放出一种非常强烈的“潜在需求”。

有个我很喜欢的判断标准:如果用户愿意“爬玻璃也要用你的产品”,哪怕这个产品还很不好用,那基本说明这是一个值得投入的方向。

真正的起点是,我的同事 Boris Cherny 跑来跟我说:“我觉得你应该做点东西,而且最好这周五之前上线。”我把 ddl 从周五谈判到了周一,给自己多争取了一个周末。然后我们拉了一个小团队,快速验证一个想法:如何让 Claude Code 在“非编程场景”下也变得非常高效。

从构成上来说,Cowork 其实很简单。我们做的事情是:给 Claude Code 加了一台“虚拟机”,让 Claude 可以在里面运行自己写的代码。

这台虚拟机带来了几个关键好处。第一,它提供了非常强的安全边界。作为用户,你不再需要时刻盯着它,因为它被关在一个沙盒里,和你的电脑、文件、网络都是隔离的,只能访问你明确授权的域名和文件。

第二,为了让 Claude Code 发挥最大效能,它其实是需要 developer tooling 的。Claude 很擅长解决各种任务,但它经常的做法是:写一些非常定制化的小程序来完成目标。给它一台“自己的电脑”之后,它就可以自己搭建开发环境,而不会影响你的系统。再加上一些 UI 层的优化,让使用更顺手、更优雅,简化那些原本更偏开发者的流程,最后我们得到的,就是一个可以很好支持知识工作的工具。

Matt:那在 Cowork 里面,“skills” 扮演什么角色?

Felix:skills 本质上就是一些 Markdown 文件,用来告诉模型“该怎么做事”。而让我一直觉得很神奇的是:这种方式居然这么有效。我对所有人的建议都是一样的:就把 Claude 当成你的 coworker(同事)。

一个 skill,说白了就是一个文本文件,里面写清楚某件事该怎么做。比如我最常举的例子是订机票。在 Anthropic,我们有指定的差旅供应商,所以你不能直接去 Google Flights,而是要用内部指定的系统,还要遵守各种规则。

这件事我怎么教同事,就可以怎么教模型。我只需要写一个文件:“这是订机票的流程,去这个网站,注意这些规则……”然后再加一点个人偏好,比如:不要红眼航班;如果要从旧金山飞纽约,尽量订下午 4 点的航班。把这些写进去之后,模型就能非常好地理解并执行。

Matt:那整个系统的“intelligence layer(智能层)”还是在模型本身,对吧?比如 Cowork 如何把一个任务拆解成多个子任务,这些都是模型在做?

Felix:是的,不过是“模型 + 人”的协作。我们比较满意的一点,是任务列表的设计方式。模型会被引导去把一个项目拆解成多个任务,而你可以随时介入:编辑任务列表、点开某个子任务、补充更多上下文。所以智能确实在模型里,但 skills 给它加了一层非常关键的实用性。

这里有个挺有意思的变化。我们过去习惯用“标准化”的技术产品,大家用一样的手机、一样的电脑。但模型不一样,模型其实非常依赖一点点指导。就像一个很聪明的人入职新公司,通常也需要 onboarding,需要有人告诉他:这里事情是怎么做的。

再举个更贴近的例子,比如做 presentation 或写文档。如果你有 PowerPoint 或 Google Slides 的模板,你就应该告诉 Claude;如果你对字体有偏好,比如喜欢 serif font 或不喜欢某种风格,也都可以写进去。只要你把这些偏好用简单的指令写下来,模型在实际帮你做事时的表现会好很多,你也不需要反复修改、盯着它“带娃式”纠正。

Matt:那 Cowork 的记忆是怎么实现的?它是存在模型里,还是在外层的 harness 里?

Felix:在 harness 这一层。所谓“记忆”,本质上就是文本文件。就是模型被明确指示:如果你觉得有一些信息未来可能还会用到,那就把它写下来。我们会在这个基础上帮模型做一点点组织,比如你可以设置项目级别的独立记忆,也可以有全局记忆。但整体来说,这套叠加在模型之上的机制,并不是什么复杂炫技的数据库系统,它其实非常朴素。

Matt:那 Cowork 是怎么接入各种信息源或应用的?是通过 connectors?MCP(Model Context Protocol)?还是多种方式组合?

Felix:是组合使用的。

我一直有个很强的判断:你工作所需的数据,基本分布在两个地方。第一类是在你本地电脑上。作为做产品的人,我们必须认真对待这一点:用户是在用电脑,而不是只用 iPad。并不是所有东西都在云端,文件夹依然很重要。这是一类上下文来源。你可以直接拖文件进来,或者给 Claude 访问某个文件夹、甚至多个文件夹的权限。

第二类,是云端或互联网里的数据,比如 data warehouse、analytics 系统、SharePoint 等等。针对这些,我们提供多种接入方式,其中 MCP connectors 是一个很强大的方式。

另外,因为 Claude 本身“有一台电脑”,如果你允许,它也可以直接访问互联网。当然你可以精细控制:哪些网站能访问,哪些不能。但总体来说,只要资源在外部存在,而且你授权了,Claude 基本都能找到办法去使用它。

本地、云端和信任

Matt:为什么 Cowork 要运行在本地电脑上,而不是完全在云端?

Felix:Cowork 现在提供的两个最大价值,其实就是:访问你的本地电脑,以及访问你的本地文件。那问题是,这些不能在云端实现吗?比如说一个很典型的例子是 Chrome。如果你授权,Claude 可以用你的 Chrome,可以帮你回邮件、总结邮件,或者操作你公司内部的工具。

很多人会问:那为什么不直接在云端做?

第一是 session。Claude 如果能直接使用你已经登录过的账号,价值是完全不一样的。比如 Gmail,本身没什么用,但“带着你登录态的 Gmail”,对 agent 来说就非常有价值。第二点更多是工程实现层面。理论上,我们确实可以把你的本地 Chrome 打包、上传到云端,甚至让你输入密码,在云端复刻整个环境。

但我反对这种做法,主要有两个原因。第一是安全性。我不认为我们应该教育用户,把所有密码都交给某一家公司,这不是一个好的方向。第二是现实世界的限制。比如银行,如果它检测到你同时在两个地方登录,一个是你的电脑,一个是数据中心,它很可能会直接锁定你的账户,然后要求你带着护照去线下网点验证。这类长尾问题非常多,而且用户体验很差。

对我来说,这种风险是不可接受的。所以在现阶段,我更希望 Claude 能“在你工作的地方工作”。你在本地电脑上,它就应该在那里。

Matt:那 Computer Use 的出现,会改变这个判断吗?你们最近收购了 Vercept,也推出了相关能力。假设从云端就能看到整台电脑的内容,那为什么还需要本地?

Felix:如果我给你一个“神奇按钮”,按下去之后,我就把你整台电脑的数据都吸到云端,你会按吗?目前我的观察是,大多数人不会。也许大家会信任 Anthropic,但要把“全部数据”交出去,还是一件非常重的决策。

从技术上讲,其实确实没有什么“必须在本地运行”的硬性限制。我们完全可以把整套系统都搬到云端,甚至远程操作你的电脑。但至少在当前阶段,让 Claude 在你工作的地方运行,不仅更符合用户习惯,也让我们可以更快迭代,同时在安全性上做得更严格。

AI 发展很快,这个判断未来可能会变。但就现在来说,我对“本地优先”这件事还是挺有信心的。

Matt:你刚才提到了“信任”,这是生成式 AI 里一个很核心的话题。一方面是你不会乱访问文件,另一方面是我把越来越重要的工作交给你,你能不能做好、不会让我出丑。作为产品负责人,你是怎么建立这种信任的?

Felix:我觉得在 2026 年做 AI 产品,有一个很有意思的变化:你做的大多数按钮,其实是“给人用的”,而不是“给机器用的”。过去我们设计界面,是为了让计算机更好地工作,人只是输入信息的角色;但现在反过来了,我们是在帮助人理解、控制、信任这个系统。

举个例子,我们最近上线了一个叫 dispatch 的功能,可以让你用手机和电脑上的 Claude 对话。我们当时有意识地“少放按钮”。但上线之后,我每天在社交媒体上能收到大概 50 条反馈,说:“能不能加一个按钮,让 dispatch 直接访问我的本地文件?”

为什么纠结这个?因为现在的逻辑是:Claude 本来就能访问你的文件,但它会先问你:“我可以访问你的 downloads 文件夹吗?”你授权之后它才会去做。

所以问题变成:我们要不要加一个按钮,让用户“显式知道”这个能力存在?这就回到你问的信任问题。我们的思路,其实不是让 Claude 去“证明自己”,而是一步步带着用户成长,让他们逐渐理解系统的能力。

比如 Cowork 刚上线时,其实已经能做很多很复杂的事情,比如写 200 页的 VC 报告、做蛋白质建模、设计复杂架构图等等。但真正打动用户的,是一句简单的:“帮我整理桌面。”这是一个对 AI 来说很简单、甚至有点“没必要”的任务,但它是一个很好的起点。

另一个例子是“定时任务”。从技术角度讲,这也不新鲜,延迟执行函数早就有了。但这里的关键是:我们在教用户一件事:你可以不盯着它。你可以让 Claude 每天帮你总结会议、写报告,然后它完成后发邮件给你,你不需要坐在电脑前盯着它执行。这个过程其实是在逐步建立信任:先从小任务开始,用户看到结果可靠,然后自然会把更重要的事情交给它。

所以信任的本质,是 Claude 承诺一个结果,最终交付的结果是好的,而且你不需要“带娃式”监督或频繁介入,信任就是这样一点点积累起来的。

AI Agent 时代怎么做产品?

Matt:在 AI agent 的成功里,UX 和底层技术一样重要吗?比如说,如何把用户一步步带入,让他们真正用起来、用得好。你在做 AI agent 的过程中,有哪些 UX 层面的经验?

Felix:UX 非常重要。Claude Code 的起点其实就是一个 UX 的变化:同样是 Claude,但不再只是“在云端对话”,而是运行在你本地电脑的终端里。这背后几乎完全是体验层的改变,模型本身没有变,核心能力也没有变。很多价值,其实就是从“你怎么和模型交互”里产生的。

那些真正被用户喜欢的 AI 产品,很少是“原始能力最强”的那一类。这不仅仅适用于 AI,而是整个软件行业的普遍规律。比如说邮箱,市面上肯定有不少产品,功能比 Gmail 更多、更复杂,很多公司总是试图靠“加功能”“多按钮”来领先。

这让我想到智能手机之前的那段时间,出现的各种奇怪手机:带投影仪的、带游戏手柄的、有全键盘的、没键盘的……大家不断往上“堆功能”。但最终真正成功的产品,往往不是“加了什么”,而是“去掉了什么”。它更关乎一种感觉:用起来是什么体验。说实话,我不太相信大多数人是看参数表来买手机的,人们做决定的原因往往不是芯片性能这些指标。

AI 其实很类似。当然,更强的模型确实会带来优势。我在 Anthropic 工作,可以直接和研究团队合作,拥有很强的模型,这是一个客观优势。但如果有一天有人在产品上打败我,我很怀疑那是因为他们做出了“更强的模型”。更可能的原因是:他们做出了更好的用户体验。

Matt:在实践层面,你们是怎么优化用户体验的?你们会不会非常精细地追踪用户行为?比如什么好用、什么不好用,然后重点投入?

Felix:我们的方法其实并不算特别独特。有一件事对我来说比较新:对用户的极致关注。去和真实的人交流,优先做快速迭代,而不是长期规划。我们基本不会规划超过一个月的 roadmap,Cowork 的整个产品路线图,最长也就是一个月。我们更关注的是:下周做什么?下下周做什么?至于一年后的产品长什么样,说实话,我们没什么信心。任何人如果告诉我,他知道 AI 一年后会是什么样,我也不会太信服。

我过去做过的所有成功产品,之所以变好,都是因为我有很多次“纠偏”的机会,可以犯点小错、比较不同方案、不断调整方向。但现在有一个全新的变化:执行成本几乎为零。如果你带着 10 个想法来找我,我现在的反应是:那我们就把 10 个全做出来试试,看看哪个更好。

我们尽量在内部测试这些东西,而不是把用户当成免费的 beta tester。但大多数时候,你其实很快就能判断一个方向对不对。现在公司规模也不小了,很容易验证:这个东西是不是至少能打动 5 个人。真正“新”的,是这种执行速度。哪怕是两年前,如果你想快速迭代,也必须非常克制,因为资源有限,一次只能做少数几件事。但现在,执行变得极其便宜,你可以同时“做深”和“做广”。

Matt:你们真的会同时做 10 个版本甚至 10 个产品,然后让内部的人测试,最后再决定走哪个方向?

Felix:实际上不止 10 个,我们现在公司内部,可能有 100 个不同的原型在跑。当然,这些原型大多数还没达到可以给用户看的程度。但能在内部快速做出来的数量,远远超过我过去任何时候的经验。

以前最大的限制是执行成本。比如你有一个好点子,来找我,我可能会说:“我们下个月排期,这个要做三周,在那之前你先去找用户验证一下。”但现在,你可以走过来说:“我有个想法。”我会说:“给我 10 分钟,我给你一个版本。”这种变化,有点像从“绘画”进入“摄影时代”。

Matt:当你有 100 个原型之后,真正的瓶颈是什么?总要有人做选择,这一步是不是会变慢?

Felix:是的,我觉得“alignment(对齐)”依然很难,而且一直都很难。公司里有不同的人、不同的想法,你选谁?怎么选?怎么把不同方案里的优点组合起来?这些问题依然存在,而且这部分仍然高度依赖人。换句话说,这正是“人类判断”和“taste(品味)”发挥作用的地方。

Matt:品味是不是正在成为一种更核心的能力?

Felix:是的,品味的重要性在上升。

Matt:但这又和刚才说的数据驱动有点冲突?一方面你会测试、看数据,但另一方面又有一些更难量化的判断。

Felix:对。数据驱动的价值在于:帮你验证你的“品味”是否真的被用户认可,帮你判断方向是不是对的。即使是那些我们认为“品味很好”的人,比如早期做出 iPhone 的团队,他们也非常强调持续迭代和测试。Ken Kocienda 在《Creative Selection》这本书里写得很好:你需要品味,但你也必须不断验证。我觉得这两者是同时存在的。

而从更大的视角来看,我甚至在想:软件会不会越来越像时尚行业?现在手机其实已经有点这个趋势了。会有一个“基础性能”和“基础能力”的下限,但真正决定差异的,可能是:你讲了什么样的故事、你的 onboarding 做得怎么样、用户在使用时的感受如何。这些因素,很可能会比“模型本身有多强”更重要。

Matt:在 Cowork 的业务背景下,这种“品味”是如何运作的?你需要服务极其广泛的专业群体,有做营收运营的,有做市场营销的,甚至还有律师和会计。当受众如此宽泛时,“品味”意味着什么?你又是如何去测试它的?

 

Felix:我反复提到“手机”的类比。我们所有人拿到手的可能都是同款手机,但世界上没有两部手机是完全一样的。你安装的 App 组合让你的手机像指纹一样独一无二。我们从同样的设备出发,但它融入我们生活的方式却各不相同,非常个性化。

 

对于 Cowork 来说,我们的思路很像:我们希望打造一种通用性极强的东西,可以应用在生活的方方面面。拿我自己的生活来说,我最近正在搬家,涉及 500 多页写满复杂术语的合同,很多词我根本看不懂,这时候 Cowork 就非常有用了。同时,它在医疗场景下也帮了我大忙,我女儿今年刚出生,处理那些堆积如山的医疗账单和表格时,它也发挥了巨大作用。

 

一边是房贷申请、和搬家公司谈判、处理财务申请,另一边则是纯粹的医疗文书。从理论上讲,这是同一种底层技术的两个完全不同的应用。但我发现,我脑子里思考的那些 primitives(基本原语)其实是一样的。有些原语打磨得更好,手感更顺滑。

 

我认为,作为一个产品缔造者,如果你密切关注并深度使用自己的产品,你能感觉到那种“撞在软件墙上”的生涩感。那种感觉很不爽,它没有让你起飞,而我想要创造更多能让人“飞起来”的时刻。即使客户所在的行业我完全不懂,我也可以从他们的故事中听出:哪些功能让他们如虎添翼,哪些环节让他们觉得被拖累。如果你能敏锐地捕捉并激进地去优化这些点,让用户进入那种“flow(心流)”状态,感觉讨厌的繁琐工作被自动接管了,那这里面就蕴含着巨大的价值。

 

Matt:打造 Claude Cowork 最难的部分是什么?

 

Felix:我在想,如果重新来一遍,换个产品,什么是最难被“复刻”的?我觉得是那种“时机感”。我之前提到过,Cowork 的诞生是因为我们一直紧贴地面,敏锐察觉到了潜在需求。这种潜在需求是上天的馈赠,你很难凭空创造它。

 

软件行业其实一直存在大量的潜在需求,只要你有心去找,总能发现。所以,如果说构建 Cowork 的核心难点,我倒不觉得有什么技术细节特别难。做出一款好产品该有的难点它都有,比如所谓的“成长的烦恼”:如果你开了一家咖啡馆,原本准备接待 10 个人,结果来了 2000 万人,你该怎么办?这对我们来说有时确实挺难的。Anthropic 的产品需求量实在太惊人了,当然,作为产品负责人,我也没资格抱怨大家太爱用我的产品。

 

Matt:如果有人正在构建某种 AI Agent,关于开发流程、构建 Harness、专业化定制、或者是加装 Guardrails 和行业深耕,有什么经验可以分享吗?

 

Felix:我首先会建议不要自己去造太多的底层轮子,可以试试我们刚推出的 Claude Managed Agents,它在很多场景下非常管用。

 

关于构建自定义 Agent,有正反两个维度的思考。反对过度定制的理由是:随着模型能力越来越强,我发现我们在产品开发中需要考虑的 Edge Cases(边界案例)反而变少了。我之前说过,记忆其实就是一个文本文件,如果 Claude 需要数据库,它自己就能造一个。所以,如果你想做一个超垂直、超专业化的产品,逻辑前提可能是模型还没强到能随时随地“现造”这些功能。如果模型以后能即时搞定一切,那你的专业化门槛可能就不存在了。

 

但是,支持投入这个领域的理由也很充分:整个行业要真正发挥出这种力量,还有很长的路要走。大家总喜欢用各种闪亮的类比来定义 AI,说它是像互联网、蒸汽机那样的发明。我觉得互联网带给我们的教训是:一项技术真正转化并重塑经济逻辑,需要几十年的时间。从第一个浏览器问世,到 Amazon 成为零售巨头,中间隔了太久。

 

所以,我的观点是:你应该深入进去,寻找那些独特且新颖的应用场景。不过,你提供的价值可能并不在于 Agent 本身,也不在于模型的智商,而在于你如何帮助人们组织工作。如何让它变得真正“好用”,这才是关键。

SaaS 的末日?

Matt:几周前,你们发布了一个看似寻常的公告,结果市场反应剧烈,媒体甚至称之为“SaaS-Pocalypse(SaaS 启示录)”。当时你们只是增加了 10 到 11 个关于法律和 CRM 之类的文件支持。显然,无论市场情绪如何波动,这都反映出你们所构建的 Cowork 以及 Anthropic 整体所具备的影响力。

 

你们做了 Claude Code,解决了开发者的痛点;做了 Cowork,服务了所有人;现在又推出了 Managed Agents。当你们不断往技术栈的上层走,软件行业还有什么空间留给后来者吗?

 

Felix:我经历过好几轮这种“民主化”浪潮,也就是构建事物的门槛越来越低,不再需要那些晦涩的专业知识。

 

举个例子:多年前我在 Microsoft 工作,参与了一个叫 Electron 的项目,这是一种让应用能在 Windows 和 macOS 上跨平台运行的技术。我们当时第一个应用案例就是 Visual Studio Code,这是一款后来在开发者中变得非常流行的代码编辑器,像 Cursor 这样的产品也是在它之上构建的。当年 VS Code 在公司内部刚推出时,很多人觉得这就是个“玩具”,觉得真正的开发者需要的是 Visual Studio 这种功能复杂、工具高级的大家伙。

 

但结果呢?你不再需要钻研得那么深了。对于做软件的听众来说,我这周感触很深:今年我查看 Assembly(汇编语言)的次数是零。而在过去五年里,这个数字从来不是零。

 

最近作家 Margaret Atwood 写了一篇非常精彩的文章,讲她如何使用 Claude。我在想,如果让 Margaret Atwood 来写软件,那个软件会是什么样?我肯定非常有兴趣装一个来试试。

 

所以我的预测是:未来我们将拥有更多的软件,而且会更加专业化。并不是说每个人都会亲手写软件,人们依然会创造并分享,大家也依然喜欢好用的工具,只是所需的技能点变了。以前是你必须精通“计算机的语言”,而未来,你会更倾向于做一个精通“人类语言”的人,软件将真正地“为人而造”。

 

Matt:这是否意味着一切最终都会归结为 UX 的问题?

 

Felix:20 年前成功的软件开发者是“计算机专家”,而未来的成功者将是那些深度理解人类和用户需求的人。这一直是一个渐进的过程,10 年前写软件就比 30 年前容易得多,AI 则是另一个阶跃式的变化。

 

至于市场表现,我不是经济学家,我是个软件工程师。我从来没搞懂过市场是怎么运作的,我也建议其他工程师不要把自己的行动指南完全建立在市场波动上。

 

我觉得还有堆积如山的事情等着我们去自动化,还有无数的工作可以变得更轻松。只要人类还有问题和麻烦,软件就会是一个合理的答案。

 

Matt:跳出具体的产品细节,你认为两三年后 Agent 的能力未来会走向何方?

 

Felix:这对我来说挺难回答的,因为我原则上不喜欢在功能还没真正做出来之前就开空头支票。我的营销哲学一直都是:先做出酷炫的东西,再展示给人看。

 

大家似乎总是很快就忘记了 AI 已经走了多远,反而开始预期所谓的“Plateau(平台期)”会很快到来。我想这可能是科技史给人的刻板印象,就像 iPhone 刚出来那几年,每年的更新都是巨变,但最近几年更新幅度就变小了。

 

但作为一个 AI 观察者,我没有任何理由认为 AI 会在短期内进入平台期。我想提醒大家,AI 学会说出像样的人话其实也就这几年的事,而现在它已经能构建完整的应用、解决复杂的问题了。对我来说,这远非巅峰,我们还在半山腰呢。这段旅程正在加速,步子会迈得越来越大。Claude Mythos Preview 其实就是一个很好的证明:模型会越来越聪明,而且目前完全看不到上限。

 

Matt:你们是否会让受规管行业更轻松地接入 Cowork?作为一家风险投资机构,我们目前在工作场景下还用不了 Cowork,但我私下里一直在用。这在你们的计划中吗?

 

Felix:你绝不是唯一一个在为特定受规管行业申请 Cowork 的人。作为产品人,用户的需求就是我们的风向标,我们会非常认真地倾听。

 

到了 2026 年,最让我激动的依然是:如何帮助人们重新组织工作,从而最大限度地发挥 AI 的能力。我曾在 Slack 工作过五年,那时候我们觉得自己在帮公司变革办公方式。虽然我们不是第一个做聊天工具的,也不是第一个提出“打破信息孤岛”的人。但我们卖给用户的不仅是一个聊天 App,而是一种更透明、更开放的办公文化。对于 AI 来说,这种变革是相似的:只有当你重新审视自己的工作流程,思考哪些部分可以交给模型,哪些部分需要完全掌控时,工具才最有效。

 

另一个让我兴奋的领域是:目前使用 AI 的人分为两类。一类是我们所说的“AGI Pilled(深受 AGI 浸染的人)”,他们全身心投入,研究怎么设置 Claude、开放什么工具权限、安装什么 MCP connectors。他们用得飞起,效率极高。而另一类人可能没那么多时间或兴趣去钻研。如何缩短这两类人之间的距离,让普通用户也能秒变 Power User,这其中的潜力巨大。在实践中,Cowork 的用户会发现我们几乎每周都会发布意义重大的更新,这件事目前看不到终点。

快问快答

Matt:哪一个想法被严重低估了?

 

Felix:MCP connectors。包括我在内,大家现在都在关注 CLI(命令行界面),但将数据与“执行引擎”分离,这件事本身有着巨大的内在价值,是一个非常技术硬核的观点。去年秋天 MCP 爆火过一阵,现在讨论变少了,但我认为到今年年底或明年,它会变得极其有用。就像 WebSocket 对 Amazon 或 TikTok 的用户来说是不可或缺的底层协议一样,用户不需要关心它,但工程师们目前对 MCP 的重视程度还远远不够。

 

Matt:哪一个想法被过度神化了?

 

Felix:我认为:并不是每个产品都需要一个 Chat(聊天框)。在 2026 年的 AI 圈,这听起来可能有点叛逆。很多同行都有一种膝跳反应,一说要把 AI 引入产品,就立刻在右边加个侧边栏,底下放个聊天框。我鼓励 AI 开发者们多想一层:如何让 AI 以更自然、更有用的方式存在,而不仅仅是对话。

 

Matt:如果你今天白手起家,你会做什么?

 

Felix:我可能会去关注这个行业的“长尾部分”。比如,世界上还有大量运行着 Windows 7 的旧设备,它们处理着琐碎的任务,却在社会中扮演着承重墙的角色。想想挺吓人的,这些处于现代 AI 触角之外的电脑,却在支撑着重要的社会功能。

 

另一个方向是,如果你相信 AI 的本质是计算机不再只是执行预设的功能,而是能非确定性地做出决策并代你执行,那我建议去攻占物理世界,这也是我对年轻人的建议。我们真的还处于非常早期的阶段,现在的 AI 产品处于就像是移动电话刚出现的“傻瓜机时代”。运气好的话,我们现在做的可能只是“诺基亚 3310”,它是个好手机,但它还不是智能手机,更不是 iPhone。真正属于 AI 的“iPhone 时刻”,正等着某个人去创造。

访谈视频原链接:

https://www.youtube.com/watch?v=9MEJ4syOVrQ&t=2s

华为举办 Pura 系列及全场景新品发布会

4 月 20 日,华为 Pura 系列及全场景新品发布会在广州举行,发布 HUAWEI Pura 90 系列等多款新品。

HUAWEI Pura 90 系列包括 Pura 90、Pura 90 Pro、Pura 90 Pro Max 三款,全系支持 IP68 与 IP69 防尘抗水。HUAWEI Pura 90 Pro Max 有橘子海、霞光紫、翡翠湖、晨曦金、曜石黑五款配色,屏幕 6.9 英寸,采用抗反光耐刮昆仑玻璃。机器采用麒麟 9030S 处理器,电池容量 6000 mAh,支持 100 W 超级快充与 80 W 华为无线超级快充。后置摄像头为 5000 万像素主摄(F1.4-F4.0,OIS 光学防抖)、4000 万像素超广角摄像头(F2.2)、1/1.28 英寸 2 亿像素长焦摄像头(F2.6,OIS 光学防抖,长焦微距)与第二代红枫原色摄像头。定价 6499 元(12GB+256GB)至 8499 元(16GB+1TB)。

HUAWEI Pura 90 Pro 有粉红芭乐、橘子汽水、椰青白、桑果黑四款配色,屏幕 6.6 英寸,采用第二代昆仑玻璃。机器采用麒麟 9030S 处理器,电池容量 6000 mAh,支持 66 W 超级快充与 50 W 华为无线超级快充。后置摄像头为 5000 万像素主摄(F1.4-F4.0,OIS 光学防抖)、1250 万像素超广角摄像头(F2.2)、5000 万像素长焦摄像头(F2.1 ,OIS 光学防抖)与第二代红枫原色摄像头。定价 5499 元(12GB+256GB)至 7499 元(16GB+1TB)。

HUAWEI Pura 90 有罗兰紫、丝绒黑、雪域白三款配色,屏幕 6.8 英寸,采用昆仑玻璃。机器采用麒麟 9010S 处理器,电池容量 6500 mAh,支持 100 W 超级快充与 50 W 华为无线超级快充。后置摄像头为 5000 万像素主摄(F1.8,OIS 光学防抖)、1250 万像素超广角摄像头(F2.2)、5000 万像素超聚光潜望长焦摄像头(F2.2 光圈,OIS 光学防抖)与红枫原色摄像头。前置摄像头为 5000 万像素超聚光人像摄像头(F2.0)与红枫原色摄像头。定价 4699 元(12GB+256GB)至 5699 元(16GB+512GB)。

HUAWEI Pura X Max 为华为首款大阔折手机。Pura X Max 外屏 5.4 英寸,内屏 7.7 英寸,电池容量 5300 mAh,外屏采用第二代昆仑玻璃,搭载麒麟 9030 Pro 处理器。机身支持 IP58、IP59 防尘抗水,后置摄像头采用 5000 万像素主摄(F1.4-F4.0,RYYB,OIS 光学防抖)、1250 万像素超广角摄像头(F2.2,RYYB)、5000 万像素长焦微距摄像头(F2.2,RYYB,OIS 光学防抖)与第二代红枫原色摄像头。Pura X Max 有幻夜黑、零度白、星际蓝、橄榄金、活力橙五色可选,售价 10999 元(12GB+256GB)至 13999 元(16GB+1TB 典藏版)。另有 HUAWEI M-Pen 3 Mini 可配合使用。

同时,HUAWEI Pura X 追加型格紫、型格橙两款新配色,仅 16GB+512GB 配置,售价 7999 元。

可穿戴设备方面,华为 AI 眼镜正式发布,整机重量 35.5 g,镜腿薄至 6.25 毫米,支持 HDR Vivid 标准;搭载 1200 万超感光摄像头,配备 1/2.8 英寸传感器与高透光 6P 光学镜片,搭载超澎湃水滴单元,采用三麦克风通话降噪系统,搭配算法可实现 80dB 双向清晰通话。华为 AI 眼镜配合搭载 HarmonyOS 6.0 及以上版本系统的 Mate、Pura、nova 系列手机使用。眼镜综合续航 12 小时,连续语音通话 8 小时,连续音乐播放 9 小时。钛丝半框光学镜与经典全框光学镜售价 2499 元,经典全框太阳镜售价 2899 元。

HUAWEI WATCH ULTIMATE DESIGN 非凡大师星钻绽放款发布,重量 91g,带有 99 颗天然钻石。售价 29999 元。

HUAWEI WATCH FIT 5 系列有 FIT 5 Pro 与 FIT 5 两款机型。FIT 5 Pro 有丹霞橙、冰川白、雅丹黑三色可选,采用 1.92 英寸 AMOLED 屏,峰值亮度达 3000 尼特,表镜为 2.5D 蓝宝石玻璃,机身采用钛合金与铝合金材质。支持 IP6X 级别防尘抗水,潜水最大深度 40 米。系列首发腕上微运动功能。FIT 5 有光织银、风信紫、向新绿、悦动白、韵律黑五色可选,屏幕为 1.82 英寸 AMOLED,峰值亮度 2500 尼特,采用铝合金材质,支持 IP6X 级别防尘抗水。FIT 5 Pro 售价 2099 元起,FIT 5 售价 1099 元起。

HUAWEI WATCH Buds 2 采用手表耳机二合一设计。表体采用钛合金,屏幕为 1.5 英寸超窄边柔性屏,峰值亮度 3000 尼特。耳机左右耳自动识别,单只净重 4 g,支持广域耳廓触控。整机综合续航约 3 天。有琥珀棕、曜石黑、钛空银三色可选,售价 3488 元起。

HUAWEI MateBook 14 鸿蒙版采用圆形键盘设计,搭载 2.8K OLED 云晰柔光屏(可选),支持 P3 广色域。机器采用麒麟 X90 芯片,40W TDP 散热设计,支持 Wi-Fi 7,整机重量 1.33 kg,接口包括一个 USB-C、两个 USB 3.2 Gen 1 Type-A 接口、一个 HDMI 与一个 3.5mm 耳机孔。有原野绿、樱粉金、深空灰三色可选,售价 6599 元(24GB+512GB)起。

华为智慧屏 S7 Pro 采用 Super MiniLED 黑晶屏,机身 49mm 薄,支持 288 Hz 高刷,搭载三分频 2.1 声道音响。售价 7999 元(65 英寸)起。此外还有 HUAWEI Sound X5 音响,定价 2199 元。


徕卡与长光辰芯联合开发下一代 CMOS

4 月 20 日,徕卡与高性能 CMOS 图像传感器供应商长光辰芯(Gpixel)宣布展开新一阶段的战略合作。双方将为下一代徕卡相机定制一款 CMOS 图像传感器芯片,提升徕卡相机图像质量、动态范围、色彩还原及弱光性能等。双方还将在芯片验证、图像调校及量产准备等方面密切协作。来源


微软 AI 数据中心 Fairwater 投入使用

4 月 16 日,微软 CEO Satya Nadella 发布推文,确认在威斯康星州建设的 Fairwater AI 数据中心已提前投入使用。该中心于 2025 年 9 月官宣,将配备超十万张 NVIDIA Blackwell GB200 GPU,设施采用闭路液冷设计,集群内光纤基础设施可绕地球 4.5 圈。微软称 Fairwater 将采用可再生能源满足电力需求。微软已在波蒂奇县投资新建一座 250MW 的太阳能电厂。来源


Apple 宣布一系列人事变动

当地时间 4 月 20 日,Apple 发布新闻稿,宣布自 2026 年 9 月 1 日起,任 Apple 首席执行官 15 年的 Tim Cook 将任董事会执行主席,参与公司政府公关等事务;现任硬件工程高级副总裁 John Ternus 将出任 Apple 首席执行官;任 Apple 非执行董事长 15 年的 Arthur Levinson 将成为首席独立董事,John Ternus 将加入董事会。Tim Cook 在任 CEO 期间,Apple 市值从约 3500 亿美元增长到 4 万亿美元,增幅超过 1000%,年收入几乎翻两番,从 2011 财年的 1080 亿美元增长到 2025 财年的超过 4160 亿美元。John Ternus 自 2013 年起任硬件工程高级副总裁,在 iPad 与 AirPods 等新品类,与 iPhone、Mac 与 Apple Watch 的多代产品推出中起重要作用。来源

同时,Apple 硬件技术高级副总裁 Johny Srouji 即日起任 Apple 首席硬件官。来源


月之暗面发布并开源 Kimi K2.6 模型

4 月 20 日,月之暗面发布并开源 Kimi K2.6 模型,模型已已上线网页版、最新版 Kimi 应用、Kimi API 和 Kimi Code 编程助手。Kimi K2.6 的通用 Agent、代码、视觉理解等综合能力得到全面提升,其中在博士级难度的完整版人类最后的考试(Humanity's Last Exam)、在考察模型真实软件工程能力的 SWE-Bench Pro、评估 Agent 深度检索能力的 DeepSearchQA 等基准测试中均取得行业领先的成绩,持平或优于 GPT-5.4、Claude Opus 4.6 和 Gemini 3.1 Pro 等闭源模型。其长程编码能力也得到显著提升,并大幅增强了 Agent 自主化执行能力。来源


第十一届中国高校计算机大赛-移动应用创新赛报名启动

4 月 20 日,由 Apple 与浙江大学联合承办的第十一届「中国高校计算机大赛-移动应用创新赛」报名启动。大赛开设「启明」「启迪」「启航」三大赛道,鼓励中小学、高职、大学及毕业五年内的年轻开发者,以及对编程感兴趣的非专业背景参赛选手。启明与启迪赛初赛作品提交截止日期为 2026 年 6 月 30 日晚 23:59,启航赛道初赛作品提交截止日期为 2026 年 7 月 31 日晚 23:59。同时,去年 Apple 捐款 3000 万用于支持在华编程教育,基于此资金设立的 Apple 移动孵化器正式面向社会招募首批独立开发者、天使轮及之前的早期创业团队入驻,入围者将获得包括技术培训、商业辅导等在内的多方面支持。来源

关联阅读:十年移动应用创新赛落幕,Apple 移动应用孵化基金「启航」


Adobe 发布面向企业的客户体验设计工具

4 月 20 日,Adobe 发布 Adobe CX Enterprise。这是一款面向企业的客户体验编排(Customer Experience Orchestration, CXO)解决方案,由内容供应链、客户参与及品牌知名度三大核心维度构建,旨在以智能体系统的形式,让组织将 AI 融入商业流程,帮助品牌从以往渠道为中心的营销模式转向全流程用户体验编排。Adobe CX Enterprise 系统支持混合界面(Hybrid Experiences)交互,兼顾传统与对话式接口;具备目标驱动的决策优化能力,可针对收入与客户生命周期价值进行持续优化;提供可扩展的智能体互操作性,允许接入 Adobe 及第三方生成式 AI 模型。该工具现已上线 Adobe Experience Cloud。来源


不妨一看的简讯

  • Google 开发中的无屏幕运动手环目前已由 NBA 球星斯蒂芬·库里公开佩戴,手环略薄于其主要竞争对手 WHOOP MG。9to5Google 称该手环可能定名为 Google Fitbit Air,配合的订阅服务可能从 Fitbit Premium 更名为 Google Health。来源
  • 4 月 20 日,爱奇艺于 2026 年世界大会宣布 117 位艺人签约其「纳逗 Pro 艺人库」,称其肖像、声音数据将用于 AI 影视制作。CEO 龚宇在会上提出「真人实拍或成非遗」言论。随后,多位艺人或艺人工作室发出声明否认签约。爱奇艺于当日下午发布微博称进入 AI 艺人库仅「代表艺人有接洽 AI 影视项目的意愿」。来源


少数派的近期动态

你可能错过的文章

> 下载 少数派 2.0 客户端、关注 少数派公众号,解锁全新阅读体验 📰

> 实用、好用的 正版软件,少数派为你呈现 🚀

    已经很久没看 wwe 比赛了,昨天看到大布被新人 4 分多钟就 ko 的新闻,不管是否是剧情需要,依旧是感慨岁月催人老,强如猛兽也依旧抵不过时间的洗礼,输了比赛后,跟经纪人,观众做了最后的道别(提一嘴,我之前最最最最讨厌的人就是保罗海曼),以前耳熟能祥的巨星现在都退役了,新人也都不认识,看的没啥意思了。
    第一次看到 wwe 比赛,大概是在 2013 年左右,在一个酒楼吃饭,里面的电视机播放的,那个时候不知道是节目效果,以为是真打,看得我心惊胆战的哈哈哈哈,后来就开始追各种任务剧情,有一说一,以前 wwe 的剧情是真的还可以

    浏览器提示“SSL证书不可信”?7种常见原因及解决方法

    在数字化时代,HTTPS协议已成为网站安全与用户信任的基石。然而,许多网站运营者和开发者都曾遭遇过令人头疼的“SSL证书不可信”警告。当用户在浏览器地址栏看到那个刺眼的“不安全”提示,或是面对“您的连接不是私密连接”的全屏拦截页时,不仅用户体验大打折扣,网站的流量和信誉也会随之流失。

    这一警告并非简单的系统提示,而是浏览器内核在TLS握手阶段主动发起的安全拦截,意味着证书链无法通过验证,数据传输面临被窃听或篡改的风险。为了帮助大家快速定位并解决这一问题,本文将深入剖析导致SSL证书不受信任的7种核心原因,并提供详尽的排查步骤与解决方案。

    证书颁发机构(CA)不受信任

    这是最根本的信任危机。浏览器的信任体系建立在一个预置的“受信任根证书颁发机构”列表之上。如果你的SSL证书是由一个不在此列表中的机构签发的,浏览器就会直接判定其为“不可信”。

    常见场景与原因

    • 自签名证书:开发者在本地测试环境或内网服务器中,为了省事自行生成的证书。虽然它能实现加密传输,但由于缺乏权威第三方的背书,公网用户访问时必然报错(错误代码通常为NET::ERR_CERT_AUTHORITY_INVALID)。
    • 小众或已失效的CA:某些不知名的免费CA机构,或者曾经知名但已被主流浏览器移除信任的根证书(如旧版交叉签名证书过期),都会导致此类问题。

    解决方案

    • 弃用自签名证书:对于面向公众的生产环境,坚决杜绝使用自签名证书。
    • 选择权威CA:申请由全球主流浏览器信任的CA机构签发的证书,如DigiCert、GlobalSign、Sectigo,或免费且广泛认可的Let's Encrypt。
    • 内网特殊处理:若是企业内部系统必须使用私有CA,则需将根证书通过组策略(GPO)或MDM工具分发并安装到所有员工的终端设备信任库中。

    证书链配置不完整

    SSL证书的信任是链式的:服务器证书→中间证书→根证书。很多管理员在部署证书时,只安装了服务器证书(即域名证书),却遗漏了中间证书。这会导致浏览器无法向上追溯到受信任的根证书,从而判定信任链断裂。

    排查方法

    • 使用OpenSSL命令检查:openssl s_client -connect yourdomain.com:443 -showcerts。如果输出中只显示了一张证书,说明中间证书缺失。
    • 利用SSL Labs等在线工具进行检测,查看是否有“Incomplete Chain”的提示。

    解决方案

    • 获取完整证书链:联系你的证书提供商,下载包含中间证书的证书链文件(通常为.ca-bundle.intermediate.crt)。
    • 正确合并配置:在Nginx或Apache等服务器配置中,将服务器证书和中间证书合并为一个文件,或在指定配置项中正确引用中间证书路径,确保服务器能一次性发送完整的证书链。

    域名不匹配(通用名称错误)

    证书是严格绑定域名的。如果证书中绑定的域名与用户在浏览器地址栏输入的域名不完全一致,浏览器就会发出“名称不匹配”的警告(错误代码通常为NET::ERR_CERT_COMMON_NAME_INVALID)。

    常见误区

    • 带www与不带www:证书只申请了example.com,但用户访问的是www.example.com
    • 子域名遗漏:证书仅覆盖了主域名,未包含blog.example.com等子域名。
    • IP地址访问:直接使用IP地址访问HTTPS站点,而证书未包含该IP。

    解决方案

    • 申请通配符或多域名证书:如果需要保护主域名及其所有子域名,应申请通配符证书(*.example.com);如果涉及多个完全不同的域名,则使用多域名证书(SAN证书)。
    • 检查服务器配置:确保Web服务器(如Nginx的server_name)配置正确,且对应的虚拟主机加载了正确的证书文件。
    • 统一访问入口:通过301重定向,强制将所有HTTP请求或非标域名请求跳转到证书覆盖的标准域名上。

    证书已过期或尚未生效

    SSL证书都有明确的有效期(通常为3个月到1年,最长不超过13个月)。一旦超过有效期,或者当前时间早于证书的生效时间,浏览器都会拒绝连接。据统计,约12%的信任问题源于证书过期。

    解决方案

    • 立即续期:登录CA机构管理后台查看有效期,若已过期需立即续费并重新部署。
    • 自动化管理:强烈推荐使用Certbot等自动化工具配合ACME协议,实现证书的自动申请、续期和部署,彻底杜绝因遗忘而导致的人为过期事故。
    • 校准服务器时间:检查服务器系统时间是否准确。如果服务器时间设置错误(如快了或慢了几个月),也会导致证书状态误判。建议配置NTP服务进行时间同步。

    混合内容(Mixed Content)

    这是一种极具隐蔽性的“不安全”提示。此时地址栏可能显示HTTPS和小锁图标,但锁上带有感叹号,或者浏览器控制台提示“连接并非完全安全”。

    原因分析
    网页的主文档是通过HTTPS加载的,但页面内部引用的子资源(如图片、JavaScript脚本、CSS样式表、iframe等)却是通过不安全的HTTP协议加载的。攻击者可以劫持这些HTTP资源来篡改页面内容,因此浏览器会判定整个页面不安全。

    解决方案

    • 开发者工具排查:按F12打开浏览器开发者工具,查看“Console”或“Security”标签页,系统会明确列出哪些资源是通过HTTP加载的。
    • 全站资源HTTPS化:将代码中所有的http://链接替换为https://
    • 配置CSP策略:在服务器响应头中添加内容安全策略(CSP):add_header Content-Security-Policy "upgrade-insecure-requests";,强制浏览器将页面中的HTTP请求自动升级为HTTPS。

    客户端设备时间错误

    有时候,网站配置完全没问题,但部分用户仍反馈报错。这很可能是用户端的问题。如果用户的电脑、手机系统时间设置错误(例如时间回到了几年前,或者设置到了未来),浏览器在比对证书有效期时就会得出“证书无效”的结论。

    解决方案

    • 用户自查:提示用户检查设备右下角的时间设置,确保时区正确,并开启“自动设置日期和时间”功能。
    • 清除缓存:建议用户清除浏览器的SSL状态和缓存(Chrome中可在设置中“清除浏览数据”并勾选“缓存的图片和文件”),有时旧的证书信息缓存也会导致误报。

    网络设备拦截或中间人攻击

    在企业内网或特定网络环境下,防火墙、代理服务器、VPN或杀毒软件可能会拦截HTTPS流量进行“深度检测”。这些设备会动态生成一个伪造的证书来替代原网站证书,如果该设备自带的根证书未被用户电脑信任,浏览器就会报警。

    解决方案

    • 排查网络环境:尝试切换网络(如从公司WiFi切换到手机热点)访问,如果正常,则说明原网络存在拦截行为。
    • 关闭SSL扫描:如果是本地杀毒软件(如卡巴斯基、360等)导致的,尝试关闭其“HTTPS扫描”或“网页防护”功能。
    • 企业IT配置:对于企业网络,IT管理员需将流量解密设备的根证书分发并安装到员工终端的信任库中。

    结语

    SSL证书不仅是加密传输的工具,更是数字世界的信任锚点。解决“证书不可信”的问题,需要从证书申请、服务器配置、代码规范到客户端环境进行全链路的排查。建议网站管理员养成定期检查证书状态的习惯,利用自动化工具和监控服务,防患于未然,为用户提供一个真正安全、绿色的访问环境。

    一、主流免费 SSL 证书渠道(2026 最新)

    1. Let's Encrypt(最通用、永久免费)

    • 机构:非营利组织,全球主流 CA,浏览器 100% 信任
    • 有效期90 天(必须自动续期)
    • 支持:单域名、多域名、通配符证书
    • 申请方式

      • 命令行(Certbot)

        bash

        运行

        # Ubuntu/Debian
        sudo apt update
        sudo apt install certbot python3-certbot-nginx
        sudo certbot --nginx -d example.com -d www.example.com
      • 宝塔 / 面板:软件商店搜 “Let’s Encrypt”,点 “申请” 自动配置

    免费SSL证书https://www.joyssl.com/certificate/select/free.html?nid=7

    2. 国内云厂商(1 年有效期、中文界面)

    阿里云 / 腾讯云 / 华为云

    • 额度:每个账号 20 个 / 年 免费 DV 单域名证书
    • 有效期1 年
    • 步骤

      1. 登录控制台 → 搜索 “SSL 证书”
      2. 购买证书 → 选 免费 DV 型
      3. 填域名 → DNS TXT 验证(推荐)
      4. 签发后下载部署,支持一键部署到云服务器 / CDN

    3. Cloudflare(CDN 自带、完全无感)

    • 方式:域名 DNS 托管到 Cloudflare
    • SSL永久免费、自动签发、自动续
    • 设置:SSL/TLS → 选 完全(严格) ,开启 “始终 HTTPS”
    • 优点:不用管服务器配置、自带 CDN 加速

    4. ZeroSSL / SSL For Free

    • 有效期:90 天,免费无限续
    • 特点:支持纯 IP 证书(少数免费支持)
    • 申请:官网注册 → 填域名 → DNS / 文件验证 → 下载

    5. JoySSL(国产、部分 1 年期)

    • 免费:单域名 DV(90 天 / 1 年,教育 / 政务可 1 年)
    • 优势:国产 CA、支持国密 SM2、中文客服

    二、各方案对比(2026)

    表格

    渠道有效期通配符自动续适合人群
    Let's Encrypt90 天技术用户、服务器自建
    阿里云 / 腾讯云1 年云服务器用户、新手
    Cloudflare永久不想配置、要 CDN
    ZeroSSL90 天需 IP 证书、多域名
    JoySSL90 天 / 1 年国内、需国密合规

    三、申请通用步骤(所有渠道)

    1. 准备:域名已备案(国内服务器)、能改 DNS 解析
    2. 选择类型:单域名(如 abc.com)、通配符(*.abc.com
    3. 域名验证(二选一)

      • DNS 验证(推荐):域名后台加一条 TXT 记录
      • 文件验证:服务器网站根目录放指定 HTML 文件
    4. 签发:验证通过几分钟内下发
    5. 部署:下载证书(.pem/.crt + .key)配置到 Nginx/Apache/IIS
    6. 自动续期:务必开启,避免过期导致网站无法访问

    四、常见问题

    • 免费证书安全吗?安全。DV 域名验证与付费 DV 证书加密强度完全一致,仅无企业身份认证。
    • 通配符免费吗?Let's Encrypt、Cloudflare、ZeroSSL 支持免费通配符。
    • 可以用于小程序 / APP?可以,只要是合法域名、受浏览器信任即可。
    • 到期忘记续怎么办?用 Certbot / 云厂商自动续签 / Cloudflare 自动托管,完全不用管

    五、推荐选择

    • 新手 / 云服务器阿里云 / 腾讯云免费 1 年(省心、中文)
    • 技术 / 多域名 / 通配符Let's Encrypt + Certbot(永久免费)
    • 不想配置 / 要 CDNCloudflare(一键开启)

    Anthropic 最新模型Claude Opus 4.7已正式全面上线。

     

    相较于 Opus 4.6,Opus 4.7 在高级软件工程能力上有明显提升,尤其是在最复杂、最困难的任务上进步显著。Anthropic 称,Opus 4.7 在处理复杂、长时间运行的任务时更加严谨稳定,对指令的执行更加精确,并且会在输出结果前主动设计验证机制,确保结果可靠。

     

    此前 Anthropic 发布了 Project Glasswing,讨论 AI 模型在网络安全领域的风险与价值,并明确表示 Claude Mythos Preview 将限制发布范围,同时优先在能力较弱的模型上测试新的安全机制。

     

    Opus 4.7 是首个承担这一角色的模型:其网络安全能力不及 Mythos Preview。对于有正当网络安全需求的专业人士(如漏洞研究、渗透测试、红队演练),Anthropic 同时推出了 Cyber Verification Program,供申请参与。

     

    Opus 4.7 价格与 Opus 4.6 保持一致:输入每百万 tokens 5 美元,输出每百万 tokens 25 美元。开发者可通过 Claude API 使用模型名称 claude-opus-4-7。

     

    真正让 Opus 4.7 和上一代拉开差距的,还是下面这些更具体的测试表现。

     

    在指令遵循方面,Opus 4.7 有显著提升。这也带来一个变化:过去为旧模型编写的 prompt,有时会出现结果偏差,因为旧模型可能会模糊理解甚至忽略部分指令,而 Opus 4.7 会更严格、逐字执行。因此,用户需要相应地重新调优 prompt 和 harness。

     

    在多模态能力上,Opus 4.7 的视觉能力显著增强。它可以处理长边最高 2576 像素(约 375 万像素)的图像,是此前 Claude 模型的三倍以上。这使得依赖细节视觉信息的应用成为可能,例如读取复杂截图的电脑操作代理、从复杂图表中提取数据,以及需要像素级精度参考的任务。

     

    在实际业务能力方面,除在 Finance Agent 评测中达到当前最优表现外,内部测试也显示,Opus 4.7 在金融分析任务上优于 Opus 4.6,能够生成更严谨的分析模型、更专业的展示内容,并在多任务之间实现更紧密的协同。

     

    在记忆能力上,Opus 4.7 更善于利用基于文件系统的记忆机制,能够在跨会话的长周期任务中记住关键信息,并据此推进后续任务,从而减少前期上下文输入的负担。

     

    除模型本身外,本次还同步发布了多项更新:

     

    首先是更细粒度的推理强度控制。Opus 4.7 新增 xhigh(“超高”)档位,介于 high 和 max 之间,使用户可以在复杂问题上更灵活地权衡推理深度与延迟。在 Claude Code 中,默认推理强度已提升至 xhigh。对于编码和 agent 场景,建议从 high 或 xhigh 开始测试。

     

    在 Claude 平台(API)方面,除支持更高分辨率图像外,还推出了 task budgets(任务预算,公测中),用于控制 token 消耗,从而在长任务中更合理地分配资源。

     

    在 Claude Code 中,新增了 /ultrareview 命令,可开启专门的代码审查会话,自动读取变更内容并识别潜在 bug 和设计问题,接近资深工程师的审查能力。Pro 和 Max 用户可获得三次免费体验。此外,auto mode 也已扩展至 Max 用户,该模式允许 Claude 代替用户做出部分决策,从而减少中断,更顺畅地执行长任务,同时风险低于完全跳过权限控制。

     

    另外,从 Opus 4.6 迁移至 4.7 时,有两个与 token 使用相关的变化需要关注。首先,Opus 4.7 使用了新的 tokenizer,在文本处理上更高效,但同一输入可能会映射为更多 token(约增加 1.0–1.35 倍,取决于内容类型)。其次,在更高推理强度下,尤其是在 agent 多轮任务的后期阶段,模型会进行更多推理,从而生成更多输出 token。这提升了复杂任务的可靠性,但也带来更高的 token 消耗。

     

    用户可以通过调整 effort 参数、设置任务预算,或在 prompt 中要求更简洁的输出,来控制 token 使用。内部测试显示,总体效果是正向的:在一项内部编码评测中,各个推理强度档位下的 token 使用效率均有所提升。不过,仍建议在真实业务流量中进行实际测量。同时,Anthropic 也提供了迁移指南,帮助用户从 Opus 4.6 平滑升级到 Opus 4.7。

     

    Claude Code 之父的使用心得

     

    Boris Cherny(Claude Code 作者)在连续几周内部使用 Opus 4.7 后,给出了一组更偏“实战侧”的使用心得。整体感受很直接:生产力明显提升,同时也需要相应调整使用方式。

     

    他总结了几个关键点:

     

    首先是Auto mode(自动模式)

     

    Opus 4.7 非常擅长处理复杂、长时间运行的任务,比如深度研究、代码重构、复杂功能开发,或者反复迭代直到达到性能指标。过去要么需要全程盯着模型运行,要么只能使用--dangerously-skip-permissions这种风险较高的方式。

     

    现在的自动模式提供了一个更安全的替代方案。在这个模式下,权限请求会被转交给一个基于模型的分类器判断是否安全执行,如果判定安全,就会自动放行。

     

    这带来的变化不只是“可以不盯着看了”,更重要的是可以并行运行多个 Claude。一个任务跑起来之后,可以直接切去处理下一个 Claude。对于 Max、Teams 和 Enterprise 用户,Opus 4.7 已支持该模式,在 CLI 中可以通过 Shift + Tab 进入,或在桌面端、VSCode 的下拉菜单中选择。

     

    第二是/fewer-permission-prompts 这个新 skill

     

    它会扫描整个会话历史,找出那些其实是安全的、但却反复触发权限提示的 bash 或 MCP 命令,然后推荐加入到 allowlist 中。

     

    这个功能本质是在帮你“整理权限策略”,减少无意义的打断。如果不使用 auto mode,这个 skill 会非常实用。

     

    第三是Recaps(回顾)

     

    这是一个看起来简单但很实用的功能:为每个 agent 生成一段简短总结,说明“刚刚做了什么”和“接下来要做什么”。

     

    在处理长时间运行的任务时,隔几分钟甚至几小时再回来,这个功能能快速帮你恢复上下文。

     

    第四是Focus mode(专注模式)

     

    CLI 里新增的这个模式会隐藏所有中间过程,只保留最终结果。

     

    Boris 的说法很直白:模型已经进化到一个阶段,大多数情况下可以信任它会执行正确的命令、做出正确的修改,所以只需要看最终结果即可。通过/focus可以随时开关。

     

    第五是调整 effort(推理强度)

     

    Opus 4.7 不再依赖固定的 thinking budget,而是改用自适应思考机制。想控制模型“想多少”,主要靠 effort 参数来调节。低 effort 响应更快、token 消耗更低,高 effort 则能换来更强的能力和更深的推理。

     

    按照 Boris 的个人用法,大多数任务使用 xhigh,最难的任务才会上 max。需要注意的是,max 只对当前 session 生效,其他 effort 档位则会延续到后续 session。用户可以通过/effort来调整。

     

    第六,也是他特别强调的一点:一定要给 Claude 一个“验证自己”的手段

     

    这一点一直可以把 Claude 的效果提升 2–3 倍,在 4.7 上更重要。验证方式会根据任务类型有所不同:做后端时,要让 Claude 能启动服务并完成端到端测试;做前端时,可以通过 Claude 的 Chromium 扩展让它直接控制浏览器;如果是桌面应用,则可以使用 computer use。

     

    他现在很多 prompt 会写成类似“Claude 做某件事 /go”。这个 /go skill 会让 Claude 自动完成一整套流程:先通过 bash、浏览器或 computer use 做端到端自测,然后运行 /simplify,最后直接提交 PR。

     

    对于长时间运行的任务来说,验证机制的意义在于,当你再次回到这个任务时,可以确认代码是确实可用的,而不是停留在一个“看起来已经完成”的状态。

     

    他最后的意思是,Opus 4.7 的提升是明显的,但变化不只在模型本身,也在使用方式上。你如果还是沿用旧 workflow,当然也能感受到它比上一代更强;但只有把工作方式一起调过来,真正利用它“能跑更久、agent 性更强”的特点,这一代的差距才会被真正拉开。

     

    参考资料:

    https://www.anthropic.com/news/claude-opus-4-7

    https://x.com/bcherny/status/2044847858634064115

    之前发了沃达丰 eSIM 的申请教程。最近把充值与保号的教程做出来了。

    核心就是:去官网注册一个账户,用于管理手机号

    充值建议用 wise 或者 N264/Paypal 或者双币信用卡,我自己用 paypal 绑定国内建行储蓄卡,冲了 5 欧元,扣了 42 元人民币。
    我自己实测了 wise/Paypal ,最低可以充值 0.01 欧元。

    充值的时候,务必填上自己的客户编号!!!

    目前保号规则:90 天内要求余额变动就算活跃。(充值一般要等个 1-2 天才会到账)

    有需要的朋友可以看我的做的视频教程:
    [充值&保号教程] : https://youtu.be/cUxN7wPa3WQ
    [激活教程] : https://youtu.be/y6f5iwD4vPs

    op 前端,向往全栈方向走,想知道后端需要哪些知识?除了语言和 sql 外,还需要哪些?目前我想到的有如下:ngix 、redis 、docker 、nacos 等等。

    ai 时代技术的价值没那么大这一点我知道,真正项目中最重要的点是解决问题的能力,也就是经验。但是我现在脑子里没有后端那套体系,遇到的问题是一片空白,所以想请教各位大佬,有哪些知识是可以预先学习下的。

    在这里插入图片描述

    2025年10月16日,Anthropic推出了Skills的概念。起初Anthropic官方对它的定位还仅仅是用来提升Claude在某些特定任务的表现。但一经推出受到了人们的强烈推崇,行业内很快也都跟进了脚本,像VS code、Cursor、Codex也都很快支持了Agent Skills。

    在这样的背景下,Anthropic在2025年12月18日发布为开放标准,实现了跨平台、可移植性的开放标准。

    在这里插入图片描述

    这意味着Agent Skills已经超越了单一Claude上的应用,正在演变成为AI Agent领域的一个通用设计模式。

    Agent Skills 是什么

    为了彻底给大家讲清楚Agent Skills,下面的内容会按照如下顺序介绍:

    • 概念
    • 基本用法
    • 高级用法
    • Reference
    • Script
    • 与MCP对比

    那么,Agent Skills到底是做什么的呢?我们可以理解为:Agent Skills就是大模型(LLM)可以随时翻阅的一份说明文档或帮助文档。简单来说,Agent Skills可以提前让大模型提前根据说明书学会相应的技能。

    举例来说:

    智能客服Skill 会议总结Skill
    回答时请注意:请将会议内容总结为如下几点:
    1、必须先安抚客户1、参会人员
    2、不得随意承诺2、议题
    ... ...3、决定

    那么我们就以【会议总结Skill】为示例,带着大家看下Skill到底是如何使用的。

    Agent Skills 使用方法

    我们以Claude Code为例,Claude Code想要使用Skills,就需要在项目路径下.claude/skills文件夹下放置自己的Skills文档。

    在这里插入图片描述

    接着,我们创建一个名称为meeting-summarizer的Skill文件夹,用vs code打开。接着我们放置一个SKILL.md,这个文件就是我们编写的Skill文档。

    在这里插入图片描述

    Skill文档分为两部分,一部分叫“元数据”,这一部分只写了namedescription两个属性,name是Angent Skill的名称,必须和文件夹的名称相同;description表示这个Agent Skill的描述,主要就是给大模型说明这个Agent Skill是干什么的。

    另一部分叫“指令”,也就是告诉大模型在相应的场景下应该采取什么对应的方式并按照我们的要求输出相应的内容。

    好的,到这里我们的会议总结助手就可以试试用了。是不是很简单?我们先来看下Claude Code有没有读取到我们的会议总结助手;

    在这里插入图片描述

    可以看到,Claude Code已经知道了我们的Skill。输入一段会议内容,让Claude Code总结一下。

    在这里插入图片描述

    总结一下,用户使用Skill进行交互如下图所示:
    在这里插入图片描述

    Agent Skills 高级用法(Reference)

    到这里,相信大家已经明白的Agent Skill的基本用法,那么我们也会面临一些复杂的场景。当我们有一些特定场景时,需要大模型参考另外的说明文档,那么如果这样的文档很多的情况下,就会消耗很多的token,这也就有点违背Skills的初衷。例如,当我们有一份公司财务手册,我们希望在总结会议内容时,如果有提到费用、报销等内容时,才需要大模型读取公司财务手册。那么就要用到Reference了。

    我们在Skill中已经写明了财务提醒这一项规则:

    在这里插入图片描述

    接着我们再用一段会议内容测试下:
    在这里插入图片描述

    可以看到,大模型根据我们的要求读取了相关的文档并给出了更为详细的结论,这完美的符合我们的需求。在Agent Skill体系里,Company-Financial-Manual.md就是典型的Reference,它有一个典型特性,按条件触发。这就说明,如果没有条件触发,那么这个md文件只会躺在硬盘里,不会占用一丁点token。

    Agent Skills 高级用法(Script)

    说完了Reference,我们再来说说如何让Agent Skill跑代码执行逻辑,毕竟查资料只是第一步,后续也有很多场景会涉及逻辑的交互,能真正帮我们把活儿干到位了,这才是真正的自动化。

    这就是Agent Skill的另一大能力——Script。

    我们可以先创建一个python脚本,这个脚本用来模拟上传总结好的会议内容:

    在这里插入图片描述

    接着,我们在Skill文档中说明规则:

    在这里插入图片描述

    我们再来测试下效果:
    在这里插入图片描述

    可以看到,我们这次给出的会议内容没有涉及到财务相关,大模型也就没有“理”那一份财务文档,给出的最终结果也没有相应的财务提醒相关内容。这再次说明印证了Reference是按需加载的。

    如果用户没有提及与Reference相关的内容,Claude Code是不会读取相关Reference的,这样也就达到了节省token的目的。Claude Code只关心脚本的运行方法和结果,至于脚本的内容可以说毫不在意,所以也不会占用token的消耗。

    总结一下,Reference是读,它会加载到上下文,所以会按需消耗token;而Script是跑,它只会按规则执行对应的脚本,不会消耗token。

    Agent Skills 渐进式披露机制

    Agent Skill的设计其实是一个精密的渐进式披露结构(Progressive Disclosure),这一结构一共有三层,每一层的加载机制都不太一样。

    层级组成加载
    元数据层(Metadata)名称(name)、描述(description)始终加载
    指令层(Instruction)SKILL.md除name和description之外的内容按需加载
    资源层(Resource)Reference、Script按规则触发

    Agent Skills 与 MCP 的区别

    最后,Agent Skill与MCP有什么区别呢?其实这两者可以相辅相成,一起配合使用,从而达到让大模型更为精准的给出我们想要的结果。

    如果我们用厨房来举例:

    • MCP是“硬件”(厨房),Skills是“软件”(菜谱);
    • 有厨房没菜谱→不知道做什么、怎么做;
    • 有菜谱没厨房→空有想法,无法做出美物的食物;
    • 两者结合,才能做出一道好菜(创造出价值)。

    总结一下,以Claude Code为背景:

    MCP(连接能力)Skills(知识)
    将Claude连接到你的各种服务(比如Notion、天气服务等)教会Claude如何有效使用你的服务
    提供实时数据访问和工具调用能力捕捉工作流程和最佳实践
    Claude能做什么(What)Claude应该怎么做(How)

    附件为示例的工程。

    skills.7z

    引言

    在数字化转型的浪潮中,企业应用开发正面临前所未有的挑战:既要满足日益复杂的业务需求,又要实现快速交付。传统低代码平台虽已大幅简化开发流程,但在面对高度定制化、智能化需求或遗留系统改造等复杂项目时,仍显力不从心。2026年,随着AI技术的深度赋能,低代码领域迎来颠覆性变革,真正实现了"复杂项目也能极速落地"的承诺。本文将深入剖析AI如何重构低代码开发范式,并探讨其在核心业务场景中的突破性应用。

    一、AI重构开发范式:从"拖拽"到"对话"

    新一代低代码平台的核心突破在于将大语言模型(LLM)的智能深度融入应用开发生命周期的各个环节,这不仅是功能叠加,更是对开发范式的彻底重构。

    1. 设计时提效:自然语言驱动建模

    开发者不再需要繁琐的配置过程,只需输入业务需求的自然语言描述。例如:

    "创建一个进销存系统,包含商品管理、库存预警和智能采购建议功能"

    AI引擎能自动推导并生成完整的数据模型,包括商品、库存、订单等核心表结构及其关联关系。这种"所想即所得"的能力,将复杂系统的初始设计时间从数天缩短至数小时。SQL语句生成、页面原型构建等环节同样受益于AI,开发者能够更专注于业务逻辑本身。

    2. 运行时增智:智能体驱动业务流程

    发布后的应用不再是静态工具,而是具备智能交互与决策能力的"智能体"。这些智能体基于LLM,具有以下核心能力:

    • 自然语言办成事:用户无需学习复杂操作,如输入"提交采购申请",智能体自动完成申请单创建、流转和信息填充
    • 深度集成能力:自动调用平台内预设函数或外部API接口,实现跨系统自动化协同
    • 结构化交互反馈:通过创新的"AI对话单元格"和卡片消息功能,将执行结果以直观方式呈现

    二、攻克复杂项目:AI赋能的三大核心场景突破

    1. 遗留系统现代化改造

    传统Access等桌面应用迁移至Web系统面临诸多挑战。AI赋能的低代码平台提供行业首创的一键导入转换能力:

    1. 将Access表和窗体直接转化为Web应用的数据表和页面
    2. 保留历史数据
    3. 通过AI分析理解原有业务逻辑
    4. 辅助开发者高效完成迁移和优化

    这一过程显著降低了复杂改造项目的风险和周期,某制造企业ERP系统迁移案例显示,项目周期缩短了67%,成本降低55%。

    2. 智能化流程再造

    复杂业务流程往往涉及多角色协作、条件分支等复杂逻辑。AI智能体与低代码可视化流程引擎结合,实现了:

    • 自然语言描述生成流程框架
    • 运行时智能任务分配和超时预警
    • 基于语义理解的自动路径选择

    某金融机构的贷款审批流程应用此技术后,审批效率提升210%,错误率下降90%。

    3. 数据洞察与决策支持

    面对海量数据,用户只需提出自然语言查询:

    "显示上月销售额最高的产品,并按区域分类"

    AI自动完成查询、分析并生成可视化报表,为复杂业务场景提供即时数据支撑。某零售企业通过此功能,将数据分析响应时间从2天缩短至2分钟。

    三、极速落地的关键:安全、可控与融合

    AI的深度应用并非以牺牲安全与可控性为代价。新一代平台强调:

    1. 权限控制与安全审计

    • 智能体只能访问授权资源
    • 全程记录操作日志保障可追溯性
    • 敏感操作设置二次确认机制

    2. 人在回路(Human-in-the-loop)

    关键业务输出可结合人工复核,确保准确性与合规性,平衡自动化与人工干预。

    3. 渐进式智能化演进

    AI能力作为可选模块,支持从传统应用到智能应用的平滑演进。其核心优势在于原生对接企业现有数据模型与业务流程,确保智能化功能能快速融入实际业务场景。

    结论

    2026年,AI深度赋能的低代码平台已从概念走向实践,成为解决企业复杂项目开发痛点的利器。通过在设计时大幅提效、在运行时显著增智,并结合对核心业务场景的突破,新一代平台真正实现了复杂项目的极速落地。这标志着低代码进入智能化新阶段,为企业数字化转型提供了更强大、敏捷且智能的开发引擎。未来,随着AI技术的持续演进,低代码平台将进一步提升其解决复杂业务问题的能力,成为企业数字化创新的核心驱动力。

    选择深度融合AI的低代码平台,不仅是技术升级,更是企业构建未来竞争力的战略决策。在数字化转型的赛道上,这将成为企业赢得先机的关键一步。

    干眼症,实在难受。

    目前在公司和家里都买了点万汉润晶的滴眼液来滴。也弄了个脚本来提醒我可以休息一下做做眼保健操。

    手机上每天晚上很早就打开了夜间模式;眼镜也是防蓝光的,当然这个有没有作用就见仁见智了。

    有时候看看公司里那些三四十岁了天天盯着电脑也不近视的就觉得还挺牛逼的。

    https://github.blog/news-insights/company-news/changes-to-github-copilot-individual-plans/


    GitHub Copilot 个人版计划调整( 2026-04-20 官方公告精简总结) 发布时间:2026 年 4 月 20 日,核心原因:智能代理工作流导致算力/成本激增,为保障现有用户体验而调整。

    一、核心调整( 3 项)

    1. 暂停新用户注册 Copilot Pro 、Pro+、学生计划停止接收新订阅,优先保障存量用户服务质量。

    2. 收紧使用限额- 按会话+周度双维度按 Token 限制,与高级请求额度独立计算。- Pro+额度是 Pro 的 5 倍以上,Pro 用户可升级提升限额。- VS Code 、Copilot CLI 实时显示用量,接近限额会提醒。

    3. 模型权限调整- Pro 计划不再可用 Opus 系列模型。- Pro+保留 Opus 4.7 ,将移除 Opus 4.5/4.6 。

    二、限额与透明化

    • 限额分会话限(防高峰过载)、周度限(控长时并行请求成本)。

    • 剩余用量与重置时间在编辑器/终端直接可见,减少意外受限。

    三、退款与取消

    • 4 月订阅不满意可取消订阅,4 月费用全免。

    • 4.20–5.20 联系 GitHub 支持可申请退款。

    四、应对建议

    • Pro 需更高额度 → 升级 Pro+。

    • 简单任务用乘数更小的模型,少用并行/长会话工具(如/fleet )。

    • 开启 Plan 模式提升效率、降低消耗。

    后续大概了解了一下,我觉得色温灯的需求不高,目前我的想法是
    1 、 网关 M2 , 智能开关,不需要妙控屏幕里
    2 、 中央空调的 VRF 控制器 是肯定要的
    3 、 传感器,目前的想法是: 主卫一个,次卫外面有个设计小灯(我想路过让他自动亮起
    4 、 能介入 homkit 的智能门铃 (昨天看视频,门铃可以自动投放到电视机上,感觉还不错


    有几个问题想问问:

    1 、妙控屏是否必须呢? 智能开关一般要多少个? 三个房间,主卫,次卫,这是 5 个? 客餐厅各一个? 一个 7 个吗
    2 、色温灯的场景到底有没有必要
    3 、智能门锁是否有必要? 我昨天看视频讲解说是,门锁可以链接 tsl 自动开空调,我觉得这也不错
    4 、如果后续洗衣机啊,扫地机器人接入的话,是不是只要机器支持就可以?
    5 、新风系统有必要接入吗? 还有什么厨房的一些报警系统?

    感谢各位大佬

    前几天随手发了一个骑摩托车的视频,没想到引起了轩然大波,视频被推流到了广东广西等地方,观众大多也都是外卖骑手,评论区基本一边倒

    举例来说:

    我在北京发视频说:这条路60巡航很舒服

    A:60 太慢了,我这边都是 80 起步

    B:你这属于危险驾驶,必须 40 (配图小区内道路)

    C:不会骑车就别骑

    D:我电动车都比你快

    后续我又发了个视频解释为什么,但还是有人在自说自话

    这波视频流量不错,但是给我带了相当大的压力,周六那天都干失眠了

    身处内地某省会城市。身为技术人员,不善交际,没有圈子。
    一方面,年级大了,有找对象的需求。
    二方面,读了些没用的书,有交流的需求。

    对于需求一,试过一些 APP 和平台,要么没回应,要么好像是约 P 的。
    对于需求二,没用的书读多了,好像是注定是孤独的。参加几次线下的一些读书会,来的人要么是来凑热闹的,要么跟自己不在一个频道。

    Tomcat 是 Java Web 开发的基石。我们天天使用它,但你是否思考过它内部是如何工作的?为了打破这个“黑盒”,最好的方式就是动手实现一个极度精简的核心。本项目 “TinyTomcat” 的目标,就是用大约 300 行纯 Java 代码,实现一个能够解析 HTTP 请求、路由到对应处理逻辑并返回响应的微型服务器。通过这个过程,你将透彻理解 Tomcat 处理请求的本质:监听端口、解析协议、调度响应。

    所以,我们的目标是:

    1. 监听一个端口(比如8080),接受HTTP请求。
    2. 解析HTTP请求,至少能解析请求的URL和方法(GET、POST等)。
    3. 根据请求的URL,找到对应的处理逻辑(类似于Servlet),并返回响应。
    4. 响应基本的HTTP格式,包括状态行、头部和响应体。

    核心设计思路

    一个基础的 HTTP 服务器,无论规模大小,其核心流程都可以抽象为下图所示的步骤:

    graph TD
        A[客户端请求] --> B(ServerSocket 接受连接)
        B --> C[读取并解析 HTTP 请求行/头]
        C --> D{请求路径是 '/' ?}
        D -->|是| E[返回欢迎首页]
        D -->|是 Servlet 路径| F[调用对应 Servlet.service]
        D -->|是文件路径| G[查找并发送静态文件]
        D -->|都不是| H[返回 404 错误]
        E --> I[构建 HTTP 响应]
        F --> I
        G --> I
        H --> I
        I --> J[发送响应给客户端]

    基于这个流程,我们设计出五个核心类,共同完成了上图的闭环:

    1. SimpleTomcat (服务器引擎):这是大脑,负责启动、监听端口,并协调所有工作。
    2. SimpleRequest (请求解析器):这是翻译官,将原始的、文本格式的 HTTP 请求解析成程序容易理解的 Java 对象。
    3. SimpleResponse (响应构建器):这是包装工,负责将我们的处理结果,包装成符合 HTTP 协议格式的字节流。
    4. SimpleServlet (处理接口):这是业务合同,定义了所有动态处理器(Servlet)必须遵守的规范。
    5. HelloServlet (业务实现):这是我们的一个具体业务逻辑例子。

    构建服务器引擎 (SimpleTomcat.java)

    这个类是程序的起点,也是调度中心。其核心逻辑在 start()handleClient方法中。

    • 多线程处理。我们使用 ExecutorService线程池来处理每一个客户端连接 (Socket),这是服务器能同时服务多个请求的基础,避免了单线程阻塞。
    • 路由分发。在 handleClient方法中,我们读取请求的第一行(如 GET /hello HTTP/1.1),解析出请求路径,然后根据一个预设的“路由表” (servletMapping) 来决定将这个请求派发给谁处理。这模仿了 Tomcat 中 web.xml或注解配置的 Servlet 映射机制。
    • 区分动态与静态。我们的路由逻辑区分了三种情况:访问根路径返回欢迎页、访问注册的 Servlet 路径则动态处理、其他路径则尝试查找静态文件
    import java.io.*;
    import java.net.*;
    import java.nio.file.*;
    import java.util.*;
    import java.util.concurrent.*;
    import java.time.*;
    import java.time.format.*;
    
    /**
     * Mini版 Tomcat - 核心服务器
     * 功能:监听端口、解析HTTP、路由请求
     */
    public class SimpleTomcat {
        private int port = 8080;
        private String webRoot = ".";
        private ServerSocket serverSocket;
        private ExecutorService threadPool;
        private boolean running = false;
        
        // Servlet映射表:路径 -> Servlet实例
        private Map<String, SimpleServlet> servletMapping = new ConcurrentHashMap<>();
        // 静态文件后缀映射
        private static final Map<String, String> CONTENT_TYPES = Map.of(
            ".html", "text/html; charset=utf-8",
            ".txt", "text/plain; charset=utf-8",
            ".js", "application/javascript",
            ".css", "text/css",
            ".json", "application/json",
            ".png", "image/png",
            ".jpg", "image/jpeg",
            ".jpeg", "image/jpeg",
            ".gif", "image/gif"
        );
        
        public SimpleTomcat(int port, String webRoot) {
            this.port = port;
            this.webRoot = webRoot;
            this.threadPool = Executors.newFixedThreadPool(20);
        }
        
        public void start() throws IOException {
            serverSocket = new ServerSocket(port);
            running = true;
            System.out.printf("🚀 SimpleTomcat 启动在 http://localhost:%d\n", port);
            System.out.printf("📁 静态文件目录: %s\n", new File(webRoot).getAbsolutePath());
            
            // 注册默认处理器
            registerDefaultServlets();
            
            while (running) {
                Socket client = serverSocket.accept();
                threadPool.submit(() -> handleClient(client));
            }
        }
        
        public void stop() {
            running = false;
            try {
                if (serverSocket != null) serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            threadPool.shutdown();
        }
        
        // 注册Servlet
        public void addServlet(String path, SimpleServlet servlet) {
            servletMapping.put(path, servlet);
            System.out.printf("📋 注册Servlet: %s -> %s\n", path, servlet.getClass().getSimpleName());
        }
        
        private void registerDefaultServlets() {
            addServlet("/hello", new HelloServlet());
            addServlet("/time", (req, res) -> {
                res.setContentType("text/plain; charset=utf-8");
                res.getWriter().write("当前时间: " + Instant.now().toString());
            });
        }
        
        private void handleClient(Socket client) {
            try (client;
                 BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                 OutputStream out = client.getOutputStream()) {
                
                // 读取请求行
                String requestLine = in.readLine();
                if (requestLine == null) return;
                
                String[] parts = requestLine.split(" ");
                if (parts.length < 3) return;
                
                String method = parts[0];
                String path = parts[1];
                
                // 创建请求/响应对象
                SimpleRequest request = new SimpleRequest(method, path, in);
                SimpleResponse response = new SimpleResponse(out);
                
                // 记录访问日志
                logRequest(client.getInetAddress().getHostAddress(), method, path);
                
                // 路由处理
                if (path.equals("/")) {
                    serveWelcomePage(response);
                } else if (servletMapping.containsKey(path)) {
                    // 动态Servlet处理
                    servletMapping.get(path).service(request, response);
                } else if (path.equals("/favicon.ico")) {
                    serveFavicon(response);
                } else {
                    // 静态文件服务
                    serveStaticFile(path, response);
                }
                
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        private void serveWelcomePage(SimpleResponse res) throws IOException {
            res.setContentType("text/html; charset=utf-8");
            PrintWriter writer = res.getWriter();
            writer.println("<!DOCTYPE html>");
            writer.println("<html><head><title>MiniTomcat</title>");
            writer.println("<style>");
            writer.println("body { font-family: Arial; margin: 40px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; }");
            writer.println(".container { max-width: 800px; margin: 0 auto; padding: 20px; background: rgba(255,255,255,0.1); border-radius: 10px; }");
            writer.println("h1 { text-align: center; font-size: 2.5em; margin-bottom: 30px; }");
            writer.println(".card { background: rgba(255,255,255,0.2); padding: 20px; border-radius: 8px; margin: 15px 0; }");
            writer.println("a { color: #ffd700; text-decoration: none; padding: 8px 15px; background: rgba(0,0,0,0.3); border-radius: 5px; }");
            writer.println("a:hover { background: rgba(0,0,0,0.5); }");
            writer.println("</style></head><body>");
            writer.println("<div class='container'>");
            writer.println("<h1>🚀 SimpleTomcat 已启动!</h1>");
            writer.println("<div class='card'><h3>📡 测试链接</h3>");
            writer.println("<p><a href='/hello'>/hello - 问候Servlet</a></p>");
            writer.println("<p><a href='/time'>/time - 时间Servlet</a></p>");
            writer.println("<p><a href='/index.html'>/index.html - 静态文件</a></p>");
            writer.println("</div>");
            writer.println("<div class='card'><h3>📁 服务器信息</h3>");
            writer.println("<p><strong>服务器时间:</strong>" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + "</p>");
            writer.println("<p><strong>工作目录:</strong>" + new File(webRoot).getAbsolutePath() + "</p>");
            writer.println("<p><strong>已注册Servlet:</strong>" + servletMapping.size() + "个</p>");
            writer.println("</div></div></body></html>");
        }
        
        private void serveStaticFile(String path, SimpleResponse res) throws IOException {
            File file = new File(webRoot + path);
            if (!file.exists() || file.isDirectory()) {
                serve404(res, "文件未找到: " + path);
                return;
            }
            
            // 设置Content-Type
            String contentType = "application/octet-stream";
            for (Map.Entry<String, String> entry : CONTENT_TYPES.entrySet()) {
                if (path.endsWith(entry.getKey())) {
                    contentType = entry.getValue();
                    break;
                }
            }
            res.setContentType(contentType);
            res.setContentLength(file.length());
            
            // 发送文件
            Files.copy(file.toPath(), res.getOutputStream());
        }
        
        private void serve404(SimpleResponse res, String message) throws IOException {
            res.setStatus(404, "Not Found");
            res.setContentType("text/html; charset=utf-8");
            PrintWriter writer = res.getWriter();
            writer.println("<html><head><title>404 Not Found</title></head>");
            writer.println("<body><h1>404 找不到页面</h1><p>" + message + "</p>");
            writer.println("<p><a href='/'>返回首页</a></p></body></html>");
        }
        
        private void serveFavicon(SimpleResponse res) throws IOException {
            res.setStatus(204, "No Content"); // 不返回favicon
        }
        
        private void logRequest(String ip, String method, String path) {
            String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"));
            System.out.printf("[%s] %s %s %s\n", time, ip, method, path);
        }
        
        public static void main(String[] args) throws IOException {
            int port = args.length > 0 ? Integer.parseInt(args[0]) : 8080;
            String webRoot = args.length > 1 ? args[1] : ".";
            
            SimpleTomcat tomcat = new SimpleTomcat(port, webRoot);
            Runtime.getRuntime().addShutdownHook(new Thread(tomcat::stop));
            tomcat.start();
        }
    }

    解析 HTTP 请求 (SimpleRequest.java)

    HTTP 请求本质上是按特定格式组织的文本。SimpleRequest类的任务就是解析它。

    • 解析请求行。构造函数中,通过 requestLine.split(" ")可以得到方法、路径和协议版本
    • 解析查询参数。在 parseQueryString方法中,我们处理 URL 中 ?后面的部分(如 name=Bob&age=25),将其拆解成键值对,存入 params映射,这样 Servlet 中就能通过 getParameter("name")获取值。
    • 解析请求头。通过循环读取输入流直到空行,将 HeaderName: HeaderValue这样的行解析后存入 headers映射。虽然我们的迷你版没有用到所有头部信息,但这种设计为后续扩展(如处理 Cookie、Session)留出了空间。
    import java.io.*;
    import java.util.*;
    
    /**
     * 请求对象
     */
    public class SimpleRequest {
        private final String method;
        private final String path;
        private final Map<String, String> headers = new HashMap<>();
        private final Map<String, String> params = new HashMap<>();
        
        public SimpleRequest(String method, String path, BufferedReader in) throws IOException {
            this.method = method;
            this.path = path;
            
            // 解析查询参数
            int qIndex = path.indexOf('?');
            if (qIndex > 0) {
                parseQueryString(path.substring(qIndex + 1));
            }
            
            // 解析请求头
            String line;
            while ((line = in.readLine()) != null && !line.isEmpty()) {
                int colon = line.indexOf(':');
                if (colon > 0) {
                    headers.put(
                        line.substring(0, colon).trim().toLowerCase(),
                        line.substring(colon + 1).trim()
                    );
                }
            }
        }
        
        private void parseQueryString(String query) {
            for (String pair : query.split("&")) {
                String[] kv = pair.split("=", 2);
                if (kv.length == 2) {
                    params.put(kv[0], kv[1]);
                }
            }
        }
        
        public String getMethod() { return method; }
        public String getPath() { 
            int qIndex = path.indexOf('?');
            return qIndex > 0 ? path.substring(0, qIndex) : path;
        }
        public String getParameter(String name) { return params.get(name); }
        public String getHeader(String name) { return headers.get(name.toLowerCase()); }
        
        public String toString() {
            return method + " " + path;
        }
    }

    构建 HTTP 响应 (SimpleResponse.java)

    与解析请求相对,我们需要构建一个格式正确的 HTTP 响应。HTTP 响应由状态行、响应头和响应体三部分组成。

    • 延迟发送头。我们设置了 headersSent标志位。这是因为在业务代码(Servlet)中,可能会先设置状态、内容类型等头部信息,再输出响应体。getWriter()getOutputStream()方法会在第一次被调用时,自动将所有已设置的头部信息发送出去(sendHeaders方法),这是一个巧妙的设计,确保了头部先于身体发送。
    • 头部格式。在 sendHeaders方法中,我们严格按照 HTTP/1.1 200 OK\r\nHeader: Value\r\n\r\n的格式拼接字符串。注意最后的空行 \r\n\r\n,它是分隔头部和身体的关键标记。
    import java.io.*;
    import java.text.SimpleDateFormat;
    import java.util.*;
    
    /**
     * 响应对象
     */
    public class SimpleResponse {
        private final OutputStream output;
        private PrintWriter writer;
        private int status = 200;
        private String statusText = "OK";
        private final Map<String, String> headers = new HashMap<>();
        private boolean headersSent = false;
        
        public SimpleResponse(OutputStream output) {
            this.output = output;
            headers.put("Server", "SimpleTomcat/1.0");
            headers.put("Date", new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US)
                .format(new Date()));
        }
        
        public void setStatus(int status, String text) {
            this.status = status;
            this.statusText = text;
        }
        
        public void setContentType(String type) {
            headers.put("Content-Type", type);
        }
        
        public void setContentLength(long length) {
            headers.put("Content-Length", String.valueOf(length));
        }
        
        public PrintWriter getWriter() throws IOException {
            sendHeaders();
            if (writer == null) {
                writer = new PrintWriter(new OutputStreamWriter(output, "UTF-8"), true);
            }
            return writer;
        }
        
        public OutputStream getOutputStream() throws IOException {
            sendHeaders();
            return output;
        }
        
        private void sendHeaders() throws IOException {
            if (headersSent) return;
            headersSent = true;
            
            StringBuilder sb = new StringBuilder();
            sb.append("HTTP/1.1 ").append(status).append(" ").append(statusText).append("\r\n");
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\r\n");
            }
            sb.append("\r\n");
            output.write(sb.toString().getBytes("ISO-8859-1"));
        }
    }

    定义处理契约 (SimpleServlet.java)

    为了支持灵活的动态处理,我们定义了极简的 SimpleServlet接口。它只有一个 service方法,接受请求和响应对象。这模仿了标准 Servlet 的 service方法,是设计模式中策略模式​ 的体现。我们可以为不同路径(如 /hello, /time)注册不同的实现类,服务器引擎无需关心具体逻辑,只需调用其 service方法即可

    import java.io.IOException;
    
    /**
     * 极简Servlet接口
     */
    @FunctionalInterface
    public interface SimpleServlet {
        void service(SimpleRequest request, SimpleResponse response) throws IOException;
    }

    实现业务逻辑 (HelloServlet.java)

    HelloServlet是我们契约的一个具体实现。实现的步骤是:

    1. 从 SimpleRequest对象中获取用户参数(req.getParameter("name"))。
    2. 通过 SimpleResponse对象设置内容类型。
    3. 通过 res.getWriter()获得输出流,生成动态的 HTML 内容。

    这个 Servlet 就像一个简单的控制器(Controller),它处理业务(组合问候语和当前时间),并渲染视图(生成 HTML 页面)。

    import java.io.*;
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    
    /**
     * 示例Servlet
     */
    public class HelloServlet implements SimpleServlet {
        @Override
        public void service(SimpleRequest req, SimpleResponse res) throws IOException {
            String name = req.getParameter("name");
            if (name == null || name.trim().isEmpty()) {
                name = "朋友";
            }
            
            res.setContentType("text/html; charset=utf-8");
            PrintWriter writer = res.getWriter();
            
            writer.println("<!DOCTYPE html>");
            writer.println("<html><head><title>问候页面</title>");
            writer.println("<style>");
            writer.println("body { font-family: Arial, sans-serif; text-align: center; margin: 100px; background: linear-gradient(45deg, #f093fb 0%, #f5576c 100%); color: white; }");
            writer.println(".greeting { font-size: 3em; margin: 20px; text-shadow: 2px 2px 4px rgba(0,0,0,0.3); }");
            writer.println(".time { font-size: 1.2em; opacity: 0.9; }");
            writer.println("input, button { padding: 10px; font-size: 16px; margin: 10px; border: none; border-radius: 5px; }");
            writer.println("</style></head><body>");
            writer.println("<div class='greeting'>👋 你好, " + name + "!</div>");
            writer.println("<div class='time'>" + LocalDateTime.now().format(
                DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss")) + "</div>");
            writer.println("<form method='GET'>");
            writer.println("<input type='text' name='name' placeholder='输入你的名字' value='" + name + "'>");
            writer.println("<button type='submit'>重新问候</button>");
            writer.println("</form>");
            writer.println("<p><a href='/' style='color:white;'>🏠 返回首页</a></p>");
            writer.println("</body></html>");
        }
    }

    总结

    我们这个 TinyTomcat 虽然简单,但基本已经有了Tomcat的的核心骨架。真正的 Tomcat 正是在此基础上,在各个维度进行了史诗级的增强:

    • 性能与并发:使用 NIO/AIO 连接器、更精细的线程池、缓存机制。
    • 配置与可扩展性:通过 server.xml, web.xml, 注解等方式进行复杂配置,支持 Valve、Filter 等扩展链。
    • 安全:实现安全管理器、 Realm 域认证。
    • 生命周期与容器:实现完整的 Lifecycle接口,管理 Server、Service、Engine、Host、Context、Wrapper 等层次化容器。
    • 协议支持:支持 HTTP/1.1、HTTP/2,甚至 AJP 协议。
    • 会话管理:实现复杂而强大的 Session 创建、跟踪、持久化机制。
    • 异步处理:支持 Servlet 3.0+ 的异步 I/O 处理。

    接下来,我将会继续从源码角度介绍 Tomcat 的核心设计,可以持续关注

    作者 | Tina

    采访嘉宾 | 沈浪、茹炳晟、吴娟、方汉

    编辑 | 蔡芳芳

     

    “我不明白,AI 的发展为什么不是让我们能 5 点下班,而是让更多人被裁员,其他人继续工作到 10 点。”

     

    “两年前,我们工作的节奏还可以,但 AI 到来之后,这个状态不存在了。节奏一下子被拉快了,因为管理层觉得 AI 可以极大提升效率,以前还能按正常周期推进的事情,现在都默认你应该更快给结果。”

     

    “现在我们内部的考核,其实已经慢慢往 AI 那边偏了。最直接的就是代码量,我们有一个排行榜,谁发了多少行代码,一刷就能看到。组里有个别人几乎全靠 AI 在写,代码量和 PR 数量一下子拉得特别高,慢慢大家就都被拿去跟这种人对标。慢慢就有点变味了,一开始是比代码量,后来开始比谁用 AI 用得多,再往后连 Token 都开始被看。这些东西其实没有写进绩效,但你心里都清楚,什么是会被看到的。”

     

    从这三个程序员的讲述里,能明显感觉到,行业里的气氛在变,大家都在被迫提速。

     

    与此同时,业界也不断传出各种收紧人力的消息,真假交织。国外亚马逊、Meta 在调整岗位结构,国内也不断传出网易等大厂压缩外包、用 AI 接手基础工作的消息,连“裁员一定要快”都成了热梗。

     

    AI 的发展,开始和一种残酷的判断绑在了一起:既然有些活已经明显变快,那人是不是可以少一点?于是,越来越多人心里开始冒出一丝不安:当效率被不断量化、不断比较之后,下一个被算掉的,会不会就是自己?

     

    提效这阵风,没人能站在风外

     

    过去一年,大家讨论 AI,已经从“要不要用(adoption)”转向“到底能不能提速(speed)”,感觉像是“成熟度”的潘多拉魔盒一下子被打开了。毕竟,AI 在软件开发里的角色变化太快了,从最早的代码补全,到对话式生成,再到 agent,甚至多智能体协同,它介入研发流程的深度已经和以前很不一样了。

     

    也正因为变化太快,市场上越来越多人开始把这类能力看得近乎神乎其神,甚至开始有意无意地传播一种更浮躁而激进的想法:AI 时代的软件工程已经和过去完全不同了,好像原来那套工程实践都可以被抛开,不需要懂 Kubernetes,不需要理解系统架构,只要会用模型,就够了。Agent 也仿佛成了什么都能包办的“万能外包”。而其中的代表 Claude Code,不知不觉间已经成了部分人的“技术信仰”。

     

    对不少企业负责人来说,这确实是一个疯狂又不可思议的时期。

     

    尤其是对于那些本来就只有二三十人的小公司,或者现在很流行的 OPC、“一人公司”来说,大模型带来的提效几乎是一眼就能看到的,很多活就是比过去纯靠人手写快得多。也正因为这样,这类公司的负责人最容易被那些炫技产品打动,尤其是 Design to Code 这种从 Figma 直接生成前端代码的演示。

     

    这种效率上的提升,同样也吸引了互联网企业。

     

    互联网公司最后还是要看数字。比如腾讯就在去年底发过一组数据:九成员工使用编程助手,将编码时间缩短了 40%,整体提升 20%。

     

    快手则把生产力提升的北极星指标直接放在了“需求交付周期”上。按照他们向 InfoQ 提供的最新数据,L1 阶段的团队,AI 主要还是代码补全工具,提升通常在 15% 到 25% 之间;而到了 L2、L3 阶段,AI 开始更深地进入交付过程,甚至能自主完成更多任务,人主要做需求定义和质量审核,提效幅度会更大一些。“我们标杆团队,L2/L3 需求占比超过 20% 的,交付周期下降了 58%。”

     

    昆仑万维 CEO 方汉也对 InfoQ 提到,公司使用 AI 后,“项目平均交付时间大幅缩短了”。他在接受《中国企业家》采访时也进一步披露了背后的投入和效果:公司已经不再把 AI 支出看作 Token 补贴,而是纳入统一的 IT 采购。按他的说法,公司现在每个月消耗的 Token 大概在 10000 亿到 12000 亿之间,分摊到员工身上,大约是每人每月 700 元。按 2024 年底约 1500 名研发技术人员来算,公司一个月在 Token 上的支出大约是 105 万元,一年最少 1200 万元。

     

    方汉认为这笔投入“太值了”。因为每月百万元左右的投入,差不多相当于 20 个员工的成本。更重要的是,实施一个月后,研发速度提升了 50% 以上,尤其是架构师和 Team Leader 这类岗位,提升最明显,几乎能达到 3 到 5 倍。

     

    金融行业要求稳、安全、合规,AI 落地没法一蹴而就。

     

    神州信息做的是银行核心软件系统。跟互联网公司不一样,金融领域对技术方案的引入持更为审慎的态度:不关心这技术有多“炫酷”,而是能否与现有技术体系实现无缝衔接。具体来说,这涵盖代码质量的可控性、复杂任务的拆解能力、功能需求的完整覆盖、需求定位的精准程度,以及与既有系统架构、开发规范和工程流程的适配程度。简言之,评判标准不仅是“能否生成代码”,更是“能否在现有系统内生成符合工程质量要求的代码”。

     

    所以 2025 年之前,神州信息试过用 AI 做文档补全、代码-文档一致性治理这些事,但那时模型能力和工具都跟不上,试下来效果不怎么样,内部结论是“还不能用在生产上”。

     

    到 2025 年前后,情况变了。大模型强了,配套工具也更完善了,神州信息又重新开始系统性地验证 AI 能力,逐步确认了 AI 技术已初步具备进入银行软件这类高可靠性要求场景的条件。

     

    那金融行业到底有没有提效?具体到一些单点环节,提效已经很明显了。以测试用例编写为例:此前单个功能模块的测试用例编写工作通常需要 5 人团队耗时一个月完成;引入 AI 辅助后,该流程已转变为 1 人审核 AI 生成结果的轻量化模式,且 AI 在异常场景覆盖方面往往表现出更优的全面性。在文档维护场景中,以往需要投入 10 人月方能完成的文档补全工作,如今借助 AI 从代码逆向生成设计文档的方式,可在 3 至 5 人月内完成,效率提升幅度达 50%以上。

     

    AI 时代的“效率悖论”:明明让人变快了,但提效却断在中间

     

    这轮“提效”风里,AI 真把人变快了,对此现在已经没人怀疑了。但一线开发者感受到的却是另一回事。

     

    有开发者对 InfoQ 形容,AI 出现之前,开发这件事其实是有节奏的。写代码、调试、验证,一步一步往前走。可到了 2025 年中,随着 AI 编程工具大规模普及,周围几乎已经没人再老老实实一行行手写代码了。AI 写代码当然更快,但人并没有因此轻松下来,反而比以前更忙了。因为“老板也懂了 AI 能提效”,预期被迅速抬高,很多原本按正常周期推进的事情,一下子都被要求更快交付结果。

     

    问题不在“快”,而在快的那一段,只发生在局部。需求还要对齐,测试还要走,联调、上线、问题处理,一样都没少,甚至因为 AI 的引入,多了一层新的复杂性。于是就出现一种很别扭的状态:编码提速了,但整体节奏没跟上,被压掉的时间,最后还是得靠人自己补上。

     

    从企业披露的数据里也能看到这种“错位”:编码这一段确实更快了,但整体提效大多仍然停留在 15%~25%。

     

    腾讯研究院特约研究员茹炳晟,对这种落差并不意外。在他看来,很多人都把“编码提速”看得太重了。

     

    在企业级研发里,真正写代码的时间,通常只占 20%~30%。剩下的大头,都在沟通、对齐、评审、测试和各种临时事务上。AI 提升的,主要是这 20%~30% 的环节,自然很难直接拉动全局。“局部的提升,我认为很容易做到。”茹炳晟说,“难的是把效率真正拉通到端到端的全流程。这对推动改进的人要求很高:你要看得清瓶颈在哪,敢不敢动流程,也要有能力做取舍。”

     

    按他的判断,至少在大型软件系统里,目前还没有看到特别显著的整体提升,尤其是那些大型、复杂、历史包袱重、同时质量要求又极高的系统,比如银行核心交易系统、工业软件等。

     

    这类系统往往一个产品就有五六百人参与维护,多的甚至达到上千人。在这样的规模下,AI 可以带来局部提速,但还很难撬动整体交付效率。

     

    也正是在这种“局部快、整体不动”的结构里,快手研发效能负责人沈浪说,他们花了一年多才摸到一个关键判断:AI 工具、个人提效和组织提效,从来不是一回事,他们自己一开始也踩过这个坑。AI 代码率上去了,看起来很不错,但回头看整体交付周期,改善其实有限。

     

    因为大公司里,从个人提效到组织提效之间常常隔着两道鸿沟:第一个是从个人到团队,你个人写代码是快了,但代码评审还得排队,测试环境也得等,这些卡点会一点点把效率吃回去;第二个是从团队到组织,就算团队交付更快了,只要需求、测试、发布这些流程还是瓶颈,整个组织的交付周期照样快不起来。(延伸阅读:“3年、1万人,快手技术团队首次系统披露AI研发范式升级历程”、“生成率从8%到60%:快手智能测试用例生成系统的四阶进化”)

     

    更麻烦的是,有些速度其实是“借”来的。茹炳晟提到,现在行业里一个很大的误区,就是太喜欢用交付速度来衡量 AI 的价值。短期看当然会更快,功能先跑通,代码先交上去,效果立刻就能看到。但这种快,往往是把代价往后挪了。

     

    AI 生成的代码,未必符合原有的架构风格,也可能把本来不该重复实现的东西又写了一遍。眼前看是提速了,后面却可能留下维护税和技术债。这些账不会当场爆出来,但会一直跟着代码和系统走,到了后续维护、变更、扩展的时候,影响才会越来越明显。

     

    什么样的企业,敢把提效直接置换成裁员?

     

    这也是为什么,那种小型、轻量的软件开发看起来 AI 提效效果最“炸”。

     

    尤其是那种由三五十人以下小团队负责的一个 IT 系统、一个小应用,系统不复杂,协作链条也短,大模型一接进去,很容易就跑出“一个人顶一个小团队”的效果。

     

    问题是,这类项目很多活得不久。可能做一年就结束了,维护压力、技术债、架构混乱这些真正的后遗症,还没来得及爆发,项目先没了。老板看到的就只剩下一件事:人可以再少一点,活照样能干完。

     

    AI 被拿来当裁员依据,往往就是从这里开始的:没做过大型复杂项目的人,最容易把 AI 神化;把软件工程误读成“写代码”的人,则最容易把小应用里的局部提效,错当成所有团队都该接受的裁员信号。

     

    但金融企业不是这样。

     

    金融行业系统本身非常复杂,AI 在代码生成环节的起效远没有外界想的那么高。像复杂账务、事务一致性、7×24 小时银行机制支撑这类代码,靠的是人长期积累下来的经验。AI 在简单查询和增删改查上当然快,但一碰到这些复杂场景,提效自然就放缓了——天花板就在那里。

     

    除此之外,合规判断、数据安全边界、监管问责时的责任承担,最终还是得由人来扛。知识传递一旦断档,系统稳定性就会受影响。所以银行不会像小企业那样,一看到 AI 快了就急着裁人。所以有金融行业技术负责人认为:把 AI 省出来的人力直接砍掉,那是危险的误判。

     

    怎么衡量开发者的生产力

     

    AI 的出现,首先放大了组织之间的差异。沈浪打了个比方:AI 像一面透镜,基础扎实的组织,长板被放得更长;本来就有问题的组织,短板也暴露得更彻底。与此同时,AI 也把个人之间的差异拉得更开了。资深工程师对需求理解深、任务拆解能力强、能识别 AI 幻觉,AI 就成了判断力的放大器;初级工程师执行速度快了,但判断失误也跟着快了。这放大了不同层级工程师之间的差距。

     

    这种差异一旦被看见,人就忍不住要比。程序员之间开始暗暗较劲,你用了多少 token,我写了多少行代码。有些是隐形的,同事间嘴上不说心里有数;有些干脆摆到明面上,成了榜单。比如 Meta 内部,有人搭了个叫 Claudeonomics 的排行榜,8.5 万名员工比谁烧的 token 多,前三名能拿徽章、头衔,甚至有人专门让 AI Agent 跑几小时任务就为了刷数据。

     

    还有那个更古老的指标——代码行数,虽然老掉牙,但从来没人真的忘了它。当 AI 把“写代码”这件事变得廉价之后,衡量一个开发者的生产力到底该看什么,成了一个更棘手的问题。

     

    “同时推进 5 个项目,现在平均一天能产出 3.7 万行代码......我最近一直在试着让软件工程师接受一件事:你们一直奉为圭臬的那句‘代码行数没意义’,到了 agentic engineering 时代,可能没那么对了。再过 5 年,你们大概不会相信自己当年真这么想过。”

     

    这其实是一个老问题。

     

    几十年来,怎么衡量开发者的生产力,在软件行业里争议不断。十年前,Martin Fowler 甚至认为,开发者的生产力是无法真正被衡量的。

     

    后来《Accelerate》问世,把软件交付拆成了几百个可测量的指标——部署频率、变更前置时间、平均恢复时间等等,行业总算有了一套相对成体系的参照系。

     

    沈浪观察到,这套框架其实一直在变。十年里,从 DORA 到 GSM 到 SPACE 到 DevEx 到 DX Core 4,表面上是度量方法在进步,背后则是“开发者是什么”这个定义在变。DORA 时代,开发者是生产线上的工人,看产出速度;SPACE 时代,开发者是有情感、需协作的多维个体;到了 AI 时代,开发者变成了与 AI 协同的决策者。

     

    如今 AI 来了之后,情况也变得更复杂了。写代码这件事也变得前所未有地快,组织自然想用新的尺子去量“AI 时代的生产力”。问题在于,这套尺子很快就走偏了——最典型的例子,就是代码行数这个早该被淘汰的指标,堂而皇之地杀了回来。

     

    代码行数之所以重新流行,原因很简单:它最容易测量,结果也最显眼。你不需要复杂的遥测系统,也不需要成熟的指标框架,只要统计一下就行。然而,低投入的改动可能写出很多行代码,高投入的改动却可能只有寥寥几行——这个指标天然就不稳定。到了 AI 时代,问题只会更严重。同样一个程序,AI 生成的代码,本就倾向于写得更“膨胀”,行数更大。

     

    但现实就是这么离谱,代码行数这个噪音极大的指标,正和 Meta 的 token 排行榜一样,成为衡量“谁更努力”的显性标尺。那么如果不看代码行数,不看 token 消耗量,那到底该看什么?

     

    旧尺子量新世界:尺子没变,刻度变了

     

    讽刺的是,DORA 和 SPACE 这类传统框架并没有被冲垮,反而在 AI 时代站得更稳了。

     

    茹炳晟认为,软件研发的本质问题没有变。人月神话里那些关于复杂度、一致性、协作、沟通的属性,并没有因为大语言模型的出现而发生任何的改变,所以度量体系的底层逻辑也就不该变。

     

    不过,他也指出,DORA 和 SPACE 的核心虽然有效,但标杆需要重新校正。其中,DORA 的四个指标——部署频率、变更前置时间、变更失败率、平均恢复时间——依然是稳定的核心选项。但基准变了。以前追求每日部署,现在 AI 让每小时部署都成为可能,原来的绝对值失去了意义。更合理的做法是:同一个团队,对比引入 AI 前后的变化——能不能在不牺牲稳定性和质量的前提下,把业务价值交付的节奏提上去。

     

    SPACE 框架的维度——满意度、绩效、活动、沟通协作、效率——同样重要,但内涵发生了根本变化。以前衡量人,现在衡量人与 AI 的协同。满意度不再只看开发者对工具满不满意,更要看他是否信任 AI 的输出、是否对代码有掌控感;效率不再是“代码写得快不快”,而是认知负担有没有减轻;沟通协作从人与人的交互,扩展到人跟 AI 的交互、甚至 Agent 与 Agent 的交互。因此,可以引入一些新指标:比如完成一个任务需要与 AI 交互多少次,需求清晰与不清晰时分别调用 AI 多少次,生成内容被采纳与被驳回的比例。

     

    代码行数不是完全没用,它可以作为过程指标,比如观察开发者的活跃度或 AI 使用频次。真正该看的,是 AI 代码采纳率、单位 token 产出,以及认知负担——高职级工程师原本并行 1.7 个项目,AI 帮忙后能升到 2.5 甚至 2.8。

     

    快手也遵循了同样的逻辑。沈浪说,他们没有抛弃 DORA,而是在它之上加了一层 AI 维度:保留交付周期和变更失败率作为质量锚点,把人均产出从“代码行”换成“交付需求数”,新增 AI 代码率(逐行比对)、L2/L3 需求占比、研发 NPS。并且摒弃了最容易被刷也更危险的的 PR 数量和提交频率。

     

    具体到代码行,正确的用法是衡量 AI 工具覆盖深度——AI 生成代码行占总代码行的比例。但用它衡量个人生产力就是错误用法。快手改用“人均有效代码行”:只算进入生产环境、通过质量门控的净增有效代码。这个数字从 134 行提升到 213 行每人天,涨幅 59%。

     

    怎么给 Agent 算时薪,怎么给人算成本

     

    前文提到的 Meta 排行榜,排名第一的人一个月烧掉 2810 亿 token,折合数百万美元。公司 30 天总消耗甚至突破了 60 万亿 token。另一个例子,Sigrid Jin,25 岁,去年 Anthropic 的榜一大哥,一年在 Claude Code 上烧掉 250 亿 token,约 17.5 万美元。

     

    很多企业都是不设限的鼓励大家使用。方汉的原话是:“token 数大多数情况比人力便宜,如果考虑开发速度的提升,就更加正向了,限制开发者合理支出没有任何意义。”

     

    方汉的观点代表了很多互联网公司的做法。而在对信息安全有严格要求的金融行业,神州信息则展现了另一种逻辑。

     

    神州信息软件工艺创新部负责人提到,出于信息安全和监管合规要求,金融行业在应用 AI 时,普遍更倾向于私有化部署,而不是直接依赖公有云。通常的做法是自建 GPU 算力集群,并将大模型部署在本地,以支撑实际业务需求。在这样的前提下,GPU 算力虽然是 AI 应用中的一项主要成本,但放到企业整体技术投入中看,该项支出占比相对有限,"属于可接受的范围"。

     

    也正因为如此,神州信息一直支持内部开发者使用 AI 工具。相比单纯控制资源消耗,他们更看重把 AI 真正用起来。神州信息软件工艺创新部负责人表示:“我们鼓励开发者积极探索 AI 能力的边界,用好了就是最有力的证明。”

     

    但不管怎么用,token 烧掉的都是真金白银。大厂工程师薪酬很高,但他消耗的 token 成本,占薪酬的比例可能非常低。你甚至会觉得,跟他靠这些 token 多做出来的事情相比,这点钱几乎可以忽略。所以大厂可以“不计代价”。小公司则完全不一样。 员工薪酬绝对值没那么高,如果某个人的 token 消耗可能都快赶上他一半工资了,那么对公司来说,token 成本是真实刺痛的成本,不能忽略。

     

    更根本的变化在于:过去算“人工小时”,现在算“token 成本”。今年 3 月阿里蔡崇信还表示,智能体本质上就是虚拟白领,是一种知识型员工。既是员工,就该算时薪——过去给人算时薪,现在也该给 Agent 算一算:它到底是不是一支高效、回报率高的劳动力?

     

    沈浪提醒,Agent 模式不能跟 L1、L2 混用同一套指标。

     

    L1 辅助形式,如 IDE 代码补全,效率单位是“人的产出”,消耗低、转化率高,基本上直接变成代码。L2 协同模式,如代码审查辅助和单测生成,中等消耗,转化率也不错,效率单位变成“团队的交付”。L3 自主模式,Agentic 任务执行消耗最高,但产出价值也最高,只是失败率也相应更高。随意问答探索价值最低,很难量化。

     

    一个开发者几分钟内就可能消耗数千美元,在 Agentic 模式下尤其常见。企业如果没有预算管理机制,很容易出现“效率提升了,但成本也失控了”的局面。

     

    另一方面,当生产力的最小单位从“人”变成了“人 + Agent 组合”,单评估“人”肯定不够,所以,目前快手探索的框架是把输入侧和输出侧分开来看。输入侧,人贡献的是需求定义、架构判断、质量审核的时间,Agent 消耗的是 Token、执行时间、工具调用次数。输出侧,看的是交付的需求数量、需求质量(一次通过率、线上 Bug 率)和交付周期。综合 ROI 就是输出价值除以人力成本加 Agent 成本。

     

    另外在场景上,标准化、可验证的活——CRUD 代码、单测生成、写文档——ROI 高。模糊、要人拍脑袋的活——复杂业务逻辑、架构决策、安全审查——用 AI 可能省下来的时间还不够验证错没错,ROI 低。

     

    最终价值是把 token 消耗和工程产出绑在一起。用掉多少 token,除以省下来的工程师工时,得到一个“token 效率比”。再折算成成本对比,看 ROI 是否为正。同时按场景和级别设预算,超了告警——不截断,但得让人心里有数。

     

    写在最后

    今年 2 月,谷歌将 AI 使用情况正式通过 GRAD 系统与员工绩效挂钩。同月,亚马逊被曝用内部系统 Clarity 追踪员工 AI 调用次数——AI 用得够不够,直接决定你能不能晋升。微软更早一步,将 AI 工具使用纳入全员绩效考核。国外三大厂殊途同归:AI 不再是可选项,而是考核的一部分。

     

    国内也不遑多让。昆仑万维从普通开发到技术线 CTO,无一豁免,AI 编程能力直接纳入绩效考核,开发效率要提升至少 50%,并与末位淘汰绑定。

     

    但我们也该明白,提效有天花板。复杂软件的地位,不会被动摇。那些动辄几百人维护的大型系统,靠的不是 Token 堆砌,是经验沉淀、是背责制度、是对稳定性的敬畏。

     

    AI 省出来的人效,目的是承接更多项目、覆盖更多场景,而不是把做事的人变少。

     

    未来,当 Token 计价器不断滚动、上下文成本不断雪球化,人类这种“看起来更慢”的大脑,会不会反而变成一种高端奢侈品?一个工程师可以花 5 个小时认真看复杂架构、深入思考问题,而不会像 AI 那样不断累积惊人的计算费用。在企业预算里,这种“慢速的人脑”,反而可能成为终极的固定成本资产。人的价值,恰恰藏在那些算不出 Token 的地方。

    ⚠️回帖抽一箱黄盖汾酒 [6 瓶装]

    ⚠️开户送五常大米,推荐朋友有红包

    ⚠️大笑脸低佣开户推荐:
    银河证券:ETF 万 0.5 免 5 [ETF,LOF ,etf 费率低,适合 etf ,打新,纳指,宽基玩家。新手必备]
    广发证券:ETF 万 0.5 免 5 [ETF,LOF ,etf 费率低,适合 etf ,打新,纳指,宽基玩家。新手必备]
    东北证券: 万 0.741 免 5 [国企券商,股票 etf 费率都很低]
    国泰海通: 万 0.8 免 5 [头部龙头券商,费率最优惠,大客户专享,综合费率最低]

    ⚠️大笑脸联系方式和最新具体券商表格清单,随时更新 www.daxiaolian.com

    18 年买的混动车,电池只有 7 度,目前里程 11 万公里,新车充满电,表显 60 公里,现在只有 48 公里,正好打八折。

    一万度电大概能跑 6 万公里,电费 3500 元,用油大概 5 毛一公里,节省 26500 元,平均一年节省 4800 元。

    目前没啥大问题,本来想换新车的,现在还是先开到报废吧,我估摸着这电池撑不了太久了。

    新注册小程序,填了邮箱,主体(企业资质)信息,管理员信息,管理员微信扫码后,提交就报 [涉嫌违规] 。页面可以提交申诉,因为不知道为啥违规,申诉原因也不知道要填什么,提交后 3 工作日就返回申诉失败。

    找到腾讯工作的好友内部咨询微信客服,给到的答复是:自查

    我于是找公司财务查,确认公司工商信息,续存状态,财税,法人征信,都是正常,企查查返会结果也是 0 风险。

    把这个信息委托好友回复给内部微信客服,给到的答复还是:自查

    于是想到是不是公司服务号在去年 7 月曾收到一次 [涉嫌诱导用户点击广告] 的违规记录,这也是仅有的一条违规记录。是不是这个违规记录引起的呢?如果是,我应该如何做?把这个疑问再次委托好友回复给内部微信客服,给到的答复依然是:自查

    没辙了。
    请教各位 V 友,有 V 友遇到申请小程序直接被告知 [涉嫌违规] 的吗?有解决的经验恳请分享一下。

    谢谢