Building AI for Women's Health: How Hertility Combined Bayesian Diagnosis and Scan Automation

想象一下，你因为月经不调或备孕困难去看医生，但医生可能只花几分钟听你描述，然后开个检查单，让你等几周甚至几个月才能拿到结果。更麻烦的是，很多女性健康问题，比如多囊卵巢综合征（PCOS）或子宫内膜异位症，症状模糊，容易被误诊或漏诊。这就是Hertility这家公司想改变的事情。他们是一家专门做女性激素健康检测的创业公司，用人工智能来帮助女性更快、更准确地了解自己的身体状况。

Hertility的核心做法是两件事：一是用贝叶斯诊断（Bayesian diagnosis）来做初步分析，二是用人工智能自动解读超声波扫描图像。贝叶斯诊断听起来很复杂，其实就是一种根据已有信息不断更新判断的方法。比如，你告诉系统你有月经不规律和长痘，系统会先根据大量女性健康数据，算出你有多大可能患有PCOS，然后你补充说你有脱发，系统就重新计算概率。每一次你提供更多症状，系统都会修正判断，而不是像传统医生那样只靠一次问诊就下结论。这种方法的优势是，它把诊断过程变成了一个动态对话，而不是一次性的“猜谜”。

第二个部分，扫描自动化，解决的是另一个实际困难。女性做盆腔超声波检查时，技师需要手动操作探头，拍摄多个角度的图像，然后由放射科医生解读。这个过程既耗时又依赖技师的经验。Hertility训练了一个人工智能模型，可以自动识别超声波图像中的卵巢、卵泡、子宫内膜等结构，并测量它们的大小和数量。比如，如果系统发现一侧卵巢有超过12个小卵泡，就提示可能有多囊卵巢。这并不意味着人工智能取代医生，而是帮助技师和医生更快地抓住关键信息，减少人为误差。

Hertility的商业模式也很有意思。他们直接面向消费者销售检测包，用户在家采集指尖血或唾液样本，寄回实验室，然后通过在线平台获得结果和解读。这种模式降低了就诊门槛，尤其适合那些因为工作忙、住得远或不好意思去医院的人。但真正让Hertility与众不同的是，他们把人工智能诊断和扫描自动化结合成一个闭环：用户先做血液检测，贝叶斯系统给出初步判断，如果需要进一步检查，系统会建议做超声波，而扫描人工智能又能自动分析图像，最终生成一份完整的报告。整个过程比传统就医快得多，而且数据更标准化。

当然，这种做法也面临挑战。一个是监管：医疗人工智能产品需要获得FDA（美国食品药品监督管理局）或类似机构的批准，证明它的诊断准确率不低于人类医生。另一个是用户信任：很多人对人工智能看病天然不信任，担心误诊。Hertility的策略是用大量真实数据训练模型，并在报告中明确标注哪些结论是人工智能生成的、哪些是医生审核过的，保持透明。

读完这篇文章，你会意识到，人工智能在医疗领域的真正价值不是替代医生，而是把那些重复、耗时、容易出错的工作自动化，比如看超声波图像或初步分析症状，从而让医生把精力集中在更复杂的决策上。对于女性健康这个长期被忽视的领域，这种技术尤其有意义，它让更多人能低成本、低门槛地获得初步诊断，而不是因为挂不上号或不好意思而一直拖着。

Speed-to-lead is a solved problem

很多公司都在拼命追求“快速联系潜在客户”，也就是销售团队常说的“速度到线索”（speed to lead）。他们相信，谁第一个联系上刚留下信息的用户，谁就能拿下这笔生意。于是，各种自动回复、即时聊天机器人被部署上去，恨不得客户刚填完表单，销售的电话就打进来了。但Intercom（一家做客户沟通软件的美国公司）在这篇文章里提出了一个反直觉的观点：速度到线索其实已经是一个被解决的问题，真正影响成交率的不是快慢，而是回复的质量和时机。

想象一下，你在一家电商网站上看中一款沙发，犹豫了一会儿，填了表单询问价格。几秒钟后，一个销售代表就打来电话，语气急促地问“您需要什么帮助？”你很可能觉得被打扰了，因为你还在浏览其他款式，根本没准备好聊天。这种“快”不仅没有促成交易，反而让客户感到压力，甚至直接挂断电话。文章指出，很多销售自动化工具只关注响应时间，却忽略了客户的状态。客户可能刚下班、在开会、或者只是随便看看，这时候的“快”反而是一种冒犯。

更关键的是，文章认为“速度到线索”这个指标本身已经过时了。过去，公司之间竞争激烈，谁先联系客户谁就占优势，因为客户的信息有限，选择也少。但现在，客户可以轻松在网上查资料、看评价、对比价格，他们往往在联系销售之前就已经做了大量功课。所以，销售团队需要转变思路：与其追求第一时间打电话，不如先了解客户的需求和意图，然后提供有针对性的信息。比如，客户在网站上看过哪些产品、停留了多久、是否下载了资料手册，这些数据比“快”更有价值。

Intercom 提出的解决方案是“基于意图的参与”（intent-based engagement）。意思是，销售系统应该根据客户的行为信号来判断什么时候联系最合适。比如，如果客户在深夜浏览网页，可能只是随便看看，那就不要半夜打电话；如果客户反复查看同一款产品的价格页面，并且下载了规格表，说明他正在认真比较，这时候可以发送一封详细的对比邮件，或者安排一个第二天上午的简短通话。这样，客户收到信息时正好是工作时间，而且内容恰好回答了他在比较时产生的疑问，成交率自然更高。

文章还举了一个具体的例子：一家SaaS公司（软件即服务公司，比如卖在线办公软件的公司）以前要求销售在客户注册试用后5分钟内打电话。结果，很多客户在电话里说“我只是想先试用一下，还没准备好聊”。后来，他们改为先发送一封个性化的欢迎邮件，附上产品使用教程，并告诉客户“如果你有任何问题，随时回复这封邮件”。结果，客户回复率大幅上升，而且主动要求电话沟通的比例也提高了。因为客户觉得没有被催促，而是得到了帮助。

所以，这篇文章的核心判断是：销售团队不应该把“快”当作唯一目标，而应该把精力放在理解客户意图、提供有价值的信息上。速度到线索已经是一个被技术解决得很好的问题，真正的增长杠杆在于“时机”和“相关性”。读完这篇文章，你会明白：在客户沟通中，时机比速度更重要，而了解客户的状态比机器自动回复更有用。下次你收到销售电话时，也可以留意一下对方是否真的了解你的需求，还是只是在机械地执行“快”的指令。

The AI Productivity Paradox

你有没有发现，身边很多人都在用AI写邮件、做总结、生成代码，但公司整体的效率好像并没有翻倍？这就是硅谷产品集团（Silicon Valley Product Group）那篇文章想讨论的核心问题：AI的生产力悖论。悖论的意思是，明明每个人都觉得AI帮自己省了时间，可公司层面的产出数字却没有明显变化。

文章举了一个很具体的场景。想象一下，你是一家电商公司的产品经理，过去你需要花三天时间分析用户数据、写一份需求文档（也就是告诉工程师要做什么功能的说明书）。现在你用AI工具，一天就写完了。省出来的两天你干嘛了呢？你可能被拉去开了更多的会，或者因为文档写得太快，老板又让你同时跟三个项目。结果是你个人确实更快了，但公司没有因为AI而多做出一个成功的功能。

问题出在哪里？文章指出，很多公司把AI当作一个“加速器”，只想着让现有工作跑得更快，却没有重新思考工作本身该怎么做。比如，以前一个设计师要花一周画三版方案，现在AI可以十分钟生成三十版。但真正有价值的工作不是“生成三十版”，而是“判断哪一版值得做”。判断需要的是对用户的理解、对商业目标的把握，这些AI帮不了忙。如果设计师把时间都花在让AI生成更多方案上，反而可能忽略了对核心问题的思考。

文章还提到一个关键概念：工作流（workflow）。工作流就是完成一件事需要经过的步骤。比如开发一个新功能，通常要经过“用户研究→需求定义→设计→开发→测试→发布”这些环节。AI可以加速其中某个环节，但如果其他环节跟不上，整体速度还是提不上去。就像一条流水线，你只升级了其中一个机器，其他机器还是老样子，整条线的产出就不会翻倍。

更隐蔽的问题是，AI可能会改变工作的性质。以前写代码的工程师，需要理解整个系统的逻辑，现在AI可以自动生成代码片段，工程师就变成了“代码审查员”，检查AI写的对不对。这本身不是坏事，但如果公司没有意识到这种变化，仍然用原来的方式考核工程师（比如按写了多少行代码），就会产生错配。工程师可能为了凑代码量，故意让AI多生成一些没用的代码。

文章最后给出的建议是，公司应该把AI当作一个“重塑工作方式”的机会，而不是“让现有工作更快”的工具。具体怎么做呢？先找出那些真正创造价值的环节，而不是那些看起来忙但其实产出不大的环节。比如，与其让AI帮你写周报，不如让AI帮你分析用户反馈中的趋势，直接告诉你用户最头疼的三个问题是什么。这样，省下来的时间才能真正用来做决策、做创新。

读完这篇文章，你会明白一个道理：AI带来的不是简单的效率提升，而是一场关于“我们到底在做什么”的重新思考。如果只是用AI把原来低效的事做得更快，那只是原地加速；真正的价值在于，用AI让那些以前做不到的事变得可能。比如，以前你只能服务一百个客户，现在AI可以帮你个性化服务一万个客户。这才是生产力提升的真正方向。

Beyond the last message: Designing for all information in Slack

你有没有在Slack（一个团队聊天软件）里遇到过这种情况：你记得上周同事在某个频道里发过一个重要文件，但你翻了几百条消息也找不到，最后只好再问一遍。Slack设计团队那篇文章就是讨论这个问题的：聊天软件里的信息太多了，怎么才能让用户找到需要的东西？

文章一开始就承认，Slack的设计初衷是“实时沟通”，也就是让消息像流水一样快速流动。但问题来了，当团队用了一年两年，频道里的消息堆积如山，你需要的可能不是最新的那条消息，而是三个月前的一条决策记录。这时候，Slack变成了一个巨大的信息仓库，但仓库没有标签，也没有索引，你只能靠记忆和搜索。

文章举了一个具体的例子：一个设计师在Slack里分享了一个设计稿的链接，然后大家在上面评论。过了两个月，新来的工程师想看看当初为什么做某个决定，他只能翻聊天记录。但评论是散落在消息里的，有的在链接下面，有的在后面的讨论里，很难拼凑出完整的决策过程。

Slack的设计团队是怎么解决这个问题的呢？他们提出了一个思路：不要只把聊天记录当作“历史的垃圾堆”，而要主动帮用户整理信息。比如，他们做了一个功能叫“画布”（Canvas），你可以把相关的消息、文件、待办事项放在一个页面里，就像一个项目的“主页”。这样，你就不用去翻聊天记录，直接看画布就能知道项目的来龙去脉。

另一个例子是“摘要”（Highlights）功能。Slack会学习你关注的话题，比如你经常在“设计”频道里发言，它就会把设计相关的关键消息推给你，而不是让你看所有消息。这有点像你订阅了一个新闻简报，只收到最重要的内容。

但文章也承认，这些功能还不够。因为信息整理这件事，光靠机器做不好。比如，画布需要有人手动更新，如果没人维护，它很快就过时了。Slack的解决方案是让画布和聊天记录联动：当你在频道里提到画布上的某个项目时，画布会自动更新相关的消息。这样既利用了机器的自动能力，又保留了人工的主动性。

读完这篇文章，你会理解一个产品设计的难题：当你的产品从“工具”变成“平台”时，用户的需求会从“怎么用”变成“怎么找”。Slack的例子告诉我们，好的设计不是让信息更多，而是让信息更容易被找到。就像你的书桌，不是堆满书就好，而是要有分类和索引，让你能快速拿到想要的那一本。对于任何使用聊天工具的人来说，这篇文章会让你重新思考：信息不是越多越好，而是越容易获取越好。

Last week in the Rosenverse: The UX identity

你有没有想过，一个职业的身份到底是什么？不是名片上的头衔，也不是工资单上的数字，而是当别人问“你是做什么的”时，你脑子里最先浮现的那几个词。对于用户体验（user experience，简称UX，就是用户使用一个产品或服务时的整体感受）这个领域的人来说，这个问题最近变得特别难回答。因为过去十年里，用户体验设计师（UX designer，负责让产品好用、让人喜欢的人）的身份一直在变。最早的时候，他们像是画图的人，专门把软件界面画得好看、把按钮放在对的位置。后来，他们变成了研究用户的人，要去观察用户怎么操作、哪里会卡住、什么让他们生气。再后来，他们又变成了策略制定者，要参与决定这个产品到底该做什么、不该做什么。每一次变化，都意味着这个职业的边界在往外扩，也意味着原来那套自我认知不再够用了。

这篇文章就是在讨论这个身份焦虑。它没有直接给答案，而是先讲了一个很具体的场景：假设你是一个用户体验设计师，你的老板突然让你去管一个跨部门的大项目，项目里涉及市场营销、工程开发、数据分析和客户支持。你心里会怎么想？你会觉得自己够格吗？还是会觉得这根本不是“设计师该干的事”？文章说，这种纠结恰恰说明，用户体验这个领域正在经历一场身份危机。它不再只是一个“画线框图的岗位”（wireframing，指画出产品每个页面的布局和功能位置），也不只是“做用户测试的岗位”（usability testing，指让真实用户试用产品并观察他们遇到的问题）。它变成了一个必须理解商业、技术、人性三样东西的混合体。但问题是，很多从业者并没有准备好，或者他们心里并不想变成那样。

文章还提到了一个很有意思的比喻：用户体验设计师就像一个“翻译官”。翻译官的工作不是自己创作内容，而是让两个说不同语言的人能互相理解。在团队里，设计师常常要翻译用户的需求给工程师听，又要翻译技术的限制给用户听，还要翻译商业目标给所有人听。这个角色听起来很光荣，但实际上非常累，因为你夹在中间，两边都可能不满意。而且，如果你翻译得不好，产品就会出问题。比如，工程师说“这个功能技术上做不到”，设计师如果直接告诉用户“我们不能做”，用户可能会觉得你们不关心他们。但如果设计师能解释“因为这个功能会拖慢整个系统，我们正在用另一种方式解决你的问题”，用户就会更容易接受。这个例子说明，用户体验设计师的真正价值，不是画图，而是沟通和协调。

最后，文章提出了一个让人思考的问题：当人工智能（AI，也就是让计算机模仿人类智能的技术）开始接管一些设计工作，比如自动生成界面布局、自动分析用户行为数据时，用户体验设计师还剩下什么？文章的观点是，那些重复性的、可被规则定义的工作确实会被取代，但“翻译”的工作，理解人类的情感、动机、矛盾，并且在商业和技术之间找到平衡，反而会变得更加重要。因为机器可以算出哪个按钮点击率最高，但机器不会知道为什么一个用户在看到某个页面时会感到委屈或兴奋。所以，用户体验设计师的身份，可能不是消失了，而是变得更像“人类行为专家”和“团队粘合剂”。这篇文章读下来，你不会得到一个明确的结论，但你会开始理解，为什么那么多做用户体验的人最近都在问自己同一个问题：我到底是谁？而这个问题本身，可能就是答案的一部分。

The Four Design Jobs AI Created (So Far)

如果你是一个设计师，最近一年你很可能听到过这句话：“AI会取代你的工作。”这句话让人紧张，但如果你仔细去看，会发现事情没有那么简单。这篇文章来自尼尔森诺曼集团（Nielsen Norman Group，一家专门研究用户体验的知名机构），它没有去预测未来，而是回头看了看过去，AI到底已经创造了哪些新的设计岗位？这些岗位不是凭空想象出来的，而是真实出现在公司里的职位。文章总结了四种。

第一种叫做“提示工程师”（prompt engineer）。你可能用过像ChatGPT这样的对话式AI，你给它一句话，它就能生成一段文字或一张图片。但你知道怎么给它那句话才能得到最好的结果吗？这里面有很大的学问。提示工程师就是专门研究“怎么跟AI说话”的人。他们要设计出最有效的提问方式，让AI输出准确、有用、不跑偏的内容。比如，如果你直接对AI说“给我写一篇关于猫的文章”，它可能会写出一篇很泛的东西。但如果你说“以一位养猫十年的主人的口吻，写一篇500字的文章，讲猫为什么喜欢钻盒子，语气要轻松幽默”，结果就会好很多。提示工程师的工作就是测试不同的说法，找到规律，然后把这些规律写成指南，让公司里其他不会用AI的人也能用好它。

第二种叫做“AI交互设计师”（AI interaction designer）。这个岗位听起来很技术，但其实它的核心是“让AI的行为变得可理解”。你有没有用过一些AI产品，完全不知道它为什么给你推荐这个东西？或者它突然做了一件让你困惑的事？AI交互设计师就是负责解决这个问题的。他们要设计出清晰的界面，告诉用户AI正在做什么、为什么这么做、接下来会做什么。比如，一个AI客服在帮你处理退款，它应该显示“我正在查询你的订单记录，大约需要30秒”，而不是突然沉默或给出一个奇怪的答案。这个岗位的人不需要会写代码，但他们需要懂一点AI的工作原理，更重要的是，他们必须非常懂人，人看到什么会放心，看到什么会焦虑。

第三种叫做“AI内容策略师”（AI content strategist）。AI生成的内容越来越多，但质量参差不齐。内容策略师的工作就是制定规则，确保AI产出的东西符合品牌调性、准确无误、不冒犯任何人。比如，一个电商网站用AI自动生成商品描述，如果AI说“这件衣服适合胖人穿”，可能会让顾客不舒服。内容策略师就要规定AI只能用“宽松版型”“适合多种身材”这样的表达。他们还要决定AI在什么情况下可以自由发挥，什么情况下必须严格按照模板来。这个岗位的人通常有写作或编辑背景，他们不直接写内容，但他们写“让AI怎么写内容”的规则。

第四种叫做“AI伦理设计师”（AI ethics designer）。这个岗位听起来很宏大，但实际工作非常具体。他们负责检查AI产品会不会对某些人群不公平，会不会泄露隐私，会不会产生有害的偏见。比如，一个招聘AI如果只学习了过去男性员工的简历，它可能会自动筛掉女性求职者。伦理设计师就要发现这个问题，并推动团队修改数据或算法。他们不是道德警察，而是像产品里的“安全检查员”，在产品上线前找出可能伤害用户的地方。

这四种岗位有一个共同点：它们都不是在取代设计师，而是在创造新的设计任务。而且，这些岗位需要的技能，理解人、沟通、创意、同理心，恰恰是机器目前最不擅长的。所以，这篇文章其实在说一个更乐观的事情：AI不会抢走你的饭碗，但它会改变饭碗的形状。你不需要学会写代码，但你需要学会跟AI合作，并且学会设计那些AI做不好的事情。对于任何一个关心自己职业未来的人来说，这篇文章提供了一个非常具体的视角：与其担心被取代，不如看看哪些新工作已经出现了，然后问自己，我能不能成为做那种工作的人？

Sonnet 5 review: I ran 64 generations to find out if it's worth it

如果你最近打开过任何一款 AI 绘图工具，比如 Midjourney 或者 DALL·E，你大概已经发现它们生成图片的速度越来越快、质量也越来越高。但背后的模型到底进步了多少，值不值得你花时间或金钱去升级，很少有人真的拿数据说话。这篇文章的作者 Lenny 做了一件很实在的事：他让同一个 AI 绘图模型的不同版本，这里说的是 Anthropic 公司出品的 Claude 系列里的 Sonnet 模型，反复生成了 64 次图片，然后仔细比较了结果。64 次听起来很多，但恰恰是因为 AI 每次生成都有随机性，单看一两张漂亮图根本说明不了问题。只有跑足够多的次数，才能看出一个模型是不是稳定地好，还是偶尔撞大运。

作者比较的核心是 Sonnet 的第四版和刚发布的第五版。他用的测试任务很具体：让模型画一只猫在太空里喝茶，背景要有星星和行星。这个场景不算难，但能考验模型对物体、空间关系和细节的把握。结果很有意思：第五版的图片在“合理度”上明显更高，猫的耳朵位置正确，茶杯不会飘在半空，星星的分布也更自然。而第四版偶尔会画出猫有三条尾巴或者茶杯倒扣在猫头上这种奇怪组合。换句话说，第五版更少犯低级错误，让用户不用反复重试就能得到可用的图。

但文章不只停留在“新版本更好”这个结论上。Lenny 还发现了一个更微妙的差别：第五版在“风格多样性”上反而有所收敛。同样一句提示词，第四版可能给出十张风格迥异的图，有的像油画，有的像卡通，有的写实。而第五版倾向于给出风格更接近的图，都偏向一种干净、明亮、略带插画感的风格。这对某些用户来说是好事，因为结果更可预测；但对那些喜欢探索不同视觉风格的人来说，反而可能觉得新版本太单调了。这个取舍很值得注意：AI 产品的进步不总是“全方面提升”，有时候是牺牲了一部分多样性来换取稳定性和准确性。

读完这篇文章，你带走的不应该只是“Sonnet 5 更好”这个结论，而是一种评估 AI 工具的方法：别只看官方展示的几张完美样图，要自己跑很多次，看看它在常见任务上是不是稳定可靠。尤其是当你用 AI 来做实际工作，比如为文章配图、设计海报原型，稳定性往往比偶尔的惊艳更重要。一个每次都给你 70 分结果的工具，比一个有时 100 分有时 30 分的工具更值得依赖。

Ambsheets 01 · A spreadsheet for exploring scenarios

想象你正在规划一家新餐厅。你要决定菜单、定价、员工数量和营业时间。每个选择都会影响其他东西：如果菜单太复杂，厨房出餐就会变慢；如果定价太低，利润可能不够付房租；如果营业时间太晚，可能需要更多夜班员工。你可能会打开电子表格，把可能的数字填进去，看看结果。但电子表格有个麻烦：它只告诉你一个数字，比如“月利润五万元”。你很难一眼看出，如果客人比预期少两成，或者食材成本突然上涨，你的餐厅会变成什么样子。

有一群研究者一直在思考这个难题。他们来自一个叫 Ink & Switch 的研究实验室，专门探索电脑还能怎么帮人思考和创造。他们发现，人们在真正做重大决定时，需要的不是精确到小数点后两位的预测，而是能快速理解“如果情况变糟会怎样”“如果情况变好会怎样”的能力。这种能力叫做“探索场景”。他们设计了一个叫 Ambsheets 的原型工具，这个词由“模糊”（ambiguous）和“表格”（sheets）合成，意思是一种故意保留不确定性的电子表格。

Ambsheets 和普通电子表格最大的区别是，它允许你在一个格子里同时填入多个可能的值。比如，你不需要在“每日客流量”这个格子里只填一个数字，比如 150 人。你可以填“100 到 200 人”，或者更具体地填“可能 100 人，也可能 200 人，最可能是 150 人”。然后，整个表格会自动计算出一系列可能的结果，而不是一个孤零零的数字。你看到的将是一个范围：在最坏情况下月利润两万元，最好情况下八万元，最可能情况是五万元。更重要的是，你可以直观地看到，是哪个因素的不确定性导致了结果的波动。

这种工具特别适合早期决策。当你要决定是否开一家新店，或者是否推出一个新功能时，你根本不可能知道准确的数字。传统电子表格会强迫你假装知道，然后给你一个虚假的精确答案。而 Ambsheets 鼓励你诚实面对自己的无知，并帮助你理解哪些未知信息是最值得先弄清楚的。比如，如果你发现利润的波动主要来自客流量，而不是菜单定价，那你就应该先花精力去调研附近的人流量，而不是纠结定价是 38 元还是 42 元。

Ink & Switch 团队把这个想法做成了几个实验版本，让真实用户试用。他们发现，人们一开始会不习惯，因为大家已经被训练成只填一个数字。但一旦习惯了输入范围、看到结果分布，很多人会感叹“这才是真实世界的样子”。一个用户说，用 Ambsheets 讨论预算时，团队不再争论“数字到底是多少”，而是开始讨论“我们愿意承担多大风险”。这改变了对话的性质，从虚假的精确变成了诚实的权衡。

当然，Ambsheets 还只是一个研究原型，不是可以下载的软件。但它提出的问题值得每个做决策的人想一想：当我们面对不确定的未来时，我们是在假装确定，还是在认真探索各种可能？我们用的工具是在帮我们看清风险，还是在帮我们忽视风险？下次你打开电子表格时，可以试着在关键格子里写一个范围，然后想想：如果这个范围是对的，我的决定会变吗？如果会变，那也许你真正需要的不是一个更精确的数字，而是一个能容纳不确定性的工具。

AI by Zapier: Add agentic AI steps to your workflows

想象你每天要做很多重复的电脑操作，比如收到一封邮件就把附件保存到网盘，或者在表格里新增一行数据就自动发一条通知。过去，Zapier 这个工具就是帮普通人把这些步骤串起来，不需要写代码。现在它推出了一个新功能，叫“AI by Zapier”，意思是你可以把人工智能也当成一个步骤，塞进你的工作流程里。

举个例子，你收到一封客户投诉邮件，以前你可能要手动判断这封邮件是愤怒、失望还是询问，然后转发给不同的人。现在你可以设置一个流程：当新邮件出现时，先让 AI 读一遍内容，判断情绪是“愤怒”还是“一般”，然后根据结果自动走不同的分支，愤怒的立刻通知经理，一般的就回复一个标准道歉模板。这个 AI 步骤本身就像一个智能开关，它不需要你训练模型，也不需要懂技术，直接在 Zapier 的界面里选一个动作，比如“用 AI 分析文本情感”或者“用 AI 提取关键信息”。

对普通用户来说，这意味着以前只有程序员才能做的自动化，现在只要你会拖拽就能完成。而且这个 AI 步骤可以跟其他几百个应用联动，比如 Google 表格、Slack、Gmail 等等。Zapier 一直以来的价值就是降低技术门槛，这次是把门槛降到了“你只需要告诉 AI 你想让它做什么”的程度。不过要注意，AI 步骤会消耗额外的计算资源，Zapier 按使用量收费，所以如果你设置了很多自动调用 AI 的流程，每个月可能要付更多钱。但如果你只是偶尔用一次，它可能比雇一个人干这些杂活便宜得多。

总的来说，这个产品让普通人也能在工作中用上 AI，而不必理解什么是大语言模型、什么是 API。它把 AI 包装成了一个像“发送邮件”一样简单的动作按钮。对于公司来说，这意味着员工可以更快地处理重复性信息工作，把时间留给更需要人的判断的事情。

What Link data tells us about AI spending

Stripe 是一家帮商家在网上收钱的公司，很多 AI 产品比如 ChatGPT、Midjourney 都用它来收用户的订阅费。Stripe 有一个叫 Link 的功能，相当于一个快速支付工具，用户填一次信用卡信息以后就不用再填了。因为 Link 记录了大量支付数据，Stripe 可以从这些数据里看出人们到底在 AI 产品上花了多少钱。

结果很有意思。2024 年，AI 公司在 Stripe 上的交易额增长非常快，尤其是一些面向普通用户的 AI 聊天工具和图像生成工具。但 Stripe 发现，很多用户并不是一次性付一年，而是按月订阅，而且取消订阅的比例也不低。这说明大家还在试用阶段，愿意掏钱，但还没形成长期习惯。另一个发现是，企业客户花的钱比个人用户多得多，一个公司可能一次就付几千美元买 AI 工具的团队版，而个人用户大多只付 20 美元左右的月费。

还有一个细节：那些卖得很贵的 AI 工具，比如每次生成图片要额外付钱的，用户反而更容易流失。因为用户一开始觉得新鲜，花了几十美元生成一堆图片，但很快发现用处不大，就不续费了。相反，那些按固定月费收费、功能扎实的工具，比如写代码助手，用户留得更久。这给 AI 公司一个启发：定价方式很重要。如果按用量收费，用户可能会因为一次好奇而花很多钱，但之后迅速离开；如果按月收固定费用，用户会觉得更可控，愿意长期使用。

Stripe 的数据还显示，AI 行业的支付成功率比传统软件低一点，意思是有些用户想付钱但支付失败了。这可能是因为很多 AI 公司是新公司，支付系统没优化好，或者用户用的信用卡被银行拒绝了。对于 AI 创业者来说，这是一个容易被忽略但很实际的问题：光有好产品不够，还得让用户顺利付钱。

总的来说，Stripe 这份数据像一张 AI 消费的体检报告。它告诉我们，AI 产品确实在赚钱，但用户还在观望，公司需要找到让用户愿意长期掏钱的方法，而不是只靠一时的好奇心。

Agency vs Ambition

你有没有遇到过这样的情况：你在一家公司工作，每天都很忙，做了很多事，但回头一看，好像都是在执行别人安排的任务，而不是在创造什么新东西？硅谷产品集团（Silicon Valley Product Group）的这篇文章，讨论的就是一个非常根本的区别，你是只有执行力（agency），还是真的有野心（ambition）。

这两个词听起来差不多，但作者用了一个很具体的场景来解释。假设你是一个产品经理，你的老板说“我们要做一个新功能，让用户能更快地导出数据”。你立刻开始画原型、写需求、协调工程师，最后功能上线了，用户也确实用上了。这是执行力，你完成了任务。但如果你问自己：用户真的需要更快导出数据吗？他们真正的麻烦是什么？有没有可能导出数据这个需求本身就不该存在？如果你开始质疑问题本身，而不是直接解决问题，那就是野心。

文章里举了一个真实的例子。Netflix 早年做 DVD 租赁时，用户抱怨“寄回的 DVD 处理太慢”。如果团队只有执行力，他们会优化仓库流程，让 DVD 更快入库。但 Netflix 的团队有野心，他们问：用户真正想要的是什么？答案是“尽快看到下一部电影”。于是他们发明了“排队系统”，让用户提前选好想看的电影，DVD 寄回后系统自动寄出下一部，用户根本不需要等。这个创新不是靠更快执行，而是靠重新定义问题。

作者 Marty Cagan 长期观察硅谷的产品团队，他发现很多公司表面上鼓励创新，实际上只奖励执行。员工被考核“完成了多少功能”“上线了多少项目”，而不是“解决了什么真正的问题”。这种文化下，大家会变得很忙，但产品却越来越平庸。因为真正的突破往往来自那些愿意花时间理解用户、挑战假设、甚至推翻自己之前工作的人。

那怎么区分自己是在执行还是真有野心呢？文章给出了几个信号。如果你做决策时，主要依据是“老板说的”“路线图定的”“同行都在做”，那你可能只是在执行。如果你做决策前，会去和用户聊、会去验证假设、会主动提出“这个问题可能不对”，那你就在展现野心。野心不是指职位高低，而是一种工作方式。

对于个人来说，这篇文章其实在提醒一件事：不要把自己的工作仅仅定位成“完成任务的工具”。即使你的职位是初级产品经理或工程师，你也可以选择有野心。比如，在接到需求时，多问一句“我们为什么要做这个？”；在开会时，主动提出“用户可能不是这么想的”。这些行为一开始可能会让同事觉得你麻烦，但长期看，这是让产品变得更好的唯一路径。

对于公司来说，如果只强调执行力，员工会变成听话的机器，公司会失去适应变化的能力。真正有竞争力的团队，是那些允许甚至鼓励员工挑战现状的团队。这篇文章最后给了一个很朴素的建议：如果你想判断一家公司值不值得去，可以看看他们开会时，是大家在讨论“怎么做”，还是也在讨论“为什么要做”。

Beyond parental leave: building a family-friendly culture at Dovetail

很多公司都说自己支持员工兼顾家庭和工作，但实际做起来，往往只是给几个月的产假，然后就默认员工可以回到原来的工作节奏。Dovetail 这家公司写了一篇文章，分享他们是怎么真正把“家庭友好”文化落实到每一天的。

Dovetail 是一家做用户研究工具的软件公司，团队不算大，但他们在福利设计上花了很多心思。文章一开头就讲了一个很具体的场景：一个刚休完产假回来的员工，第一天到公司，发现自己的会议被安排得满满的，从早到晚，完全没有时间泵奶。这不是个别现象，很多公司虽然给了产假，但员工回来后，工作安排完全没有考虑到他们正在经历的生活变化。

Dovetail 的做法是，他们不把“家庭友好”当成一个政策，而是当成一种文化。比如，他们允许员工在需要的时候随时调整工作时间，不是那种“申请审批”的弹性，而是默认你可以自己决定。一个员工可能因为孩子生病需要上午在家，下午再来公司，或者晚上再补上工作时间。他们也不要求员工必须待在办公室，只要工作完成，在哪里都行。

文章里还提到一个细节：他们公司内部有一个“家庭频道”，员工可以在里面分享自己带孩子的经验，或者临时需要帮助，比如“今天孩子突然发烧，谁能帮我去药店买退烧药？”同事看到就会主动帮忙。这听起来很小，但真正让员工感到支持的不是政策文本，而是这些日常的互助。

另一个有意思的点是，Dovetail 的领导者自己也在用这些福利。CEO 会公开说“我今天下午要提前走，去接孩子”。这个动作非常重要，因为如果领导层从来不表现出自己需要平衡家庭，员工就会觉得请假是不应该的。Dovetail 的 CEO 用行动告诉大家：家庭优先，工作可以调整。

文章还讨论了一个常见的误区：很多人觉得家庭友好就是给产假，但产假只是起点。孩子出生后的第一年、甚至更长时间，父母都需要灵活安排。而且家庭友好不只是针对有孩子的人，照顾老人、自己生病、或者任何生活上的大事，都应该被包容。

对于想学习这种文化的公司，Dovetail 的建议很简单：不要只写政策，要建立信任。信任的意思是，你相信员工会为自己的工作负责，而不是盯着他们的出勤时间。如果你总是担心员工在家会偷懒，那你永远无法建立真正的家庭友好文化。

这篇文章最后传递了一个很温暖的观念：当公司真正支持员工的家庭生活时，员工反而会更投入工作，因为他们不用在工作和家庭之间做痛苦的选择。Dovetail 用自己的实践证明，这不是一个成本，而是一种投资。

Extending Fin as the most open Agent platform

你是一家电商公司的客服主管，每天要处理几百个用户问题。你试过用聊天机器人自动回答简单问题，但效果不好，因为机器人只能按固定流程走，用户稍微说点不一样的，它就卡住了。现在出现了一种新东西：AI助手。它能听懂用户的话，自己判断怎么回答。但问题又来了：每个公司都有自己的系统，比如库存数据、订单记录、退货政策。AI助手如果不了解这些内部信息，就只能说些通用的话，等于没用。

Intercom这家公司做了个叫Fin的AI客服助手。他们最近宣布，要把Fin做成“最开放的Agent平台”。什么叫“开放”？意思是，Fin不只是Intercom自己用，其他公司也能把Fin接入自己的系统。比如一家卖鞋的电商，可以把Fin连到自己的库存数据库和退货系统。用户问“我上周买的鞋还能退吗”，Fin就去查那个订单的状态和退货政策，然后给出准确回答。

但实现这个不容易。每个公司的系统都不一样，有的用旧系统，有的用新系统，数据格式也不一样。Intercom的做法是，让Fin能通过一种通用的方式连接各种系统，就像用同一个充电器给不同手机充电。他们还提供了工具，让开发者可以自己写一点代码，把Fin和公司内部的数据源连起来。这样Fin就能访问实时信息，比如物流追踪、账户余额等。

Intercom之所以强调“最开放”，是因为很多AI助手只能在自己的平台里用，不能随便接其他系统。而Intercom希望Fin能成为“中央大脑”，帮企业把各种分散的信息整合起来。对用户来说，这意味着以后找客服时，AI能直接查到你的订单、知道你的问题，不用你重复说“我的订单号是……”。对企业来说，这意味着不需要替换现有的系统，就能用上AI客服。

当然，开放也有风险。比如数据安全：如果Fin能访问公司内部数据，那别人会不会也看到？Intercom说他们设计了严格的控制，让公司自己决定Fin能看到什么、不能看什么。另外，如果Fin接的系统太多，会不会变慢或出错？Intercom表示他们会持续优化，并提供了监控工具。

总的来说，这篇文章想说的是：AI助手要真正有用，不能关起门来自己玩，必须和现实世界的系统连接。Intercom的策略就是让Fin成为那个连接器。如果你是一家公司的老板或产品经理，读完你会明白：选AI工具时，别只看它自己有多聪明，更要看它能不能和你现有的系统合得来。否则，再聪明的AI也只是个摆设。

How to bring your work (and yourself) to internship interviews at Slack

很多人觉得面试设计实习生岗位，只要把作品集做得漂亮就行。但Slack的设计团队在招聘实习生时，更看重的是你能不能在面试中真正“带”出你的工作过程，而不是只展示最终结果。这篇文章就详细讲了他们面试实习生时的具体做法和期望。

面试一开始，Slack的设计师不会急着看你的作品集。他们更想先了解你这个人：你是怎么开始对设计感兴趣的？你平时通过什么方式学习？你遇到困难时会怎么解决？这些问题其实是在考察你有没有“设计思维”，也就是能不能把设计当成一个解决问题的过程，而不是单纯画图。比如，他们可能会问：“你最近做的项目里，哪个让你最头疼？你是怎么熬过来的？”这时候，你不需要说你的图标画得多好看，而是要说你当时遇到了什么限制（比如时间紧、技术做不到），然后你做了什么调整，最后结果怎么样。

然后才是作品展示环节。但Slack的做法跟很多公司不一样：他们不让你从头到尾讲一遍项目，而是让你挑一个你觉得“还没完全做好”的部分，现场带着面试官一起改进。这听起来有点吓人，但他们的目的不是考你，而是想看你真实的工作状态。比如，你可能会说：“这个按钮的位置我其实一直不满意，但当时时间不够就没改。”然后面试官就会跟你一起讨论：为什么觉得不好？用户可能会怎么用？有没有别的布局方案？他们甚至会拿出纸笔，让你当场画几个草图。这个过程里，他们观察的不是你的最终答案，而是你思考的路径，你会不会先问问题？会不会考虑不同用户的需求？能不能接受别人的建议并快速迭代？

最后，Slack的设计师还会问你一个很实际的问题：“如果你来Slack实习，你最想参与哪个功能？为什么？”这个问题不是为了让你猜他们想要什么答案，而是看你对Slack的产品有没有真正的理解。比如，你可能说：“我觉得Slack的搜索功能还可以更好，因为有时候我记不清文件名字，只能靠内容回忆，但搜索结果里看不到文件预览。”这样的回答说明你真的用过产品，而且有自己的观察。如果你只是说“我想做你们的新功能”，反而显得不够具体。

整篇文章读下来，你会发现Slack面试实习生时最在意的不是技术有多强，而是你有没有“设计师的思维方式”，也就是能不能从用户的角度出发，用逻辑和同理心去解决问题。他们甚至说，实习生可以没有太多经验，但一定要有好奇心，愿意学习，并且能清楚地讲出自己为什么做某个设计决定。如果你正准备面试设计岗位，这篇文章会让你重新思考：与其花时间美化作品集，不如好好练习怎么在面试中“带”出你的思考过程。

Introducing Shift 2026: A New Conference for the Future of UX

一家出版过很多经典用户体验书籍的出版社，Rosenfeld Media，最近宣布要办一场新的大会，叫 Shift 2026。大会的全称是“Shift 2026: The Future of UX”，也就是用户体验的未来。用户体验（UX）这个词你可能经常听到，它指的是一个人使用某个产品时的整体感受，比如一个App好不好用、顺不顺手、会不会让人感到困惑。过去二十年里，用户体验设计（UX design）已经从一个很新的概念变成了几乎所有数字产品公司都必须重视的岗位。设计师们研究用户怎么操作、页面怎么布局、按钮放在哪、文字怎么表达，目的是让产品既好用又让人愿意用。

但这两年，人工智能（AI）突然变得非常强大。像ChatGPT这样的对话机器人，Midjourney这样的图片生成工具，还有各种能写代码、能整理数据的AI助手，正在改变人们做事情的方式。以前设计师需要手动画很多界面草图，现在AI可以快速生成几十个版本给设计师参考。以前用户需要自己点来点去找功能，现在AI可以直接理解用户说的话然后帮用户完成操作。这些变化让整个用户体验行业都面临一个根本问题：当AI能自己做很多设计、甚至能直接和用户对话时，设计师还应该做什么？

Rosenfeld Media 办这场大会，就是想聚集行业里最有经验的人，一起讨论这个问题。大会的演讲者包括一些非常资深的设计师，比如曾经在苹果公司负责过iPhone设计的人，还有在谷歌、微软、Adobe这些大公司领导过设计团队的人。他们不是来给一个标准答案的，因为现在还没有人能确定答案。但他们可以分享各自公司正在尝试的方法，比如有的公司在用AI帮设计师做快速原型（prototype，即产品早期粗略的模型），有的公司在研究怎么让AI理解用户的情感反应，还有的公司在探索AI能不能自己发现用户需求然后自动调整产品。

这场大会的特别之处在于，它不像很多科技大会那样只展示最新的AI功能有多酷，而是把重点放在“人”身上。大会的主题是“人类中心AI”（Human-Centered AI），意思是AI技术要围绕人的真实需求来发展，而不是反过来让人去适应AI。比如，一个AI客服如果能自动识别用户生气的语气并转给真人处理，这就是人类中心AI。但如果AI客服只是机械地回复固定话术，用户越生气它越重复同样的话，那就是反人类的。Shift 2026 要探讨的正是这类问题：在AI越来越聪明的时代，如何确保技术始终服务于人，而不是让人感到被机器支配。

对于没有行业背景的读者来说，这场大会传递了一个很重要的信号：AI不是来取代设计师的，而是来改变设计师的工作方式的。就像当年电脑普及后，打字员这个职业消失了，但出现了更多需要计算机技能的新岗位。同样，未来设计师可能需要掌握新的能力，比如如何给AI下指令（prompt engineering，即编写提示词让AI生成想要的结果），如何判断AI生成的设计是否合理，以及如何设计那些AI无法替代的人类体验，比如情感共鸣、文化理解、道德判断。Rosenfeld Media 把这场大会命名为“Shift”，就是“转变”的意思，因为他们相信整个行业正在经历一个深刻的转变，而这场大会就是帮助从业者理解这个转变、并找到自己新位置的地方。

如果你对科技产品如何影响日常生活感兴趣，这场大会的讨论可能会让你意识到，AI的发展方向其实取决于我们每个人的选择。当一家公司决定用AI替代客服时，它省了钱但可能让用户更沮丧。当另一家公司用AI辅助客服时，它可能既提升了效率又保留了人情味。Shift 2026 要探讨的正是这些选择背后的原则和方法。虽然大会要到2026年才举办，但Rosenfeld Media 提前公布这个信息，其实是在邀请所有关心用户体验的人，无论是设计师、产品经理、创业者，还是普通用户，一起参与到这场关于未来的对话中来。因为最终，用户体验的好坏，影响的不仅仅是设计师的工作，更是每一个使用科技产品的人的生活质量。

The Core Skill of Design in the AI Era: Critique

Nielsen Norman Group（尼尔森诺曼集团）是一家非常权威的用户体验研究机构，它的创始人之一雅各布·尼尔森（Jakob Nielsen）是互联网可用性（usability，即产品是否容易使用）领域的奠基人。这家机构每年都会发布很多研究报告和文章，帮助设计师和产品经理理解用户行为。最近他们发了一篇文章，标题是《AI时代设计的核心技能：批判》。这个标题可能会让人有点困惑：批判？设计师不是应该创造东西吗？为什么要批判？

其实这里的“批判”不是指批评或者挑毛病，而是一种专业的审视能力。文章想表达的是，随着AI工具越来越强大，设计师可以更快地生成很多设计方案，但真正稀缺的能力变成了“判断哪个方案更好、为什么好、以及好在哪里”。举个例子，假设你让AI帮你设计一个购物App的首页，AI可能几秒钟就给出十个不同版本。有的版本把搜索框放在顶部，有的放在中间；有的用大图，有的用小图；有的促销信息很显眼，有的很克制。这时候设计师的工作就不再是亲手画这些页面，而是要从这十个版本里选出最合适的一个，或者把几个版本里好的元素组合起来。

但问题在于，AI生成的东西看起来可能都很漂亮，甚至有些版本比设计师自己做的还好看。这时候如果设计师只是凭感觉选一个最顺眼的，那很可能选错。因为好看不等于好用。比如一个页面虽然视觉上很震撼，但用户进来后找不到“加入购物车”按钮，那这个设计就是失败的。所以设计师需要具备一种能力，叫做“设计批判”（design critique），也就是能够系统性地分析一个设计方案的优缺点，考虑用户的目标、产品的商业目标、技术限制、品牌调性等等因素，然后给出合理的判断。

文章进一步指出，在AI时代，这种批判能力甚至比创造能力更重要。因为AI可以替代很多重复性的创造工作，比如画图标、排版、生成配色方案，但它无法替代人类对复杂需求的理解和权衡。比如，一个银行App的设计，既要让用户快速转账，又要确保安全，还要符合监管规定，同时不能吓到用户（比如频繁弹出安全提示）。AI可能不知道如何平衡这些互相矛盾的目标，但一个有经验的设计师可以。设计师的批判思维能帮助他识别出AI方案中哪些地方可能让用户感到不安，哪些地方可能违反法规，哪些地方虽然好看但实际使用起来很麻烦。

为了培养这种批判能力，文章建议设计师多练习“批判性回顾”（critical review），也就是定期对自己或他人的设计方案进行结构化的分析和反馈。比如，可以问自己几个问题：这个设计解决了用户的什么问题？用户在使用过程中可能会在哪里卡住？这个设计是否尊重了用户的隐私？如果不做这个设计，用户会怎样？这些问题听起来简单，但要在每个具体场景里给出扎实的答案，需要大量的实践和对用户行为的深刻理解。

对于非设计行业的读者来说，这篇文章其实揭示了一个更普遍的规律：当技术工具变得越来越智能时，人类最宝贵的技能往往不是“做得更快”，而是“判断什么值得做”。就像有了计算器之后，人们不需要再手工做复杂运算，但需要理解数学原理才能知道计算器算出的结果是否合理。同样，有了AI设计工具后，设计师不需要再亲手画每一个像素，但需要理解设计背后的原理，才能判断AI给出的方案是否真正有效。这种判断力，也就是文章所说的“批判”，将成为未来设计师的核心竞争力，也是所有与AI协作的岗位都需要重视的能力。

文章最后提到，批判不是天生的，而是可以通过刻意练习获得的。比如，可以每天花时间分析一个优秀的设计，说出它为什么好；也可以分析一个糟糕的设计，找出它为什么不好。这种练习不需要任何特殊工具，只需要一双愿意观察的眼睛和一个愿意思考的大脑。对于任何想在未来与AI共事的人来说，这可能是比学习最新AI工具更值得投入的事情。因为工具会不断更新，但判断力永远有价值。

Computer and browser use in Codex (5 real examples)

想象一下，你有一个助手，它能像人一样操作电脑：打开浏览器、点击链接、填写表格、复制粘贴文字、甚至登录网站。这不是科幻片里的场景，而是OpenAI在Codex（一个给开发者使用的AI工具）里新加入的能力，叫做“计算机和浏览器使用”。简单说，AI不再只是回答你的问题，而是能直接替你动手干活。

这篇文章用五个真实例子展示了这个能力有多强大。第一个例子是，一个开发者让AI帮他填写一份复杂的在线表单。过去，这需要开发者自己写代码来模拟人的点击和输入，但现在AI可以直接“看”到屏幕上的内容，像人一样找到输入框，然后敲字。第二个例子是，AI被要求去一个网站查找某个信息，它自己打开浏览器、输入搜索词、点进链接、滚动页面，最后把结果复制出来。整个过程不需要任何预先编写的脚本。

最让人印象深刻的例子是，AI能完成一个多步骤的工作流：先登录一个后台系统，然后下载一份报告，再打开另一个应用把报告上传，最后发送一封邮件通知同事。这一切都是AI自己决定下一步做什么，就像一个人坐在电脑前完成日常任务。当然，这些操作不是完美的，AI有时候会点错按钮，或者被验证码拦住，但它的思考方式和人非常接近：它会观察屏幕，判断哪里可以点击，然后执行。

这篇文章的核心观点是，AI正在从“聊天机器人”进化成“数字员工”。过去，AI只能处理文字，现在它能处理图形界面，也就是我们普通人每天用的软件。这意味着，很多需要人工操作的重复工作，比如数据录入、信息搜集、系统迁移，都可能被AI自动完成。对于公司来说，这能节省大量时间和人力。但同时也带来新的问题：如何确保AI操作的安全性？它会不会误操作删除重要文件？这些都需要新的设计思路来解决。读完你会明白，为什么科技公司都在抢着让AI学会“使用电脑”，因为这是让AI真正替人干活的关键一步。

Keyhive 03 · What's In a Name?

想象你正在用一个笔记软件，里面写满了你的灵感、待办事项和日记。有一天，你想把其中一篇关于“旅行计划”的笔记分享给朋友，让他也能编辑。你复制了一个链接发过去，朋友点开，却看到了一个空白页面。或者更糟，他看到了另一个完全不同的笔记。这不是网络出错了，而是笔记软件在背后用了一个“暗号”来定位你的笔记，这个暗号是一个长长的数字和字母串，比如“a1b2c3d4”。如果这个暗号不小心跟别人的笔记重复了，或者被系统错误地分配给了另一篇笔记，分享就会乱套。

Ink & Switch 实验室的“Keyhive”项目，就在研究这个看似简单却极其棘手的问题：在一个允许多人实时协作的笔记系统里，我们到底该用什么来“叫”一篇笔记？在计算机世界里，这个“名字”通常被称为标识符（identifier）。你可能会想，直接用笔记的标题不就好了？但标题会重复，比如两个人都写了“工作日志”。而且标题会变，你今天叫它“项目计划”，明天改成了“已完成项目”，那之前分享给同事的链接就失效了。所以，系统需要给每篇笔记一个内部专用的、永不改变的名字。

目前最常用的做法是给每篇笔记分配一个随机生成的、足够长到几乎不会重复的字符串，比如“f3a1b2c4d5e6...”。这就像给每个新生儿一个独一无二的身份证号。听起来很完美，对吧？但问题在于，当一群人同时编辑同一篇笔记时，每个人的电脑都在本地（local）保存了一份笔记的副本。如果两个人同时给这篇笔记起了不同的“内部名字”，或者因为网络延迟，一个人看到的名字在另一个人那里还没更新，冲突就产生了。更麻烦的是，如果这个“名字”本身也参与协作编辑，比如有人想给笔记重命名，而这个“名字”又恰好是系统用来定位笔记的钥匙，那整个系统可能就会像多米诺骨牌一样倒塌。

Keyhive 团队提出的思路是，把“名字”和“内容”彻底分开。他们设计了一种叫“内容可寻址”（content-addressing）的机制。简单说，就是不再用一个人为指定的、可能冲突的名字来定位笔记，而是用笔记内容本身计算出的一个“指纹”来定位。这个指纹，也叫哈希值（hash），就像笔记的DNA。只要笔记内容不变，指纹就永远不变。当你修改笔记时，你会得到一个新的指纹，但旧版本依然可以通过旧指纹找到。这样一来，两个人同时编辑同一篇笔记时，他们的操作会基于同一个原始指纹，系统就能智能地把两边的修改合并起来，而不是因为名字冲突而丢失数据。

这听起来有点像 Git 版本控制（一种程序员用来管理代码修改历史的工具），但 Keyhive 要把这种机制做得更轻量、更实时，适合普通人在笔记软件里无感使用。他们还在探索如何让这些“名字”既能被机器高效处理，又能被人友好地记忆和分享。比如，能不能把那个长长的哈希值转成一个短句，像“勇敢的蓝色大象”这样，既容易读，又不容易出错？

读完这篇文章，你带走的不只是一个技术知识，而是一个判断：未来那些真正好用的协作工具，很可能不再依赖一个中心服务器来分配名字，而是让每一份内容自己证明“我是谁”。这对于普通用户意味着，分享更可靠，离线也能编辑，数据真正属于自己，因为你的笔记不再被某个公司的服务器上的名字簿绑架了。

Zapier for enterprise orchestration: Scaling automation on a trusted platform

想象一下，你在一家几百人的公司上班，每天需要把客户订单从销售系统同步到财务系统，再把发货信息从仓库系统推给物流公司。以前，你可能手动复制粘贴，或者让 IT 部门写一段代码。后来有人发现了 Zapier 这个工具，它能让你把不同的软件像拼积木一样连起来，设定“当 A 发生，就自动做 B”。比如，当销售系统里出现一个新订单，Zapier 就自动在财务系统里创建一张发票。这听起来很方便，对吧？但当你所在的公司变大，客户变多，业务变得更复杂时，简单的“积木拼搭”就不够用了。你可能会遇到这样的情况：某个自动化流程突然中断了，但没人知道；或者，财务部门担心数据通过第三方工具传输是否安全；再或者，你想让一个流程同时处理几千个订单，但 Zapier 的基础版一次只能处理几个。这就是 Zapier 最近推出企业版（Enterprise）要解决的问题。

Zapier 的企业版并不是简单地把个人版功能放大。它更像是在你已有的自动化积木外面，加了一层管理、安全和监控的“外壳”。比如，企业版里有一个叫“平台信任”（Platform Trust）的部分，它解决的是大公司最头疼的安全合规问题。大公司往往有严格的 IT 政策：哪些数据可以离开公司网络，哪些软件必须经过审批，自动化流程的每一步有没有留下日志（log，也就是操作记录）。Zapier 企业版允许公司的 IT 管理员设定规则，比如“只有经过审批的自动化流程才能运行”，或者“所有涉及客户数据的流程必须加密”。这样一来，财务部门就不用担心订单数据在传输过程中被泄露，IT 部门也能随时查看谁在什么时候运行了哪个自动化任务。

另一个重要的变化是“可扩展性”（scalability），也就是当业务量暴增时，自动化系统能不能扛得住。假设你的电商公司在双十一期间订单量是平时的 100 倍，如果自动化系统处理不过来，订单就会积压，客户投诉就会涌来。Zapier 企业版承诺更高的处理上限和更稳定的性能，确保在高负载下流程不会卡住。它还提供了“错误处理”（error handling）功能：如果一个自动化步骤失败了，比如物流公司的系统暂时宕机，系统不会直接放弃，而是会重试几次，或者把失败的任务放到一个“待处理”队列里，等人来检查。这比个人版里“失败了就发一封邮件通知你”要可靠得多。

最后，Zapier 企业版还强调“编排”（orchestration），这个词听起来很技术，但可以理解为“指挥多个自动化流程协同工作”。在个人版里，你只能创建一条条独立的自动化链条，比如“A 触发 B，B 触发 C”。但在企业场景里，你可能需要多个链条并行运行，并且互相依赖。比如，当客户下单后，既要触发财务开发票，又要触发仓库备货，还要触发客服发送确认短信。而且这些链条之间可能有顺序要求：必须先开发票，才能备货；必须先备货，才能发货。企业版允许你把这些依赖关系画成一张流程图，系统会自动按顺序执行，并在某个环节卡住时及时报警。对于不熟悉编程的业务人员来说，这相当于给了他们一个可视化的“自动化指挥中心”，而不需要去写复杂的代码。

总的来说，Zapier 企业版的出现，反映了一个趋势：自动化工具正在从“个人效率神器”变成“企业基础设施”。以前，每个员工可以自己偷偷用 Zapier 省点时间；但现在，公司需要确保这些自动化流程是安全的、可控的、能应对大规模业务的。如果你是一家正在扩张的公司，当你的自动化需求从“帮我自己省 5 分钟”变成“帮整个部门省 500 小时”时，你就需要这样一套更强大的“企业级”工具了。

Analyzing the evidence that helps businesses win “product not received” disputes

你有没有在网上买过东西，结果东西没收到，于是向银行或信用卡公司发起“拒付”（dispute，也就是要求退款）？作为买家，这确实是一种保护自己的方式。但作为卖家，尤其是那些做电商的小商家，每一次拒付都意味着损失：不仅商品的钱拿不回来，还要额外支付一笔拒付处理费（通常 15 到 25 美元），更别提可能因此被支付平台标记为高风险商户。Stripe 作为一家帮助商家处理在线支付的公司，每天要处理成千上万起这样的拒付纠纷。最近，Stripe 在自己的官方博客里分享了一组数据和分析，专门针对一种最常见的拒付理由：“未收到商品”（product not received）。

Stripe 分析了大量历史纠纷数据后发现，商家能不能赢下一场“未收到商品”的纠纷，关键不在于你口头说“我发货了”，而在于你能否提供让银行信服的证据。银行和信用卡公司处理纠纷时，会像法官一样审查双方提交的证据。对于“未收到商品”这个理由，最有力的证据是什么？Stripe 的数据显示，如果商家能提供带有追踪号的物流信息，并且物流记录显示包裹已经成功签收，那么胜率会大幅提高。具体来说，提供最终配送证明（比如快递员的签收记录）的商家，赢下纠纷的概率比只提供发货证明的商家高出将近 40 个百分点。这个数字非常直观：如果你只是说“我发了”，但拿不出“对方收到了”的证据，银行很可能会偏向买家。

但事情没那么简单。Stripe 发现，即使你有物流签收记录，如果签收地址和买家在支付时填写的地址不完全一致，纠纷的胜率也会下降。比如，买家要求寄到公司地址，但快递显示签收地点是“前台”，而前台地址与买家填写的地址有细微差别，比如少了房间号，银行可能就会认为“没有送达给买家本人”。另外，如果物流信息显示“已送达”，但买家声称自己没收到，这时候商家如果能提供更详细的证据，比如包裹照片、快递员签名的电子记录，甚至买家与客服的聊天记录（其中买家承认收到了商品），胜率会更高。Stripe 甚至发现，那些主动在纠纷发生前就联系买家、确认收货情况的商家，整体纠纷率更低，而且一旦发生纠纷，胜率也更高。

Stripe 还提到了一个反直觉的发现：有时候，商家提供太多证据反而会降低胜率。比如，有些商家会提交一大堆订单截图、内部系统记录、邮件往来，但这些信息可能杂乱无章，银行的工作人员没有时间仔细梳理。Stripe 建议商家只提交最关键、最直接的证据：能证明订单确实被创建、支付成功、商品已发货、且已被签收的四份文件，按时间顺序整理好。简单清晰比堆砌信息更有效。

这篇文章对商家的实际价值在于：它把“如何打赢拒付纠纷”从一个模糊的经验，变成了有数据支撑的行动指南。如果你是一个电商卖家，下次遇到“未收到商品”的拒付，你应该立刻去做这几件事：第一，确认物流信息是否完整，特别是最终签收记录；第二，检查签收地址是否与订单地址完全一致；第三，如果地址有出入，提前准备解释材料；第四，整理一份简洁的证据包，按时间线排列。更重要的是，Stripe 的数据暗示，最好的防御是主动沟通，在发货后及时给买家发送追踪链接，并在显示“已送达”后请买家确认。这样不仅能减少纠纷，即便纠纷发生，你也有更充分的证据。

从更广的角度看，Stripe 的这篇博客也揭示了支付行业的一个现实：拒付纠纷的本质是一场证据博弈，而银行往往倾向于保护消费者。商家不能只靠“我发货了”的朴素逻辑，而要用支付平台和银行认可的证据语言来沟通。Stripe 作为中间的支付处理商，它的角色不只是“收钱”，还包括帮助商家理解这个规则，甚至通过数据分析告诉商家“哪种证据最管用”。对于没有法务团队的小商家来说，这种来自支付平台的指导，可能比找律师还实用。

The Politics of Pilot Teams

你可能听过一个词叫“试点项目”，就是公司挑一个很小的范围先试试新办法，如果效果好再推广。听起来很合理，对吧？但作者说，试点团队这件事，表面上是技术问题，实际上全是政治问题。什么意思呢？想象一下，一家传统银行想做一个新的手机银行功能，他们选了一个小团队，给这个团队最好的工程师、最新的工具，还免去了所有流程审批。这个团队很快做出了一个很酷的原型，用户测试反馈也很好。可是，当这个团队想把成果推广到全公司时，麻烦来了。

其他部门的人会说：“你们用的是特殊待遇，我们哪有那种资源？”“你们做的功能和我们现有的系统根本接不上。”“你们的产品好是好，但我们的客户不是同一批人。”这些说法听起来都有道理，但真正的原因往往是：其他团队觉得被冒犯了，或者担心自己的地位受到威胁。作者指出，试点团队的成功往往建立在“特权”之上，他们可以绕过公司通常的审批、安全、合规流程，可以调用最优秀的人，可以不受短期业绩压力。这些特权在试点阶段是必要的，但一旦要推广，就变成了别人攻击的靶子。

所以，如果你在领导一个试点项目，从一开始就要想清楚：你如何让其他团队觉得这不是对他们的否定，而是一个可以学习的机会？你如何把试点中获得的经验、代码、流程设计成可以复用的模块，而不是一个孤立的“样板间”？你如何让那些没有参与试点的关键人物，比如安全负责人、运维负责人，从一开始就参与进来，而不是等到最后才被告知？

文章里举了一个具体的例子：一家公司做了一个试点，效果非常好，但推广时发现，试点团队用的数据库版本和公司标准版本不同，导致所有现有系统都要重新适配。这个技术问题背后其实是政治问题：标准版本的决定权在另一个团队手里，而那个团队没有被提前说服。所以，真正做好一个试点项目，需要的不仅是技术和产品能力，更需要从一开始就把“推广”当作产品的一部分来设计，把各个利益相关方的诉求纳入考虑。读完后你会明白，试点成功不等于产品成功，真正的考验在于你能不能把“特例”变成“常规”。

Trading my desk for a classroom and why Dovetail supports it

有一家做用户研究工具的公司叫Dovetail，他们的一个员工决定暂时离开公司，去一所高中教一年书。公司不仅支持他，还专门写了一篇文章来解释为什么他们觉得这件事值得。你可能觉得这只是一个员工福利的故事，但仔细看，你会发现它其实在讲一个更深的问题：科技公司离真实用户太远了。作者说，很多做产品的人整天在办公室里讨论“用户需求”，但他们接触的“用户”往往是其他科技公司的白领，或者通过屏幕上的数据来想象用户。

而这位员工去教的学校，是一所低收入社区的公立高中，学生们可能没有稳定的网络、没有最新的手机、甚至每天要为吃饭发愁。在这样的环境里，你设计的产品，哪怕是一个简单的问卷工具，会面临完全不同的挑战。比如，你假设用户有稳定的网络连接，但这里的学生可能只能在图书馆蹭Wi-Fi；你假设用户有固定的邮箱，但这里的学生可能共用一部手机；你假设用户愿意花10分钟填写一份反馈，但这里的学生放学后要打工，根本没有时间。这些不是小细节，而是决定产品能不能真正被使用的关键。

Dovetail支持员工去做这件事，其实是承认了一个事实：科技公司需要走出自己的泡泡，去理解那些不被看见的用户。而且，这种理解不是靠一次用户访谈就能获得的，需要长期沉浸在那个环境里。文章里没有说大道理，只是讲了这个员工去教书后，回来会如何改进他们的产品，比如让问卷更短、更适配低端手机、支持离线填写。这些改进看起来很小，但可能让产品从一个“精英工具”变成一个“大众工具”。读完后你会觉得，一个公司愿意让员工花一年时间去理解真正的世界，这本身就是一种产品战略。

How to make the case for giving your AI Agent system access

想象你是一家公司的客服主管。你的团队每天要处理成百上千个客户问题，大部分是重复的：密码忘了、订单状态、退换货流程。你听说现在有AI客服机器人，可以自动回答这些问题，于是你买了。但很快你发现，机器人只能回答那些不需要查内部系统的问题。客户问“我的订单到哪了”，机器人说“我帮你查一下”，然后就没下文了，因为它根本进不去你们的订单系统。客户更生气了。

问题出在哪？不是AI不够聪明，而是AI没有“权限”。它像一个新来的实习生，坐在电脑前，却没有登录任何系统的账号。它能看到公开的说明书，但看不到客户的私人数据、订单记录、账户余额。所以它只能给出通用回答，没法真正解决问题。

Intercom的这篇文章，讲的就是怎么在公司内部说服别人：让AI客服机器人访问你们的内部系统。这不是技术问题，而是信任问题。你的同事会担心安全：让机器人进系统，万一它乱改数据怎么办？客户隐私泄露怎么办？系统被攻击怎么办？这些担心都很合理。

文章给出了一个实际的路径。先从最安全、影响最小的事情开始：让机器人只读数据，不能写。比如它可以查订单状态，但不能修改订单。然后给它设置明确的边界：哪些系统可以访问，哪些不能。比如客户支持系统可以，但财务系统不行。再然后，给它的每次操作都留下日志，就像给实习生配一个监督员，每一步都有记录。

更重要的是，你要让同事看到“不做”的代价。每次机器人回答不了，客户就要转人工，人工客服就要花时间查系统，客户等待时间变长，满意度下降。如果机器人能直接查系统，客户问题秒回，人工客服只处理真正复杂的问题。这个对比很直观。

文章还提到一个关键点：不要一次性开放所有权限。先挑一个最痛的问题试点，比如“查订单状态”。让机器人只访问订单系统，只读，然后看效果。如果效果好，再逐步开放其他权限。这样风险可控，也容易获得支持。

读完这篇文章，你会明白：让AI真正有用，不是靠更聪明的算法，而是靠更聪明的权限设计。AI像一个人，需要合适的工具和信任，才能发挥价值。而说服别人给AI权限，本质上是在说服大家：信任可以分步建立，风险可以控制，而收益是实实在在的。

What we’ve learned about designing for accessibility from our users

你每天用手机或电脑工作，有没有想过，那些按钮、菜单、提示信息，对视力不好、手抖、或者完全看不见屏幕的人来说，意味着什么？Slack，那个很多公司用来聊天的软件，最近分享了一篇来自他们用户的故事。这些用户不是普通用户，而是依赖辅助技术使用软件的人。辅助技术，比如屏幕阅读器，一种能把屏幕上的文字读出来的软件；或者语音输入，用说话代替打字。Slack的设计团队发现，他们自以为做得不错的地方，在实际用户面前漏洞百出。

有个用户叫詹姆斯，他完全失明，用屏幕阅读器工作。他说，Slack里最常用的功能之一，@提及某人，比如在群里喊“@张三 看一下这个文件”，对他是噩梦。因为屏幕阅读器会把整个聊天记录里的所有@都读出来，但他根本不知道哪个@是针对谁的，上下文全丢了。他只能靠猜。另一个用户玛丽，有运动障碍，手会不受控制地颤抖。她很难精准点击屏幕上很小的按钮，比如“发送”旁边的“更多选项”那个三个点的小图标。她经常误触，然后不小心删掉了整条消息。

这些故事让Slack团队意识到，无障碍设计（accessibility）不是加几个标签、调大字体那么简单。它意味着，每个功能在设计之初就要考虑：一个看不见的人怎么知道这条消息是谁发的？一个不能用手滑动屏幕的人怎么切换频道？一个阅读困难的人怎么快速找到未读消息？他们开始重新审视自己的设计流程。以前，他们可能先做普通版本，再回头修补无障碍问题。现在，他们尝试反过来：先做无障碍版本，再扩展给所有人。因为很多无障碍改进，比如清晰的对比度、大的点击区域、合理的键盘操作顺序，对普通用户也有好处。

有个很具体的例子。Slack的“快捷表情反应”，就是鼠标悬停在消息上，出现一排表情让你点，对玛丽来说很难用，因为悬停本身就需要稳定控制鼠标。团队后来加了键盘快捷键，比如按一下某个键就能弹出表情选择器。这个改动不仅帮了玛丽，也让那些不想离开键盘的快速用户更高兴。另一个例子是消息的“时间戳”。对明眼人来说，时间戳很小，放在消息右上角，不碍眼。但屏幕阅读器用户需要知道消息是今天还是昨天发的，可原来的设计把时间戳藏得太深，读出来时已经离消息内容很远了。团队重新安排了信息顺序，让屏幕阅读器先读人名和时间，再读内容，这样詹姆斯的体验就顺畅多了。

文章里有一段话很触动我。Slack的设计师说，他们曾经以为无障碍是“锦上添花”，是“对少数人的照顾”。但和用户聊完之后，他们发现，无障碍其实是“雪中送炭”，是软件能不能用的基本门槛。如果一个视障用户无法独立完成@提及，那这个功能对他来说就等于不存在。而公司里，这样的用户可能不止一个。根据世界卫生组织的数据，全球有超过十亿人带有某种形式的残疾。这些人不是小众，他们可能是你的同事、客户、朋友。

最后，Slack团队给出了一些很实在的建议。比如，不要只在测试阶段才找残障用户测试，而是从需求讨论阶段就邀请他们参与。再比如，不要只依赖自动化检测工具，因为工具只能发现技术问题，发现不了“这个流程对盲人是否合理”这样的体验问题。他们还强调，无障碍不是一次性的项目，而是每个迭代都要考虑的事情。读完整篇文章，我最大的收获是：设计一个对所有人友好的产品，不是做慈善，而是做正确的事。当你把一个原本可能被排除在外的人拉进来，你其实也在让产品变得更好。下次你使用任何软件时，可以留意一下那些小小的设计细节，它们背后可能藏着对某个人的巨大善意。

Meet the curators for Shift UX 2026

你大概率不是设计师，也不做用户体验研究。但你一定用过某个App，点过某个按钮，结果发现它完全不是你想象的样子。比如你想退订一个服务，找了半天才在一个小角落里找到“取消订阅”，点进去还要填理由，填完还要再确认一次。那一刻你心里想的是：这产品到底有没有为“我”想过？这就是用户体验（UX）要解决的问题。但UX不只是让按钮好找、颜色好看，它背后有一套完整的思考和决策过程。而每年的Shift UX大会，就是全世界最懂这件事的人聚在一起，分享他们怎么思考、怎么犯过错、又怎么找到更好办法的地方。

Rosenfeld Media刚刚公布了2026年Shift UX大会的策展人名单。策展人（curator）不是普通的主持人，他们更像是大会的“内容导演”。每个人要决定大会的议题、邀请哪些演讲者、安排什么样的活动，确保来的几千个从业者都能带走真正有用的东西。今年的大会主题是“重新连接”（Reconnect），意思是过去几年大家被远程工作、AI冲击、经济压力搞得有点散了，现在需要找回那种人与人之间、人与产品之间真实的连接感。

策展人名单里有几位很值得认识。比如Indi Young，她是用户体验研究领域的老前辈，写过好几本关于“同理心”和“思维模式”的书。她一直主张设计师应该去理解用户做决策时脑子里在想什么，而不只是看用户点了哪里。还有John Maeda，他既是设计师也是计算机科学家，曾在MIT媒体实验室工作，后来去了WordPress和eBay做设计负责人。他特别擅长把复杂的技术概念用最简单的方式讲给非技术人员听。另外还有一位叫Megan Kim的策展人，她曾在Spotify和Netflix负责产品设计，她的关注点是“设计系统”，也就是怎么让一个公司里几百个设计师用同一套语言和规则做产品，避免每个人做出来的界面像来自不同公司。

这些策展人会一起设计大会的内容。比如会有工作坊，让参会者亲手练习怎么问用户问题才能得到真实答案，而不是让用户说“挺好的”就糊弄过去。也会有案例分享，比如某家银行怎么把原本需要打客服电话才能解决的业务，改成了在App里几步就搞定，同时又不让用户觉得冷冰冰。还会有关于AI的讨论：当ChatGPT这样的工具能自动生成界面和文案时，设计师到底还有什么价值？是纯粹做“调参数的人”，还是依然要承担“理解用户真实需求”的核心角色？

如果你不是设计师，看这个名单和大会主题有什么用呢？其实很有用。因为今天几乎所有你用的产品，从微信到银行App到共享单车，背后都有UX设计师在决定你看到什么、怎么操作、操作完感觉如何。一个重视UX的公司，会让你觉得“这产品真懂我”；一个不重视的，你会觉得“这产品是不是在故意整我”。Shift UX大会的策展人名单，某种程度上就是一份“谁在真正推动产品变好”的名单。你可以把它当作一个信号：如果你关心的产品，它的团队里有参加过这类大会的人，那它大概率会越来越顺手。

最后你可能会问：为什么Rosenfeld Media要公布策展人名单？因为这家公司本身就是UX领域最权威的出版和活动机构之一。他们出的书和办的大会，几乎是全球UX从业者的必读和必去。公布策展人，等于提前告诉你：这些人的判断和选择，会定义接下来一年里全球产品设计的方向。所以这篇公告虽然看起来只是几个人名和简介，但它背后是整个行业在思考：我们怎么让技术真正服务于人，而不是反过来让人去适应技术。

Vibe Architects: Agentic Vibe Coders

想象一下，你有一个想法：想做一个帮人记录每天喝水量的App。你不会写代码，但你知道现在有AI工具可以“生成”软件。你打开一个叫“Vibe Coding”的平台，用自然语言说：“做一个App，每次用户喝完水就点一下加号，每天目标8杯，显示进度条。”几秒钟后，一个能用的App就出现在屏幕上。你甚至可以继续用对话修改：“把加号按钮改成蓝色，进度条变成圆形。”AI自动改好。这就是“Vibe Coding”，用感觉和对话来编程，而不是一行行敲代码。

但问题来了：这个App真的能用吗？比如用户不小心多点了两次，数据就错了；或者用户想查看一周的喝水记录，发现根本没有历史数据；再或者App在iPhone上看着挺好，在安卓手机上按钮全挤在一起。这些细节，Vibe Coding的初学者往往想不到。而有一类人开始出现，他们专门负责解决这些问题，他们被称为“Vibe Architects”（氛围架构师）。

Nielsen Norman Group（NN/g）是全球最权威的用户体验研究机构，他们最近发表了一篇文章，专门分析这个新角色。文章说，Vibe Architect不是程序员，也不是传统意义上的设计师，而是一个“翻译者”和“把关人”。具体来说，当一个人用Vibe Coding快速生成一个原型后，Vibe Architect会检查这个原型是否真的解决了用户的问题，是否在常见的边缘场景下依然好用，以及是否考虑了安全和隐私。比如那个喝水App，Vibe Architect会问：“如果用户一天没打开App，第二天打开时数据还在吗？”“如果用户想导出数据给医生看，能做到吗？”“如果用户是色盲，蓝色按钮能看清吗？”这些问题，Vibe Coding的AI不会主动问，但Vibe Architect会。

文章还举了一个更复杂的例子。假设一个初创公司想做一个AI客服机器人，用Vibe Coding快速搭了一个版本：用户提问，机器人自动回答。看起来很棒。但Vibe Architect会发现，当用户问“你们公司地址在哪里”时，机器人可能从网上随便抓了一个地址，而那个地址是错的。或者当用户生气地说“我要投诉”时，机器人可能只会重复“请问您有什么问题”，而不是立刻转接给真人客服。Vibe Architect需要设计一套规则：哪些问题机器人可以直接回答，哪些必须转人工；机器人回答错了怎么办；用户信息怎么安全地存储。这些都不是靠“感觉”能解决的，而是需要系统的思考和测试。

那么，Vibe Architect和传统的产品经理或用户体验设计师有什么区别？文章指出，传统角色通常是在软件已经基本定型后介入，做优化和测试。而Vibe Architect是在软件还没写出来之前，甚至在AI生成第一版的过程中，就在脑子里预演所有可能出问题的地方。他们更像是“建筑总工程师”，在施工队进场之前，就已经想好了地基承重、管道走向、消防通道。而且他们需要非常熟悉AI的能力边界：知道AI在哪些事情上特别擅长（比如生成常见界面），哪些事情上特别容易犯错（比如处理逻辑矛盾、理解隐含意图）。

这篇文章对普通读者有什么启发？第一，它提醒我们，即使AI可以“写”软件，但“设计”软件依然需要人。那个“设计”不是指画图，而是指想清楚用户会怎么用、会出什么错、怎么让用户感到安全和被尊重。第二，Vibe Architect这个角色很可能成为未来很多公司的标配。就像二十年前“网页设计师”还是一个新鲜职位，今天每个公司都有。同样，未来每个用AI快速开发产品的团队，可能都需要一个Vibe Architect来确保产品不是“看起来能用，用起来崩溃”。第三，它给了非技术人员一个机会：你不需要学会写代码，就能参与产品构建。只要你善于观察人的行为、能预判问题、有逻辑思维，你就可以成为那个“氛围架构师”。

最后，文章来自Nielsen Norman Group，这个机构由雅各布·尼尔森（Jakob Nielsen）和唐·诺曼（Don Norman）联合创立。唐·诺曼就是那本经典书《设计心理学》的作者，他最早提出了“用户体验”这个词。所以这篇文章不仅是介绍一个新职位，更是在延续一个核心观点：技术越强大，越需要有人为“人”着想。Vibe Architect就是那个在AI时代替用户操心的人。

Why a sabbatical can change everything

你有没有过那种感觉：每天的工作像是在跑步机上不停迈步，但窗外的风景从来没变过？很多人在职场里干了五六年、甚至十年后，会突然觉得自己的创意干涸了，判断力变钝了，连跟同事说话都提不起劲。这不是你一个人的问题，硅谷很多产品经理、设计师和创始人管这叫“职业倦怠”（burnout）。他们发现，光靠周末休息或者年假去海边躺几天，根本解决不了。真正能把人从这种状态里拉出来的，是一件听起来很奢侈的事：休一个长假期，英文叫“sabbatical”。

这个英文词最早来自大学里给教授的那种带薪学术假，教授可以一整个学期不用上课，专心写书或者做研究。但最近几年，科技公司里越来越多的人开始主动申请这种长假，少则一个月，多则三个月甚至半年。他们不是为了去旅游发朋友圈，而是为了彻底断开日常工作，让自己重新变成一个“普通人”。比如，一个每天要开八个会的产品总监，在长假里第一次有时间在上午十点去菜市场买菜，或者花一下午陪孩子拼乐高。这些在旁人看来微不足道的事，对长期高压工作的人来说，其实是让大脑重新学会慢下来、重新感受生活节奏的必要过程。

文章里提到一个很具体的例子：一位叫克莱尔的设计师，在连续做了四个大型产品改版后，发现自己连打开设计软件都觉得恶心。她申请了八周的长假，一开始的两周她什么都不做，就是睡觉、散步、看以前没时间看的电视剧。到第三周，她开始随手画一些跟工作毫无关系的东西，比如邻居家的猫、窗外的树。到了第六周，她突然有了一个想法，那个想法后来变成了她团队下一个产品的核心交互方式。这个故事想说明的是，创造力不是靠硬挤出来的，它需要一段什么都不想的空白期，让潜意识自己去整理那些碎片。

当然，不是每个人都有条件直接跟老板说“我要休三个月假”。文章也给出了实际的操作建议。比如，你可以先从一周的“数字断联”（digital detox）开始，把工作软件从手机里删掉，告诉同事除非真有火灾否则别找你。更可行的办法是，跟公司谈一个“无薪长假”（unpaid leave），很多中型以上的公司其实在政策里允许员工停薪留职，只是大部分人不清楚或者不敢提。关键是要提前规划：把手头的工作交接清楚，让同事知道你回来后会接手，而不是把烂摊子丢给别人。

读到这里你会发现，文章真正想说的不是“休假有多爽”，而是一个更深的判断：长期连续工作的效率其实是一种幻觉。人不是机器，不能一直保持同样的输出质量。那些最顶尖的产品团队和创始人，往往是最懂得主动打断工作节奏的人。他们知道，当你觉得所有事情都在重复、没有新想法的时候，不是你不行了，而是你的系统需要重启。休长假就是那个重启按钮。它不会让你落后，反而会让你回来之后，看得更清楚哪些事情值得做，哪些只是在原地打转。

How Mach 1 uses Zapier MCP to run AI operations across 25 different companies

想象一下，你一个人要管二十五家公司的日常运营，每家公司都有自己的客户邮件、财务账单、员工请假申请和社交媒体账号。你不可能在每个公司的电脑前都坐八个小时，那样你一天得工作两百个小时。这就是Mach 1这家公司面对的真实问题。他们是一家专门帮别人做“远程后台运营”的公司，客户从几个人的初创团队到几十个人的中型公司都有。Mach 1的团队不大，但他们接的活很杂：帮客户处理客服邮件、整理发票、更新网站内容、甚至管理招聘流程。

过去，他们的做法是让每个人手动登录不同公司的系统，比如一家公司的Gmail、另一家的Slack、第三家的QuickBooks（财务软件）。员工每天要切换十几个账号，光记住密码和找到正确的文件夹就要花掉大量时间。更糟糕的是，如果客户半夜发来一个紧急请求，值班的人必须爬起来打开电脑，手动操作一遍。Mach 1的创始人意识到，他们需要的不是雇更多人，而是让机器帮他们做那些重复的、有固定步骤的事情。

这时候，他们用上了一个叫Zapier的工具。Zapier做的事情很简单：它像一个中间人，可以把不同的软件连接起来。比如，当客户在某个表单里提交了一个问题，Zapier可以自动把这个问题的内容复制到Mach 1的客服系统里，然后自动给客户回一封邮件说“我们收到了”。整个过程不需要任何人动手。但Mach 1的需求比这个复杂得多。他们需要Zapier能理解更具体的指令，比如“如果客户是A公司的，而且问题里提到‘退款’，就把这条消息转发给财务组，同时把客户信息存到A公司的专属表格里”。

Zapier最近推出了一项叫MCP（Model Context Protocol，模型上下文协议）的新功能。这个拗口的名字可以简单理解为：它让Zapier不仅能执行简单的“如果A就B”的指令，还能跟人工智能对话，让AI帮忙判断该怎么做。Mach 1是第一批用上这个功能的公司。他们把Zapier MCP当作一个总调度员，所有客户发来的消息、新的订单、员工请假申请，都先流到这里，然后由AI判断该走哪条流程。比如，一个客户发邮件说“我的账单地址错了”，AI会先识别出这是哪个公司的客户，然后自动在对应的财务软件里找到该客户的档案，把地址改掉，最后再发一封确认邮件给客户。整个过程只要几秒钟，而且不需要任何一个人去读那封邮件。

这个案例最有意思的地方在于，它让我们看到人工智能在真实商业场景里是怎么落地的。不是那种科幻电影里的机器人，而是一个很具体的、帮人省时间的工具。Mach 1的员工现在每天的工作不再是机械地复制粘贴，而是花时间处理那些AI搞不定的复杂情况，比如客户情绪很激动的时候，或者需要跨部门协调的特殊请求。他们的创始人说，用了Zapier MCP之后，公司处理客户请求的速度快了将近三倍，而且出错率大幅下降。

读到这里，你可能会想：那Mach 1的员工会不会被AI取代？文章其实给出了一个相反的答案。因为Mach 1的生意本质是“服务”，客户付钱买的是安心和信任。AI能帮他们更快地处理标准流程，但客户真正依赖的是Mach 1的人在关键时刻的判断力和人情味。所以，Mach 1不仅没有裁员，反而因为效率提升，接下了更多客户，开始招聘那些擅长处理复杂问题和人际沟通的人。这个案例给所有做服务生意的公司一个启发：不要害怕用AI接管那些重复劳动，腾出来的时间和精力，正好可以用来做那些机器做不了、客户又最需要的事情。

Keyhive 04 · Opening the Pre-Alpha

如果你用过电脑上的钥匙串、手机里的密码管理器，或者试过和朋友共享一个网盘文件夹，你大概已经遇到过这类麻烦：你想把某个文件只给特定几个人看，但现有的工具要么全公开、要么全锁死，中间那条路几乎不存在。更麻烦的是，如果你和几个人一起维护一个共享账号或一组密钥，比如一个开源项目的管理员密码、一个家庭共享的保险箱数字，谁改过、谁看过、谁不小心删了，几乎完全不可追溯。你只能信任每个人都是小心的，但信任在软件世界里从来不是一种设计，而是一种侥幸。

Ink & Switch 这个研究实验室一直在做一件事：让普通人也能拥有安全、可控的数字协作空间，而不需要理解加密、证书、权限模型这些词。他们之前做过一个叫 Keyhive 的项目原型，这次发布的第四篇笔记，讲的是他们正在把这个原型变成一个可以让人真正上手试用的“预 Alpha”版本。预 Alpha 在软件工程里意思是最早期的可用版本，通常只有核心功能，Bug 很多，但至少能让真实用户按一按按钮，看看整个思路在实际操作中是不是走得通。

这篇笔记没有在讲技术细节，而是在讲他们做这个版本时遇到的真实取舍。比如，为了让一个人能邀请另一个人加入一个共享的密钥组，他们必须在安全与方便之间反复权衡。最安全的做法是让每个新成员都通过面对面扫描二维码或者手动输入一串很长的密钥来加入，但这样用户可能试一次就放弃了。稍微方便一点的做法是让邀请通过一个中间服务器传递，但这样一来，服务器就有可能被攻破或者被监控。他们最终选择了一种折中方案：邀请链接里包含加密后的信息，服务器只负责转发，不负责解密，这样即使服务器被黑，攻击者也看不懂邀请内容。这个选择听起来简单，但实现起来需要确保加密方式足够强，同时邀请链接又不能长得像一篇论文。

另一个有趣的细节是关于“撤销权限”。在现实世界里，如果你把一把家门钥匙给了朋友，后来不想让他进了，你只能换锁，然后重新配钥匙给所有其他需要进门的人。在数字世界里，很多系统也是这么做的：一旦你要收回某个人的访问权，就得重新生成整个密钥，然后通知所有人更新。Keyhive 想做到的是：你只需要把那个人的名字从权限列表里移除，系统会自动生成一个新的密钥，但只发给剩下的人，那个被移除的人手里的旧密钥自动失效。听起来很理想，但实现时他们发现一个问题：如何确保被移除的人不会在移除前的一瞬间偷偷复制了数据？他们最后给出的回答是：不能完全防止，但可以通过日志记录让每一次访问都有迹可循，这样如果有人违规，至少能被发现。这个回答很诚实，它承认了软件安全不是魔法，而是把风险降低到可接受的程度，同时让违规行为留下证据。

整篇笔记读下来，你会感觉到一个团队在认真对待“普通人也能安全协作”这件事。他们没有假装能做出一个完美无缺的系统，而是不断在问：一个普通用户在这里会遇到什么困惑？我们能不能让这个困惑少一点？如果做不到完美，我们能不能让出问题的时候至少知道是谁出的问题？这种务实的态度，比那些宣称“绝对安全”的产品更值得信任。读完你会明白，真正的安全不是一道锁，而是一整套让人能安心犯错、也能追溯错误的设计。

How to make pathfinder soup

假设你是一家软件公司的老板。你想做一款新功能，但不确定用户到底需不需要，也不知道技术上行不行得通。你手下的工程师说“先做几个月看看”，产品经理说“先调研一下”，市场部说“先放个广告试试”。每个人都有自己的办法，但时间、钱、人力都是有限的，你不敢随便押注。这时候，有一种做法叫“探路者（pathfinder）”。它不是原型，也不是最小可行产品（minimum viable product，即只做最核心功能去测试市场的版本），而是一种更轻量、更快速的探索方式，用最短的时间、最少的代码，去回答一个最关键的不确定问题。

比如，你的团队想做一个让用户用语音控制App的功能。你们不确定语音识别在嘈杂环境里准不准，也不确定用户愿不愿意开口说话。与其花三个月开发完整功能，不如先花一周写一个极简的“探路者”：只录制用户的语音，然后人工在后台判断它是否正确，再返回结果。这样，你们就能快速知道技术可行性（语音识别到底行不行）和用户接受度（用户会不会真的去用）。如果不行，就换个方向；如果行，再投入更多资源。这个“探路者”代码量很小，可能只有几十行，但能回答一个关键问题，帮团队避免浪费大量时间在错误的方向上。

“探路者”的关键在于：它只回答一个具体问题，而不是做一个完整功能。很多团队容易犯的错是，把探路者做得太复杂，试图一次回答所有问题，结果花了几个月才做完，失去了“快速验证”的意义。所以，做探路者之前，团队要先明确：目前最大的不确定性是什么？是技术实现难度，还是用户会不会用？然后针对这个不确定性，设计最简单的实验。比如，不确定用户是否愿意付费？那就先做一个假的“购买”按钮，点击后弹出“此功能即将上线”的提示，看看有多少人真的点了。这不需要任何支付系统，只需要一个按钮和一个计数器。

另一个常见问题是，探路者做完了，结果出来了，然后呢？文章里提到，很多团队做完探路者后，就把结果扔到一边，继续按原计划开发。这完全浪费了探路者的价值。正确的做法是：探路者的结果必须直接影响后续决策。如果结果证明想法行不通，就果断放弃；如果行得通，就根据探路者中学到的经验调整方案。比如，探路者发现用户更喜欢用文字而不是语音输入，那团队就应该把资源转向文字输入功能，而不是继续做语音。

最后，文章还提醒：探路者不是万能的。它只适用于那些“不做不知道”的问题。如果问题可以通过已有知识或简单推理回答，就不需要探路者。比如，你不需要做探路者来验证“用户是否希望App加载更快”，这几乎是肯定的。探路者的价值在于，它让团队在投入大量资源之前，用最小的成本消除最大的不确定性。读完这篇文章，你会带走一个清晰的判断：在开始任何大项目之前，先问自己“我们现在最大的不确定是什么？”然后做一个探路者去回答它。这不是偷懒，而是最聪明的做事方式。

The Purpose of Prototypes

假设你是一个产品经理，脑子里有一个新功能的想法。你把它画在纸上，或者用工具做出一个看起来能点的界面，拿给用户看。用户说“不错”，然后你回去花了三个月把它做出来。上线后，用户根本不怎么用。你哪里做错了？

问题可能出在你对“原型”的理解上。很多人以为原型就是产品的一个简化版本，用来展示“我们要做什么”。但硅谷产品集团（Silicon Valley Product Group）的文章指出，原型真正的目的不是展示，而是学习。一个原型应该是一个用来回答问题的工具，而不是一个用来展示答案的演示。

举个例子，如果你想知道用户会不会在购物流程里点击某个按钮，你不需要做一个完整的购物车系统。你只需要一个看起来能点的按钮，点完之后显示“下一步”，然后观察用户是否真的会点。如果用户犹豫了，或者点了别的地方，你就学到了东西：按钮的位置、文字或者颜色可能有问题。这个过程叫做“测试一个假设”，原型就是用来做这个测试的。

原型可以有很多种形式。最粗糙的是纸上的草图，你甚至可以用笔在纸上画几个界面，然后用手移动纸张来模拟点击。这听起来很简陋，但它的速度极快，你可以在一个下午测试十几个不同的想法。更精细一点的是可点击的线框图（wireframe），用工具把页面布局连起来，用户点击某个区域就能跳到下一个页面。再往后是高保真原型（high-fidelity prototype），看起来几乎和最终产品一样，但背后的逻辑可能只有几条。关键不在于保真度（fidelity）有多高，而在于它能不能帮你快速回答一个问题。

文章里提到一个重要的区分：原型和概念验证（proof-of-concept）不是一回事。概念验证是用来回答“这个东西技术上能不能做出来”的问题。比如你想用人工智能识别图片里的猫，你需要先写代码看看模型能不能跑通。而原型是用来回答“用户会不会用这个东西”的问题。两者都很重要，但目的不同，混在一起容易让团队陷入“技术可行但没人用”的困境。

另一个常见的误解是，原型应该一次做对。实际上，好的原型往往很丑，很粗糙，甚至故意不完整。因为如果原型太精致，用户可能会被视觉吸引，而忽略功能本身的问题。他们可能会说“这个颜色真好看”，而不是“这个按钮放在这里我不太明白”。粗糙的原型反而能逼用户关注核心逻辑。

读完这篇文章，你带走的判断应该是：下次再做一个新功能之前，先问自己“我最不确定的事情是什么”，然后做一个最简陋的东西去验证它。原型不是终点，而是通往答案的捷径。

Unreasonable experiences: why great products are no longer enough

你有没有遇到过这样的时刻：一个产品明明功能齐全、运行流畅，但你用完之后就是觉得哪里不对劲，甚至有点烦躁？比如你订了一张机票，App 上所有操作都能完成，可当你需要改签时，却要反复输入订单号、验证身份、等待人工客服，整个过程像在闯关。这就是文章开头想让你注意的事情，一个“好产品”和一次“让人舒服的体验”之间，可能隔着一条很宽的河。

文章讲了一个叫“不合理体验”（unreasonable experience）的概念。这里的“不合理”不是指产品有毛病，而是指它超出了用户原本的预期，好到让人觉得“这怎么可能”。比如你住酒店，房间干净、床铺舒服是“合理”的；但如果你入住时发现酒店已经根据你上次的偏好准备好了你爱喝的茶和枕头类型，那就是“不合理”的。这种体验不会自然发生，它需要公司刻意去设计，甚至愿意做一些在商业上看起来“不划算”的事情。

文章举了一个具体的例子：一家叫 Zappos 的卖鞋网站。它的客服团队被允许花很长时间跟顾客聊天，哪怕顾客最后什么都没买。有一次，一个客服跟一位顾客聊了整整 6 个小时，内容从鞋子变成了生活琐事。这听起来像是浪费人力，但 Zappos 认为这种“不合理”的关怀最终会让人记住它，并在未来需要买鞋时第一个想到它。这个例子说明，所谓的不合理体验，往往就是公司愿意在用户身上花“多余”的时间、精力或钱，而这些投入在传统财务模型里是找不到回报公式的。

那么，为什么现在“好产品”不够用了？文章给出的理由是：技术普及让产品本身越来越难做出本质差异。你的竞品也能做同样的功能、用同样的技术栈（也就是背后那套软件和硬件的组合），甚至抄走你的界面设计。当产品本身拉不开差距时，用户就会根据“用起来爽不爽”来做选择。而“爽”往往来自那些产品之外的小细节：比如你退出一个应用时，它记住了你上次看到的位置；比如你打电话给客服，对方直接叫出了你的名字并知道你之前遇到的问题。这些细节很难规模化，但恰恰是它们构成了用户心中的“不合理体验”。

文章还提醒，不要误解为只有砸钱才能制造不合理体验。有时候它只是需要公司换一种思考方式：从“我们提供什么”变成“用户在这个场景里真正需要什么”。比如一个银行 App 如果只是功能齐全，用户可能觉得理所当然；但如果它在用户转账失败时，不是抛出一个错误代码，而是主动提示“你可能是输错了卡号，要不要检查一下第 8 位数字”，这就变成了一个不合理体验。这种改进不需要巨额预算，只需要产品团队（也就是设计这个 App 的人）真正站在用户的角度，去模拟那些让人卡住的瞬间。

读完整篇文章，你能带走一个很清晰的判断：在功能越来越难以成为护城河的今天，真正能让用户留下来的，往往是那些“没必要做但做了”的事情。这些事看起来不合理，因为它们不直接对应销量或转化率（也就是有多少人看完后买了东西），但它们会在用户心里种下一个印象，这个地方懂我。而一旦这种印象形成，用户就很难再被竞品简单的功能升级拉走了。

Conversation design: How to make your AI Agent communicate like your team

你打电话给客服，对方接起来，语气熟悉，知道你的名字，知道你为什么打来，甚至知道你已经试过哪些办法。你几乎以为自己打给了同一个客服代表。但对面其实是一个人工智能（AI）程序，它只是被设计成听起来像你认识的那个人。Intercom 这篇博客讲的就是这种设计思路：怎么让 AI 代理（AI agent，也就是能自动跟人对话的软件）说话的方式跟你的团队一模一样。

很多公司做 AI 客服，第一反应是让它“像人”，但“像人”太模糊了。真正的问题是：你的客户已经习惯了跟你的某几个同事说话，他们知道那个同事说话慢、爱用表情符号、还是直接给方案。如果 AI 突然用另一种语气，客户会立刻觉得不对。Intercom 举了一个例子：一家公司有两位客服，一个叫 Harry 一个叫 Sally，风格完全不同。Harry 话少、直接给步骤，Sally 话多、先问心情。如果 AI 代理随机切换风格，客户会困惑：到底是谁在跟我说话？所以 Intercom 建议，先定义好你团队的“声音”，然后让 AI 只模仿那一种。

具体怎么做到呢？文章里提到几个落地动作。第一，给 AI 写一个“角色卡”（persona card），就像给演员写人物小传一样。里面写清楚：这个 AI 代表谁，它应该用“我们”还是“我”，它能不能开玩笑，它遇到不知道的事情怎么回答。第二，把真实客服的对话记录拿给 AI 学习，但不是学所有话，而是挑出那些客户反馈好的回答。第三，设计“回退”机制：如果 AI 发现自己搞不定，应该怎么把对话转给真人，并且转的时候要把刚才说了什么一起带过去，客户不用重复。

这里有一个关键转折。很多公司担心 AI 太像人会引起反感，所以故意让它显得“机械”。但 Intercom 认为，用户反感的不是像人，而是“假”。如果 AI 明明不懂却假装懂，用户才生气。如果 AI 诚实地表明身份，同时用团队熟悉的语气说话，用户反而觉得顺畅。文章里提到一个数字：经过对话设计（conversation design，即专门设计对话流程和语言风格的工作）的 AI 代理，问题解决率比没设计的版本高出不少。

最后，Intercom 提醒了一个容易被忽略的事：AI 不只在回答问题时需要设计，在它“不说话”的时候也需要。比如，当 AI 正在查资料，它应该沉默还是说一句“让我查一下”？如果客户等了五秒没回应，会不会挂断？这些沉默间隙的设计，同样影响体验。读完这篇文章，你带走的不只是“让 AI 像人”这个口号，而是一套具体动作：写角色卡、挑好对话样本、设计转接流程、注意沉默。下次你再遇到一个客服 AI，可以留意一下它有没有让你觉得“这公司的人说话就这味儿”。

How we design for admin experiences: baking good content into the process

你有没有试过在某个工作软件里当管理员？比如给团队加新人、设置权限、调整通知规则，结果发现界面里全是密密麻麻的开关和下拉菜单，每个选项旁边就一行干巴巴的技术术语。你根本不知道按下去会发生什么，只好硬着头皮猜，猜错了还得回头改。Slack 的设计团队发现，很多企业软件的管理后台就是这个样子，他们把这种体验叫做“管理员困境”。

Slack 的设计师们开始思考一个很实际的问题：为什么不能把“解释”直接揉进操作流程里？他们举了一个很具体的例子。以前，当管理员要关闭某个频道的“通知”功能时，界面上只有一个开关和一行字“禁用通知”。管理员关掉之后，团队成员可能再也收不到重要提醒，但管理员自己并不知道后果。后来 Slack 改了设计：当你准备关掉通知时，旁边会立刻弹出一段话，告诉你“关闭后，该频道的成员将不会收到任何新消息提醒，除非他们手动开启”。这段话不是藏在帮助文档里，也不是鼠标悬停才出现的小气泡，它就写在开关旁边，在你做决定的那个瞬间出现。

这种把内容“烘焙”进流程的做法，听起来简单，但做起来不容易。Slack 的设计团队花了很多功夫去研究管理员在真实工作中会遇到什么场景。比如一个团队负责人想把某个频道设为“仅限特定成员发消息”，他可能不是要限制谁说话，而是怕新人不小心在全员频道里发错消息。如果界面只给他一个“限制发帖”的选项，他可能就选错了。Slack 的做法是在这个选项下面加一句话：“开启后，只有你指定的成员可以在此频道发消息，其他人只能阅读。适合用于公告频道。”这样一来，管理员看到的不再是一个冷冰冰的功能开关，而是一个有上下文、有后果、有建议的决策辅助。

Slack 团队还分享了一个很重要的原则：不要一次性把所有信息都堆给管理员。他们观察到，很多管理员在第一次设置某个功能时，其实只需要知道“这个功能是干什么的”和“我点下去会发生什么”。至于更高级的配置，比如“通知时间段的精细调整”或者“与第三方工具的联动规则”，可以放在后续步骤里，等管理员熟悉了基础操作再展示。这就像教一个人做饭，第一次只告诉他“盐是咸的，放一小勺就行”，而不是同时讲解盐、糖、酱油、醋的全部用法。

Slack 的设计师们还意识到，管理员并不总是技术专家。很多团队的管理员其实是项目经理、人事专员或者团队里的热心同事，他们被临时拉来管工具，对技术细节没兴趣也没时间研究。所以，Slack 在写那些帮助文字时，刻意避免使用“部署”“防火墙”“API”之类的词，而是用“设置”“限制”“允许”这类日常语言。比如，他们不会说“配置频道访问控制列表”，而是说“选择哪些人可以看到这个频道”。

读到这里，你可能会想：这不就是写清楚说明书吗？但 Slack 的经验告诉我们，真正的难点不在于写不写，而在于“在什么时候写”和“写多少”。如果所有解释都堆在一个单独的“帮助”页面里，管理员根本不会去看。如果每个选项旁边都塞满长篇大论，界面又会变得臃肿。Slack 的做法是把最关键的一句话放在用户最需要它的地方，也就是用户的手正要点击的那个瞬间。

这篇文章给我们带来的启发是：好的产品设计不只是把按钮摆对位置，还要理解用户在做决策时心里在犹豫什么、害怕什么。管理员不敢随便点一个开关，是因为他不知道后果。如果你能在他犹豫的那一刻，用一句话消除他的不安，他就能更快、更自信地完成工作。对于任何做产品的人来说，这都是一种值得借鉴的思路：把内容当成设计的一部分，而不是事后补上的说明书。

What Will the Future of UX Actually Look Like? An Interview with Shift UX Curator, Stefanie Hutka

你有没有想过，那些每天打开的App、网站、甚至智能家电，它们的界面和操作方式是怎么被设计出来的？背后有一群人叫用户体验设计师，他们的工作就是让你用起来顺手、不困惑。但这份工作本身也在快速变化。这篇文章采访了Shift UX的策展人Stefanie Hutka，聊的是用户体验（UX）这个行业未来会变成什么样。

Hutka提到一个很实在的变化：过去设计师只要把界面画得好看、交互逻辑通顺就行，但现在公司越来越要求设计师能证明自己的设计带来了商业价值。比如，一个购物App的结账按钮从红色改成绿色，设计师不光要说“绿色更让人安心”，还得拿出数据说“改版后完成购买的人多了百分之几”。这意味着设计师需要懂一点数据分析，甚至要参与早期的产品策略讨论，而不是等到产品快做完了才被叫来“美化一下”。

另一个趋势是工具和技术的快速迭代。以前设计师主要用Sketch或者Adobe系列软件画图，现在像Figma这样的协作工具让整个团队能同时在线修改设计稿，产品经理、工程师都能直接在上面提意见。Hutka认为，未来设计师需要更熟悉代码的基础逻辑，哪怕不亲自写代码，也要知道什么样的设计在技术上是可行的、什么样的会很难实现。这就像室内设计师需要了解水电布线一样，不是要自己拉电线，但不能画一个根本装不出来的吊灯。

还有一个重要话题是包容性设计。过去很多产品默认服务的是“典型用户”，年轻、视力好、手指灵活、网络流畅。但Hutka指出，未来的UX必须考虑更多样化的人群，比如老年人、视力障碍者、临时网络不稳定的人。这不仅仅是“做好事”，而是巨大的市场机会。全球有超过十亿人存在某种残疾，如果产品从一开始就考虑他们的需求，反而能做出更简洁、更通用的界面。比如，为盲人做的语音导航，最终也让开车的人更方便。

Hutka还谈到，用户体验设计不再只是“屏幕上的事”。智能音箱、汽车仪表盘、甚至医院的挂号机，都涉及交互设计。未来的设计师可能要同时设计声音、手势、甚至触觉反馈。比如，你用手势关灯，系统需要给你一个轻微的震动确认，而不是靠屏幕显示。这些跨感官的设计挑战，会让UX这个职业变得越来越跨学科。

读完这篇文章你会感受到，用户体验设计正在从“美化界面”变成“设计整个服务流程”。设计师不再只是画图的，而是需要理解商业、技术、用户心理，还要能跟不同部门的人吵架和协作。如果你正考虑进入这个行业，或者只是好奇为什么有些产品用起来特别顺、有些却让人抓狂，这篇文章能帮你看到这个职业背后的真实变化。

Incentive Structures for Diary Studies

你有没有被邀请填过那种连续几天的使用日记？比如，产品公司让你每天记录什么时候打开了他们的App、当时在做什么、心情怎么样。这种研究方法在用户体验领域叫“日记研究”，目的是了解人们在真实生活中怎么使用产品，而不是在实验室里被观察。但有一个很实际的问题：用户凭什么要花时间每天认真记录？这篇文章就专门讨论这个，日记研究里的激励结构。

文章首先点出一个常见误区：很多人觉得只要给钱就行了。但实际经验表明，现金奖励虽然直接，却可能带来问题。比如，如果用户只是冲着钱来，他们可能会敷衍了事，随便写几个字应付，甚至编造内容。更糟糕的是，一旦你中途停止支付，用户会立刻放弃。所以，单纯靠钱并不能保证高质量的数据。

那什么样的激励更有效？文章提到几个关键原则。第一，激励要跟任务难度匹配。如果每天只需要花两分钟填一个简单表格，给一张小礼品卡就够了；但如果要求用户每天写一段详细文字、拍照或者录视频，那奖励就得明显更高，比如每周抽送一个价值较高的奖品。第二，激励的形式可以多样化。除了现金和礼品卡，还可以考虑积分、折扣、或者产品内的高级功能。比如，一个健身App可以给参与日记研究的用户免费解锁一个月的付费课程，这样既省钱又能让用户感觉被重视。

文章还强调了一个容易被忽略的点：非金钱激励同样重要。比如，在招募用户时明确告诉他们“你的反馈会直接影响产品改进”，并且后续真的把改进结果分享给他们看，这种参与感和成就感往往比几块钱更让人愿意认真记录。另外，在日记研究过程中，定期给用户发送鼓励消息、或者展示其他参与者的有趣回答，也能保持他们的积极性。

最后，文章提醒了一个常见陷阱：不要只依赖一种激励方式。最好是现金、礼品卡、产品福利、社交认可混着用，并且根据用户群体的特点调整。比如，针对大学生，礼品卡可能比现金更受欢迎；针对职场人士，高价值抽奖可能更有吸引力。

这篇文章虽然讲的是研究方法，但背后的道理对任何需要用户参与的场景都适用：想让别人认真帮你做事，光给钱不够，还要让他们觉得被尊重、有参与感、并且看到自己的贡献产生了实际影响。如果你曾经填过那种半途而废的问卷，或者设计过类似活动但效果不佳，这篇文章能帮你理解问题出在哪里。

How the founder of Morning Brew built a Claude content machine that never runs out of ideas and never sounds like slop | Alex Lieberman

想象你每天早上打开一封邮件，里面是几条精心挑选的商业新闻，语言轻松，读起来像朋友在聊天。这就是 Morning Brew，一家从大学宿舍起步的媒体公司，后来以超过 7500 万美元的价格被收购。它的创始人 Alex Lieberman 现在又做了一个新东西：一个完全由 AI 驱动的“内容机器”，专门帮人持续产出有观点、不套路的商业内容。

大多数用 AI 写东西的人都有个共同的烦恼：AI 确实能写，但写出来的东西往往很“滑”（slop），就是那种读起来正确但毫无灵魂的流水账。Alex 的团队花了很长时间琢磨怎么让 AI 既不缺创意，又不说废话。他们最后做了一套系统，核心是让 AI 先“想”再“写”，而不是直接出稿。

这套系统里有一个很聪明的设计：AI 每天会从几百篇商业新闻里自动抓取最有话题性的素材，然后不是直接生成文章，而是先产出一份“内部简报”。这份简报里只有标题、关键数据和一两个让人意外的角度。人类编辑再从中挑选最有潜力的点子，给 AI 一个简单的提示，比如“用创业者视角写一篇关于 AI 如何改变招聘的文章”。AI 接着会生成一个初稿，但不是最终版本，而是一个“骨架”，有观点、有例子、有转折，但语言还很粗糙。人类编辑再花几分钟调整语气、加入个人经历或行业八卦，让文章听起来像真人写的。

这个流程的关键在于，AI 负责“永远不空想”，它每天有固定的输入源和筛选规则，所以不会跑偏。而人负责“永远不无聊”，在 AI 的骨架上添加血肉。Alex 说，他们用 AI 不是为了省掉人，而是为了让人的精力可以集中在最值钱的地方：判断什么值得说，以及怎么说才有趣。

最终的结果是，这套系统可以每天稳定产出好几篇高质量的商业解读，而且每篇都有明显的个人风格。读者不会觉得是机器写的，因为语气、用词和例子都是人选的。对于任何想靠内容建立品牌的人来说，这是一个很实际的参考：不是用 AI 替代人，而是用 AI 帮人节省“找素材”和“写草稿”的时间，把人的创造力解放出来做真正重要的判断。

Keyhive 05 · Syncing Keyhive

你有没有想过，当你在手机上写了一条笔记，几分钟后在电脑上打开，它已经自动出现了？这背后藏着一个不怎么浪漫的秘密：同步。

大多数人以为同步就是“复制一份过去”，但现实要麻烦得多。想象一下，你和你朋友各拿一支笔，在同一张纸上写东西。你写“今天天气好”，他写“今天下雨了”。如果你们写在不同位置，把两张纸叠在一起看还能凑合。但如果你们在同一位置写了不同的字，那叠在一起就变成一团乱。数字世界的同步就是这种“叠纸”的过程，只不过纸是看不见的，而且可能同时有几十个人在写。

Keyhive 是一个专门帮多人应用做同步的底层工具。它不关心你写的是笔记、待办事项还是聊天记录，它只关心一件事：让所有参与者的数据最终变得一模一样，而且不丢失任何人的修改。这听起来像是一个简单问题，但实际做起来非常棘手。因为网络会断，设备会关机，两个人可能在同一时刻修改了同一个东西。

Keyhive 的做法有点像给每个数据块贴一个“家族树”标签。每次修改都记录它来自哪个旧版本，就像族谱里谁是谁的孩子。这样，即使两个人在离线时各自改了同一份数据，当他们重新联网时，系统可以沿着家族树找到共同的祖先，然后决定怎么合并。合并的规则有很多种，Keyhive 选了一种叫“最后写入者获胜”（last-writer-wins）的策略：如果两个人同时改了同一个字段，就看谁的修改时间更晚，晚的那个覆盖早的那个。这听起来有点粗暴，但好处是简单可靠，而且大多数应用场景下用户不会同时改同一个字段。

但同步不只是合并冲突这么简单。Keyhive 还要解决一个更实际的问题：性能。如果一份文档有几千条修改记录，每次同步都要把整个历史重新算一遍，那速度会慢得让人抓狂。所以 Keyhive 采用了一种叫“状态向量”（state vector）的技巧。每个参与者都维护一个“我见过哪些版本”的清单。同步时，双方先交换这个清单，然后只发送对方没有的版本。这就像你和朋友交换邮票：你不需要把整本集邮册都给他，只需要给他缺的那几张。

Keyhive 的另一个设计亮点是“可插拔的存储后端”（pluggable storage backend）。意思是，它不规定你的数据存在哪里。你可以存在本地文件里，也可以存在云端服务器上，甚至可以存在别人的电脑上。这让 Keyhive 非常适合那些对隐私敏感的应用，用户的数据可以只存在自己的设备上，不需要经过任何中央服务器。

不过，Keyhive 目前还只是一个研究项目，没有变成可以直接下载的软件库。它的价值更多在于探索一种新的同步思路：让同步变得像本地操作一样快，同时保留离线工作的能力。对于普通用户来说，这意味着未来的笔记应用、协作工具可能会更流畅、更私密，不再需要每次打开应用都等那个“正在同步”的转圈动画。

读完这篇文章，你会明白一件事：你每天使用的那些“自动同步”功能，背后是一群工程师花了好几年时间，绞尽脑汁解决“两个人同时写同一行字”这种看似简单的问题。而 Keyhive 给出的答案，不是更聪明的算法，而是一套更务实的取舍，在正确性、速度和简单性之间找到一个平衡点。

Human Strategy In An AI-Accelerated Workflow

这几年，几乎每个用电脑工作的人都被“AI（人工智能）”这个词包围了。打开任何一个办公软件，里面都藏着能写文案、做表格、生成图片的AI助手。很多人开始担心：AI会不会取代我的工作？但如果你真的走进一家公司，去看看那些最忙的团队在干什么，你会发现，真正的瓶颈往往不是写东西或画图的速度，而是“大家到底该做什么”这件事本身。

这篇文章就从这个角度切入，讨论了一个很实际的问题：当一个团队已经把AI用得很顺，写代码、做设计、写邮件都变快了好几倍之后，真正让项目卡住的反而是人的决策、沟通和判断。比如一个设计师用AI十分钟生成了十版方案，但他不知道哪一版符合产品方向；一个产品经理用AI写完了需求文档，但团队开会时发现大家对“用户到底需要什么”的理解完全不一样。AI把“做”这个环节压缩到了几乎可以忽略不计，但“想清楚做什么”和“大家同意这么做”的时间一点都没少。

文章里举了一个具体的例子，是一家做电商的公司。他们的设计团队用AI做了几百张广告图，每张都精美得可以拿奖。但上线之后发现转化率（就是看到广告后真正下单的顾客比例）反而下降了。为什么？因为AI生成的图虽然好看，但并没有突出顾客最关心的东西，比如价格、优惠、商品用途。设计师们花了大量时间在“做图”这个动作上，却没花足够时间跟营销团队确认“这张图到底要传达什么信息”。AI加速了执行，却放大了团队协作中的信息断层。

这篇文章提出的核心观点是：在AI加速的工作流里，人的战略能力反而变得更重要了。所谓“战略能力”，不是指高高在上的商业计划，而是指一个人能不能在混乱的信息中判断出什么最重要，能不能把不同部门的同事拉到同一页纸上，能不能在AI给了十个选项后快速做出取舍。这些能力以前也被强调，但AI把执行速度提到极致之后，这些能力的短板就变得格外刺眼。

文章还讲了一个很形象的比喻。它说，以前的工作流像一条流水线，每个人负责一个环节，上一个环节做完交给下一个。AI来了之后，流水线的传送带突然加速了十倍，但每个工位上的工人如果还是按照原来的节奏思考和交接，传送带上就会堆满半成品，到处是没人能处理的零件。这时候最需要的不是让传送带更快，而是重新设计整个流水线的布局，甚至改变每个工人的角色。

对于普通读者来说，这篇文章最有价值的地方在于它提醒我们：不要只盯着AI能帮你多快写完一篇文章或画完一张图，更要关注那些AI没法替你做的事，比如理解一个同事为什么生气，比如从一堆数据里找到真正重要的那一个，比如在团队争论时提出一个让大家都能接受的方案。这些事看起来“慢”，但恰恰是决定一个项目成败的关键。

读完之后你会带走一个很实在的判断：AI时代，最值钱的能力不是操作AI的技巧，而是那些在AI出现之前就已经稀缺的能力，判断力、沟通力和决策力。工具越快，这些能力就越值得你花时间去打磨。

Relay.app is shutting down: How to export your workflows and move to Zapier

如果你平时需要把不同的软件连起来自动干活，比如当收到一封带附件的邮件时自动把附件存到网盘，或者当表格里新增一行数据时自动发一条消息到群里，那你很可能听说过Zapier这个名字。Zapier是一个自动化工具，它像一根根数据管道，把各种软件（比如邮箱、表格、聊天软件、项目管理工具）连接起来，让它们之间能自动传递信息。

最近，这个领域发生了一件不大不小的事：一个叫Relay.app的同类产品宣布要关闭了。Relay.app也是一个自动化工具，功能和Zapier类似，但界面更现代，操作方式也有自己的特色。它从2023年上线，积累了一批忠实用户。但到了2026年3月，运营方决定停止服务。这背后有很多原因，可能是用户量不够大，可能是融资没跟上，也可能是市场竞争太激烈。对于Relay.app的用户来说，最直接的问题就是：我辛辛苦苦搭好的那些自动化流程怎么办？

Zapier作为这个领域的老牌玩家，很快发布了一篇文章，手把手教Relay.app的用户怎么把自己的工作流程（workflows）导出来，然后迁移到Zapier上。这篇文章不是那种冷冰冰的官方公告，而是带着一种“别慌，我们来帮你”的态度。它详细解释了每一步：先登录Relay.app找到导出功能，把流程文件下载下来，然后注册Zapier，再导入这些文件。它还提醒用户，有些特殊的设置可能需要手动调整，比如某些Relay.app独有的触发条件（trigger）和动作（action）在Zapier里可能名称不同，需要重新映射。

对于普通读者来说，这件事其实折射出一个更普遍的道理：当你依赖一个工具来管理你的日常工作流时，这个工具本身的风险就成了你的风险。Relay.app不是第一个关停的自动化工具，也不会是最后一个。很多创业公司推出的产品虽然好用，但可能因为商业原因突然停止运营。所以，选择工具的时候，除了看它功能强不强、价格合不合适，还要看它背后的公司稳不稳定、有没有成熟的迁移方案。Zapier能在这个时候站出来接盘，恰恰是因为它已经运营了十几年，用户量大，商业模式相对成熟，不太可能突然消失。

这篇文章的另一个价值是，它展示了一个成熟公司如何对待竞争对手的“遗产”。Zapier没有幸灾乐祸，也没有冷眼旁观，而是主动提供帮助。这既是商业策略，趁机吸引新用户，也是一种行业责任，毕竟自动化工具的核心价值就是让用户安心，如果用户因为工具关停而损失了数据和工作流，整个行业都会失去信任。

读完之后你会带走一个很实际的提醒：不管你用的是什么工具，定期导出备份你的工作流配置，就像备份你的文件一样重要。同时，尽量选择那些有清晰退出路径的产品，这样即使有一天它不做了，你也能带着你的“自动化资产”轻松搬家。

Forward Deployed Engineers

你是一家公司里负责做产品的团队。你们花了很多时间设计新功能，写代码，测试，然后发布。但有时候，你发现产品真的上线了，客户却用不起来。不是产品不好，而是客户的环境和你们想象的不一样。比如，客户的IT部门有严格的安全规定，你们的软件需要访问某个内部数据库，但客户公司根本不开放这个权限。或者客户的员工习惯用一套旧工具，你们的新产品需要他们改变工作流程，他们不愿意。这时候，产品本身没问题，但落地出了问题。

硅谷产品集团（Silicon Valley Product Group）的一篇文章提出一个角色叫“前部署工程师”（Forward Deployed Engineers）。这个角色不是坐在办公室写核心代码的，而是被派到客户现场，帮助客户把产品真正用起来。他们有点像产品团队的“侦察兵”和“安装工”。他们去客户那里，看客户怎么工作，遇到什么障碍，然后现场修改配置、写小脚本、甚至临时开发一些连接器，让产品能适应客户的具体环境。

这个角色最早在谷歌、Palantir这类公司流行起来。Palantir做的是大数据分析软件，客户通常是政府或大企业，环境极其复杂。他们的工程师经常驻扎在客户办公室，和客户一起工作几个月，确保软件真的能帮客户解决问题。这跟传统软件公司“卖完就走”的模式完全不同。

为什么需要这个角色？因为很多好产品死在最后一公里。客户买了产品，但部署不顺利，用不起来，最后就放弃了。前部署工程师就是专门解决这最后一公里的。他们不只是技术支持，还负责把客户现场的反馈带回产品团队，告诉团队“客户真正需要什么”“我们的产品在真实场景里哪里不适用”。这样产品团队就能根据真实反馈改进产品，而不是闭门造车。

对于非技术背景的读者来说，可以这样理解：你开了一家餐厅，菜做得很好，但客人来了发现筷子不好用，椅子不舒服，或者找不到停车位。前部署工程师就是专门去客人家里看他们怎么吃饭，然后帮你调整筷子、椅子、停车位的人。他们不改变菜的味道，但让客人能舒舒服服地吃上菜。

这个角色对产品成功非常重要。很多公司只关注“做出好产品”，但忽略了“让客户用好产品”。前部署工程师就是连接这两个环节的桥梁。他们让产品在真实世界里真正发挥作用，也让产品团队不断学习真实世界的需求。如果你在做产品，或者公司有复杂的企业客户，考虑设立这样一个角色，可能会大大提升产品的实际采用率。

Your research is good. So why isn't it changing anything?

你是一个产品经理，或者设计师，或者任何需要做用户研究的人。你花了很多时间访谈用户，观察他们怎么使用产品，记录他们的痛点。你写出了一份漂亮的研究报告，有详细的数据，有用户的原话，有深刻的洞察。你把报告发给了团队，开了分享会，大家都说“很好，很有启发”。然后，就没有然后了。产品该怎么做还是怎么做，你的研究好像从来没有发生过。

这是很多研究人员的困境：研究做得很好，但就是改变不了任何事情。Dovetail的一篇文章专门探讨了这个问题。文章认为，问题不在于研究质量，而在于研究没有和产品决策真正连接起来。

为什么会这样？一个常见的原因是，研究结果没有在正确的时机传递给正确的人。比如，产品团队已经在开发某个功能了，这时候你拿出一份研究说“用户其实不需要这个”，团队已经投入了资源，很难回头。更好的做法是，在产品还在构思阶段、还没有开始写代码的时候，就把研究结果放进去，影响产品的方向。

另一个原因是，研究报告本身太像论文了。有很多图表、引文、方法论，但产品经理和设计师没有时间细读。他们需要的是“所以呢？”，研究结果意味着产品应该做什么改变。文章建议，研究人员应该直接给出行动建议，甚至参与产品决策会议，而不是只交一份报告就完事。

还有一个更根本的问题：研究往往只关注用户，而不关注公司内部的利益相关者。比如，销售团队想要某个功能，因为客户在问；高管想要另一个方向，因为竞争对手在推。如果研究只证明用户需要A，但公司内部的力量都在推B，研究就很难落地。好的研究人员会主动和销售、高管、工程师沟通，理解他们的目标和顾虑，然后把研究结果和他们关心的事情联系起来。

文章还提到一个具体做法：把研究结果变成“产品需求文档”的一部分。也就是说，不是单独做一个研究文档，而是把用户洞察直接写进产品需求里，让每一个功能点都有用户研究的依据。这样，团队在开发时自然会参考研究。

对于非研究背景的读者，可以这样理解：你是一个侦探，破了一个案子，找到了真凶。但法官不听你的，因为你的证据没有在正确的时间提交，或者你没有用法官听得懂的语言解释，或者法官已经被其他律师说服了。你要做的，不只是找到真相，还要确保真相能被采纳。

所以，如果你做研究，但发现研究没有影响力，不妨想一想：你的研究在什么时候、以什么方式、对什么人产生影响？是不是只停留在报告里，而没有进入决策的流程？是不是只关注用户，而忽略了公司内部的政治和优先级？调整一下方法，你的研究就能从“很好”变成“有用”。

Playing a different game

想象你开了一家小咖啡馆。街对面开了一家连锁咖啡店，价格更低，速度更快，还送积分。如果你也降价、也加快出杯速度、也搞积分，你大概率会输。因为你没有人家那么多钱和供应链。但如果你做的是精品手冲，只卖单一产地豆子，每周办一次杯测会，老客人愿意为了那杯特殊风味多走两条街，那连锁店反而拿你没办法。Intercom 这篇《Playing a different game》讲的就是这件事，在商业和产品里，最危险的竞争不是“做得不够好”，而是“和对手玩同一个游戏”。

大多数公司掉进的陷阱是：看到对手做了什么，就觉得自己也必须做。对手加了 AI 客服，你也加；对手做了免费版，你也做；对手把按钮从蓝色改成绿色，你也改。这种模仿看起来安全，实际上是把主动权交给了别人。你永远在追赶，而对手永远在定规则。更糟的是，当你按照对手的规则竞争时，你的优势，比如你对某一类用户的深度理解、你独特的团队文化、你长期打磨的某个流程，反而成了累赘，因为它们在新规则里用不上。

文章里举了一个很具体的例子。有一家做客服软件的公司，没有去和 Zendesk（一家大型客服平台）比功能多少，而是专注做“给小型电商用的极简客服工具”。他们的用户根本不需要几十种报表和自动化流程，他们只需要一个能快速看到未回复消息、能一键发优惠券的简单界面。这家公司没有试图在所有维度上赢，而是在一个窄得多的赛道上做到极致。结果就是，大平台看不上一小块市场，小平台又做不出他们的深度，他们反而活得很好。这就是“玩不同的游戏”。

玩不同游戏的关键，不是故意标新立异，而是想清楚三个问题：你的用户是谁？他们真正需要但别人没给的是什么？你的团队有什么独特的能力或资源，能让别人很难复制？比如，一个做笔记工具的公司，如果发现自己的用户是程序员，而程序员最烦的是写文档时还要切换窗口，那就做一个嵌入代码编辑器里的笔记插件。这个产品功能列表看起来很薄，但对那批用户来说，它比任何全能笔记工具都好用。因为其他笔记工具要花很大力气才能做到同样的深度集成，不值得。

读到最后你会发现，这篇文章真正想说的是：竞争不是要赢过所有人，而是要让自己变得无法被比较。当你玩一个不同的游戏，你的对手就不再是那些大公司，而是用户心中那个“还没被满足的需求”。你的目标不是比对手好10%，而是给某一群人一个他们找不到替代品的体验。下次你看到竞争对手做了什么事，不要急着跟，先问自己：我们要不要继续玩自己的游戏？

A behind-the-scenes look at building the Slack Design illustration library

想象你每天打开一个软件，看到的不是冷冰冰的按钮和文字，而是一幅幅小插画：一只戴着耳机的小企鹅在发消息，一群小人在白板前讨论，或者一个机器人帮你倒咖啡。这些插画不只是好看，它们会告诉你这个功能是做什么的，或者在你遇到错误时让你别那么紧张。Slack 就是那个被很多人用来和同事聊天的软件，而它的设计团队最近写了一篇文章，详细讲了他们是怎么搭建一套插画库的。

你可能会想，画几幅图而已，有什么好说的？但真实情况是，一个像 Slack 这样有几千万用户的产品，插画不是设计师随手画了就完事的。如果每个设计师都按自己的喜好画，那用户今天看到的是一只卡通猫，明天看到的是写实风格的人，后天又变成抽象线条，整个产品看起来就会像拼凑出来的，用户会觉得不专业、不可靠。更麻烦的是，如果插画风格不统一，用户每次看到新画面都要重新理解它的意思，学习成本就高了。

Slack 团队的做法是，先定下一套规则。比如，人物的画法要一致：脸是圆圆的，身体是简单的几何形状，颜色来自公司规定的色板，不能随便用。插画里的元素也要有固定的“词汇”，比如一个带闪电的云朵代表“快”，一个齿轮代表“设置”。这样，不管哪个设计师来画，新插画都能和老的看起来像一家人。

但光有规则还不够。他们还需要一个“仓库”，也就是一个所有人能共享的插画库。这个库不是简单地把图片存起来，而是把每个插画拆成可以重复使用的零件。比如，一个“打招呼的小人”插画，手、头、身体都可以单独拿出来，用在别的场景里。这样，设计师不用每次都从头画一个人，而是像搭积木一样，从库里取出“手”“头”“身体”拼在一起，再换个颜色或表情，就变成一个新的插画了。效率高了很多，而且风格绝对不会跑偏。

这套系统还有一个关键点：它不只是给设计师用的。工程师写代码时，可以直接调用库里的插画，不需要等设计师出图。产品经理做原型时，也能先用库里的占位图，快速看到效果。也就是说，整个团队的工作都因为这套共用的插画库变得更顺畅了，不用反复沟通“这里该放什么图”“那个图能不能用”。

文章里还举了一个具体的例子。Slack 有一个功能叫“频道”，是团队成员讨论特定话题的地方。如果用户想创建一个新频道，系统会展示一幅插画：两个人站在一块白板前，白板上写着“新项目”。这幅插画不是随便画的，而是设计团队根据“创建频道”这个动作，想传达“协作”和“开始新东西”的感觉。有了插画库，这幅画里的“白板”和“人”都可以从库里调出来，未来在别的页面，比如“新建文档”或“发起投票”，也能用同样的“白板”元素，用户一看就知道是“开始一个协作活动”。

读完整篇文章，你会意识到，那些看似轻松的插画背后，是一套严谨的设计系统。它让产品看起来统一、友好，也让团队协作更高效。如果你是一个普通用户，下次看到 Slack 里的小插画，可以多留意一下：它们不只是装饰，而是产品在跟你说话，用一种温柔的方式告诉你“这个功能是干这个的”或者“别担心，点这里就好”。

这篇文章适合任何对“产品是怎么做出来的”感兴趣的人。它不涉及复杂的技术，讲的更多是思考和流程。你会看到，一个好的设计系统，不是靠一个人画几百张图，而是靠一套规则和工具，让整个团队能一起画出几万张风格统一的图。

Tickets now available for Shift UX 2026!

如果你是一位产品设计师或用户体验研究员，你可能已经知道Shift UX这个会议。它每年聚集几百个来自不同公司的人，一起讨论怎么让数字产品更好用、更人性化。今年的Shift UX 2026刚刚开放售票，地点在美国俄勒冈州的波特兰。会议时间定在2026年10月，具体日期还没有公布，但主办方Rosenfeld Media说早鸟票数量有限，卖完就没了。

这个会议不是那种大舞台、几千人听演讲的场合。它更偏向工作坊和深度对话，每个参与者都有机会动手解决问题，而不是光坐着听。比如去年有场工作坊叫“如何用简单语言写界面文案”，参加的人直接拿自己公司的产品页面来改，当场就能看到变化。另一个常见主题是“如何让用户研究的结果真正影响产品决策”，这背后的问题很多人都有感受：你花了几周做用户访谈，写了一份报告，但产品经理看了一眼就放在一边，功能还是照原计划做。Shift UX想解决的就是这种“研究做了但没用”的困境。

今年的大会主题涵盖人工智能产品设计、内容策略、用户研究方法和设计系统。其中人工智能产品设计尤其值得关注，因为很多设计师正在头疼怎么把AI功能自然地放进现有产品里，而不是生硬地加一个聊天机器人。Rosenfeld Media的创始人Lou Rosenfeld在公告里提到，他们特意邀请了来自不同规模公司的从业者，包括像Figma、微软这样的巨头，也有小型创业公司。这样参与者能听到各种真实的案例，而不是只有大公司的成功故事。

除了正式议程，会议还有一个传统叫“点子交换”，有点像快速相亲，但大家交换的是设计难题和可能的解法。比如你可以带着“我们产品的注册流程流失率很高”这个问题去，五分钟内就能听到三四个不同行业的同行给出建议。这种形式很受欢迎，因为它直接、高效，而且能认识新朋友。

如果你对用户体验（UX）这个领域感兴趣，或者正在做产品相关的工作，Shift UX是一个能让你带着具体方法回去的会议。票价目前是早鸟价，比正价便宜不少。不过它不是在线上举办的，需要你亲自去波特兰，所以时间和旅行成本也要考虑进去。总的来说，这是一个注重实践、反对空谈的会议，适合那些想真正动手改进产品的人。

Testing Font Scaling For Accessibility With Figma Variables

你有没有遇到过这种情况：在手机上打开一个网站，字小得眯起眼睛才能看清，或者字太大，一屏只能看两三行？这通常是因为网站没有处理好字体缩放。设计师在设计时用的是电脑屏幕，但用户可能用各种设备，而且每个人的视力也不一样。有些人会把系统字体调大，方便阅读，但如果网站不支持这种调整，文字就会变形、重叠，甚至消失。

Smashing Magazine的这篇文章介绍了一种用Figma变量来测试字体缩放的方法。Figma是很多设计师用来画界面草图的工具，而变量是它最近新增的功能，可以让你定义一些可重复使用的数值，比如颜色、间距、字体大小。以前设计师调整字体大小时，要手动改每一个文本框，非常麻烦，而且容易漏掉。现在有了变量，只要改一个地方，所有关联的地方都会跟着变。

文章的具体做法是：先在Figma里设置一组字体大小变量，比如正文、标题、小字分别对应不同的数值。然后利用Figma的“变体”功能，创建几个不同的字体缩放模式，比如“正常”、“放大1.2倍”、“放大1.5倍”。这样设计师可以一键切换，看到不同缩放比例下界面会不会出问题。比如按钮上的文字变大了，按钮本身有没有跟着变大？如果没变，文字就可能溢出按钮，或者按钮之间互相挤在一起。

这个方法的好处是，它把无障碍测试（accessibility testing）提前到了设计阶段，而不是等到开发完成、代码写好了再改。那时候改起来成本高，而且容易引入新问题。作者还提到，他们团队在测试一个新闻App时，发现默认字体大小下标题和正文间距刚好，但放大1.5倍后，标题和正文几乎贴在一起，用户很难区分。通过这个Figma变量方法，他们很快调整了间距变量，确保任何缩放比例下阅读体验都舒适。

对于没有设计背景的读者来说，这篇文章的核心价值是：它提供了一个低成本的工具，让设计师在画草图时就能发现潜在的可用性问题，尤其是和视力相关的。你不需要等到用户抱怨“字太小”才去改，而是从一开始就考虑不同人的需求。如果你是一个产品经理或者开发者，也可以拿着这个方法去和设计师沟通，问他们是否在Figma里做了字体缩放测试。这能帮助团队避免很多后期返工，也让产品对更多人友好。

Netflix CPTO on AI and the future of product and tech roles | Elizabeth Stone

Netflix 的首席产品与技术官（CPTO）Elizabeth Stone 最近在一次访谈里聊了聊她对人工智能的看法，以及产品和技术岗位的未来。你可能会想，Netflix 不是做影视流媒体的吗，跟人工智能有什么关系？实际上，Netflix 早就把人工智能用在了很多地方。比如，你打开 Netflix 时看到的那一排排推荐影片，背后就是人工智能在根据你之前看过的内容、你停留的时间、你跳过哪些影片，来猜测你现在可能想看的。Stone 说，人工智能不是要取代产品经理或工程师，而是会改变他们的工作方式。

她举了一个例子：过去，Netflix 的工程师要花很多时间写重复的代码，比如处理数据格式不统一的问题。同一份用户数据，在推荐系统里是一种写法，在搜索系统里是另一种写法，工程师得手动把它们对齐。现在，有了人工智能的帮助，工程师可以把更多精力放在理解用户需求、设计更好的产品体验上。Stone 强调，未来产品和技术岗位的核心能力不再是写代码本身，而是理解问题、定义问题、以及判断人工智能给出的答案是否靠谱。

Stone 也提到了一个很多人担心的问题：人工智能会不会让一些岗位消失？她的回答很务实。她说，就像当年 Netflix 从 DVD 租赁转型到流媒体，很多旧的岗位消失了，但新的岗位出现了。人工智能会淘汰那些重复性高、创造性低的工作，但也会创造出需要人类判断力、创造力和同理心的新工作。比如，产品经理需要更深入地理解用户在使用产品时的情绪和场景，而不仅仅是看数据。人工智能可以告诉你用户点击了什么，但它无法告诉你用户点击时是开心还是沮丧。

最后，Stone 给正在做产品和技术的人提了一个建议：不要把人工智能当成一个黑盒子，而是要主动去理解它擅长什么、不擅长什么。她认为，未来最成功的产品和技术团队，不是那些最会用人工智能工具的团队，而是那些最会问问题的团队。因为人工智能可以给出很多答案，但只有人类才知道哪些问题是真正值得回答的。读完你会带走这样一个判断：人工智能不会抢走你的饭碗，但会重新定义你饭碗里装的是什么。

How to automate ChatGPT (GPT-5.6 Sol, GPT-5.6 Terra, and more)

你有没有遇到过这样的情况：在 ChatGPT 里写好了一段文案，想把它存到 Notion 或发送给同事，却要手动复制粘贴、打开另一个软件、再粘贴一遍？如果每天要做十几次，这种重复操作会浪费大量时间。Zapier 这家公司就是专门解决这类问题的。它像一个“数字搬运工”，能帮你把不同的网络服务连接起来，让它们自动传递信息、执行任务。现在，Zapier 把 ChatGPT 也纳入了这个自动化的世界，意味着你可以让 ChatGPT 和上千种其他软件协同工作，而不用自己动手。

具体怎么做呢？Zapier 提供了一个叫“Zap”的自动化流程。比如你设定一个触发条件（trigger），当有新邮件到达 Gmail 时，Zapier 会自动把邮件内容发送给 ChatGPT，让它写一个回复草稿，然后把草稿存到你的 Google 文档里。整个过程不需要你打开任何一个软件，完全自动运行。文章里提到，ChatGPT 现在有多个版本，比如 GPT-5.6 Sol 和 GPT-5.6 Terra，它们的能力略有不同，但都可以通过 Zapier 接入。你不需要理解这些版本的技术差异，只需要知道它们就像不同的“大脑”，有的更适合创意写作，有的更擅长逻辑分析。

对于没有编程背景的人来说，Zapier 的界面是可视化的，你只需要在网页上点选、拖拽，就能创建自己的自动化流程。比如你是一个自媒体作者，可以设置当你在微信公众号后台发布一篇文章时，Zapier 自动把文章内容发给 ChatGPT，让它生成一段推广文案，然后自动发布到你的微博和 Twitter 上。这背后其实是一个很简单的逻辑：先告诉 Zapier 你希望它“监视”哪个事件（比如新文章发布），再告诉它接下来要做什么（调用 ChatGPT 处理），最后告诉它结果存到哪里（比如发到微博）。

文章还特别强调，这种自动化不仅省时间，还能减少人为错误。比如你每天需要从销售邮件中提取客户信息并录入表格，手动操作容易漏掉或填错，但让 Zapier 和 ChatGPT 配合，它们可以准确提取关键字段并自动填入。对于小团队或个体创业者来说，这相当于多了一个不知疲倦的助手。当然，Zapier 并不是免费的，它有免费额度，但高级功能需要付费。不过对于大多数日常场景，免费版已经足够用了。

读完这篇文章，你可能会意识到，今天的人工智能工具不再只是单独使用的“聊天窗口”，而可以成为整个工作流的一部分。你不需要学会写代码，就能像搭积木一样，把不同软件和 AI 组合起来，创造出属于自己的自动化小工具。这种能力，正在让每个人都能像程序员一样，用技术解决自己的重复劳动。

Kick the Bots Out of Your Survey Data

做用户调研的时候，你辛辛苦苦设计好问卷，发出去，回收了几百份答案。你满心期待能看到真实用户的反馈，结果打开数据一看，很多答案明显不对劲：有人几秒钟就填完一份原本需要五分钟的问卷，有人在开放式问题里复制粘贴了同一段话，有人选的选项自相矛盾。这些不是真人，是机器人程序。它们混进你的样本里，污染数据，让你分析出来的结论全是错的。

尼尔森诺曼集团（Nielsen Norman Group）这篇关于如何清除问卷中机器人的文章，正好切中了很多产品经理、设计师和研究员的痛点。文章首先告诉你，机器人（bots）不是偶尔出现，而是越来越猖獗。它们可能来自恶意刷量、自动填表工具，或者某些专门薅调查奖励的团伙。你发一个问卷链接到社交媒体、论坛或者邮件列表，就等于给机器人开了大门。

那怎么识别它们呢？文章给出了一些具体方法。比如看完成时间：一份正常的问卷，平均完成时间应该是多少秒或多少分钟，如果某个回答的完成时间远低于这个值，比如只用了十几秒，那几乎可以肯定是机器人。再比如看陷阱题：在问卷里悄悄放一道“请选择第三个选项”这样的注意力检查题，真人一般会正确回答，而机器人可能随机乱选。还可以看IP地址：同一个IP地址短时间内提交了多份问卷，或者来自你根本不打算调查的地区，那也很可疑。

但光识别还不够，你得在收集阶段就阻止它们。文章建议使用验证码（CAPTCHA），也就是那种让你识别红绿灯、斑马线的图片验证。不过验证码会降低真人的填写意愿，所以可以用得更巧妙一些，比如只在检测到可疑行为时才弹出验证码。还可以用“蜜罐”（honeypot）技术：在表单里藏一个对用户不可见的输入框，真人看不见所以不会填，机器人会盲目填上，然后你就可以把它过滤掉。

就算做了这些防护，还是会有漏网之鱼。所以文章强调，在分析数据之前，必须做一次“数据清洗”。把那些明显异常的答案删掉，比如完成时间极短的、答案逻辑矛盾的、重复提交的。清洗之后，你的样本才能代表真实用户。

读完这篇文章，你带走的一个判断是：问卷数据里混入机器人不是小概率事件，而是常态。如果你不做防护和清洗，那么你基于问卷做的所有决策，产品方向、功能优先级、用户画像，都可能被机器人带偏。花一点时间把机器人踢出去，是对调研结果负责的基本动作。

Ambsheets 02 · Filtering scenarios

假设你是一个产品经理，正在设计一个新功能。你脑子里有很多想法，但不知道哪个最好。你可能会和团队开会讨论，或者画几张草图，但讨论来讨论去，常常陷入空谈。有没有一种更结构化的方法，能让你快速过滤掉不靠谱的想法，聚焦到真正值得做的方向上？

Ink & Switch 实验室的这篇笔记，讲的就是一种叫“Ambsheets”的工具。Ambsheets 这个词可能有点陌生，但你可以把它理解成一种特殊的“思考工作表”。它不是为了记录信息，而是为了帮助你系统地探索一个设计问题的各种可能性，然后从中筛选出最合适的方案。

文章具体讨论了“过滤场景”（filtering scenarios）这个环节。什么意思呢？就是当你面对一堆潜在的设计方案时，你需要一些“过滤器”来淘汰那些明显不好的。过滤器可以是用户需求、技术可行性、商业价值，或者任何对你项目重要的标准。比如，你设想了一个很酷的功能，但开发成本太高，周期太长，那它就被“技术可行性”这个过滤器筛掉了。另一个功能虽然技术上简单，但用户根本不需要，那它就被“用户需求”过滤器筛掉了。

Ambsheets 的特别之处在于，它把这些过滤过程变成可视化的、可操作的步骤。团队可以在一张大纸上画表格、写场景、标注过滤条件，然后一起讨论。每个人都能看到哪些想法被淘汰了，为什么被淘汰，以及剩下的是哪些。这样讨论就不再是各说各话，而是基于共同的视觉框架。

文章还举了一个具体的例子：假设你在设计一个笔记应用，用户想快速找到以前写过的内容。你可能想到很多搜索方式：全文搜索、标签搜索、AI 智能推荐等等。然后你用“用户是否容易理解”、“实现难度”、“对隐私的影响”等过滤器一一检验。结果发现，AI 推荐虽然强大，但用户可能觉得不可控，而且实现起来很复杂，于是被暂时搁置。而简单的标签搜索，虽然不酷，但用户熟悉、实现简单、隐私风险低，就成了优先选项。

读完这篇笔记，你带走的一个判断是：好的设计不是靠灵光一现，而是靠系统化的过滤。用 Ambsheets 这样的工具，让团队在早期就把不合适的方案淘汰掉，避免在错误的方向上投入大量精力。对于产品经理和设计师来说，学会过滤和筛选，比学会创造新点子更重要。

The Product Model at Google

很多人以为谷歌的成功全靠技术，比如搜索算法、人工智能或者那些让人眼花缭乱的黑科技。但硅谷产品集团（Silicon Valley Product Group）的一篇文章提出一个不同的看法：谷歌真正的秘密武器，是它内部做产品的方式，也就是所谓的“产品模型”（product model）。这个词听起来有点抽象，其实很简单。传统的公司做产品，通常是老板或者高层想出一个主意，然后交给工程师去实现，工程师做完就交给销售去卖。这种模式叫“项目模型”（project model），就像接一个项目，做完就结束。而产品模型不一样，它强调的是持续地发现用户的问题，然后不断改进解决方案，而不是一次性交付一个东西。

在谷歌，产品经理、设计师和工程师组成一个紧密的小团队，他们不是等着上级下达指令，而是自己去观察用户、做实验、分析数据，然后快速尝试各种可能的改进。比如谷歌搜索的首页，你看起来就是干干净净一个搜索框，但背后有无数个小实验在同时进行：按钮的颜色、字体的大小、搜索结果的排序方式，甚至广告出现的位置，都是通过大量实验一点点优化出来的。这种做法的核心是“产品发现”（product discovery），也就是团队不断问自己：用户真正需要什么？我们做的这个东西有没有用？而不是等产品做出来了才发现没人用。

文章里举了一个具体的例子：谷歌的云端硬盘（Google Drive）在早期，团队发现用户经常抱怨文件同步太慢。传统做法可能是工程师埋头优化代码，然后发一个版本说“我们修好了”。但谷歌的产品团队会先做用户研究，发现很多人其实不是真的需要更快的同步，而是希望知道同步的进度，比如还剩多少文件没传完。于是他们加了一个简单的进度条，用户满意度立刻上升了。这个例子说明，产品模型不是追求技术上的完美，而是解决用户真正在意的问题。

当然，这种模式不是谷歌独有的，很多互联网公司也在用，但谷歌把它贯彻得特别彻底。文章提到，谷歌的每个产品团队都有自主权，可以决定做什么、怎么做，不需要层层审批。这种授权听起来很美好，但实际操作起来很难，因为它要求团队里的每个人都具备很强的判断力。比如产品经理必须能分辨哪些功能值得做，哪些只是“锦上添花”；工程师不能只等着别人告诉他要做什么，而要主动思考如何用技术解决用户问题。

读完这篇文章，你会明白为什么谷歌能做出那么多改变世界的产品，不是因为运气，而是因为它建立了一套让好想法不断涌现并快速验证的机制。这套机制的核心，就是把做产品当成一个持续学习和调整的过程，而不是完成一个任务。对于任何想做出好产品的人来说，这可能是比技术更重要的启示。

Doing the right thing when things go wrong

想象一下，你是一家在线商店的老板，突然发现系统出了故障，导致一批客户的订单被重复扣款。你的第一反应是什么？可能赶紧修系统，然后发一封道歉邮件，再给受影响的客户一些补偿。但Intercom（一家专门做客户沟通软件的公司）的一篇文章说，这样做可能还不够，甚至可能让事情变得更糟。问题不在于你做了什么，而在于你怎么做。

文章讲了一个真实的故事：一家叫Buffer（一个社交媒体管理工具）的公司，曾经因为安全漏洞导致用户数据被泄露。Buffer的CEO没有躲在公关团队后面，而是直接在自己的博客上写了一篇详细的说明，告诉大家发生了什么、为什么发生、他们正在怎么处理。他甚至公开了公司内部的沟通记录，让用户看到他们是如何一步步解决问题的。结果呢？用户不仅没有大量流失，反而有很多人留言说“感谢你们的坦诚”。

这个例子说明了一个道理：当事情出错的时候，用户最在意的不是错误本身，而是你对待错误的态度。如果你试图掩盖、推卸责任或者只是机械地道歉，用户会觉得你不真诚，甚至可能怀疑你以后还会犯同样的错误。但如果你能坦诚地承认错误，并且清晰地告诉用户你正在做什么来避免再次发生，用户反而会更信任你。文章把这种态度叫做“做正确的事”（doing the right thing），但这不是一个空洞的口号，而是需要具体行动的。

具体怎么做呢？文章给出了几个步骤。首先，要第一时间通知用户，而不是等所有问题都解决了再说。因为用户如果自己发现出了问题，而你没有主动告知，他们会觉得被欺骗。其次，要解释原因，但不要用太多技术术语。比如不要说“数据库连接池溢出导致事务回滚失败”，而要说“我们的系统在处理订单时遇到了一个临时故障，导致部分订单被重复处理”。最后，要给出明确的补救措施，比如退款、赠送优惠券，并且告诉用户你改进了什么，确保同样的问题不会再发生。

文章还提到一个常见的误区：很多公司觉得只要给用户足够的补偿，用户就会满意。但研究发现，如果用户觉得你的态度不够真诚，即使补偿再多，他们也不会原谅你。相反，如果你的态度诚恳，即使补偿很少，用户也更容易接受。这就像朋友之间闹矛盾，对方如果真心道歉，你可能很快就原谅了；但如果对方只是敷衍地说“对不起”，然后塞给你一个礼物，你反而会觉得更生气。

这篇文章的核心观点是：错误是不可避免的，但错误也是建立信任的机会。当你把用户当成合作伙伴，而不是需要应付的对象时，一次危机反而可能让用户更加忠诚。读完之后，你会重新思考“客户服务”这件事：它不只是解决问题，更是维护关系。而维护关系最重要的，就是真诚。

Beyond Black Box Scores: How Musubi Trains Custom AI for Trust and Safety Teams

想象一下，你是一家社交媒体公司的内容审核员。每天要看成千上万条用户发的帖子，判断哪些是垃圾广告、哪些是仇恨言论、哪些是虚假信息。公司给你一套AI工具，它会为每条内容打一个风险分数，比如0.95分，表示“非常可能有问题”。但问题在于，你根本不知道这个分数是怎么算出来的。它就像一个黑盒子，你只能信任它，却不能理解它。如果它把一条正常的帖子标记为高风险，你可能会误删；如果它漏掉一条真正危险的帖子，后果更严重。这就是“黑盒评分”带来的困境。

有一家叫Musubi的公司，专门为信任与安全（trust and safety）团队提供AI解决方案。这里的“信任与安全”指的是平台用来保护用户免受有害内容伤害的机制，比如删除暴力视频或封禁骚扰账号。Musubi的做法和传统黑盒AI完全不同：他们允许团队用自己的数据和规则来训练AI，而不是直接使用别人训练好的通用模型。这样一来，审核员不再是盲目接受一个分数，而是可以理解AI为什么给某条内容打高分或低分。比如，如果团队发现“包含某个特定关键词的帖子经常是诈骗”，他们就可以把这个规则教给AI，让AI在判断时重点考虑这个关键词。

更具体地说，Musubi提供了一个平台，让信任与安全团队可以上传自己标记过的历史数据，比如过去一年里被确认是垃圾广告的10万条帖子。然后，团队可以用自然语言（就是日常说话的方式）告诉AI：“如果帖子包含链接和‘免费’这个词，并且来自新注册账号，就标记为高风险。”AI会学习这些规则，并应用到新的内容上。这样一来，审核员看到高风险标记时，就能大概猜到原因：可能因为这条帖子有链接、有“免费”字样，而且发帖人刚注册。这种透明度大大减少了误判，也让团队能更快地调整规则，应对不断变化的攻击手法。

对于零背景的读者来说，这个故事的关键在于：AI不一定要是神秘的黑盒子。Musubi证明了，即使是复杂的AI系统，也可以被设计成让非技术人员（比如内容审核员）理解和控制。这就像你教一个新同事如何识别诈骗邮件，你告诉他“看到要求转账的邮件要小心”，而不是给他一个神秘的数字让他猜。这种“可解释的AI”在信任与安全领域尤其重要，因为错误的判断可能伤害真实用户，或者让平台面临法律风险。读完这篇文章，你会带走一个判断：AI的落地成功，往往不在于算法有多先进，而在于它能不能被使用它的人真正理解和使用。

Re-designing Slack on Mobile

如果你用过Slack，你一定知道它是一款团队沟通工具，有点像工作用的微信。但你可能没想过，在手机上使用Slack和电脑上使用Slack，体验可以差很多。电脑屏幕大，你可以同时看到多个频道和对话列表；手机屏幕小，信息挤在一起，点来点去很容易迷失。Slack的设计团队发现，很多用户在手机上打开Slack后，第一反应是“我在哪？”，因为界面太拥挤，他们找不到当前最重要的消息。于是，Slack决定重新设计手机版，让用户能更快地抓住重点。

设计团队做了大量用户研究。他们发现，手机用户的核心场景是“快速看一眼”：比如在等咖啡时检查有没有紧急消息，或者在会议间隙回复一条关键信息。用户不需要在手机上完成所有操作，他们只需要高效地处理最迫切的事情。基于这个洞察，Slack团队提出了一个设计原则：手机版应该像一个“信息过滤器”，帮用户自动筛选出最重要的内容，而不是把电脑版的所有功能都缩小塞进手机。

具体怎么改呢？首先，他们重新设计了底部导航栏。原来的底部有“首页”“频道”“私信”“搜索”“更多”五个标签，每个标签点进去都显示一个长长的列表。新设计把“首页”改成了“活动”视图，这里只显示未读消息、@你的消息、以及你设置的关键词提醒。这样一来，你一打开App，第一眼看到的就是需要你立即处理的事情，而不是所有频道的列表。其次，他们优化了消息预览：每条消息只显示前两行文字，并且用图标区分是普通消息还是文件或链接，让你不用点进去就知道大概内容。

还有一个有趣的细节：Slack团队重新设计了“撰写消息”的按钮。以前，这个按钮在屏幕右上角，很小，一只手操作够不到。新设计把它移到了底部中间，并且做成了圆形大按钮，拇指正好可以够到。这个改动看似微小，但对用户来说，发消息的操作从“需要双手配合”变成了“单手就能完成”。Slack团队还测试了不同颜色的按钮，最终选择了Slack品牌色紫色，因为它在各种光线环境下都容易识别。

整个重新设计的过程，Slack团队用了大量的原型测试（prototype testing，就是做出一个简易版本让真实用户试用并收集反馈）。他们发现，用户对“活动”视图的接受度很高，但也有一些用户担心会错过不紧急但重要的消息。于是团队增加了一个“所有未读”的入口，让用户想看所有未读消息时也能找到。这种平衡“高效”和“全面”的思考，是手机产品设计中最难的部分。读完这篇文章，你会带走一个判断：好设计不是把所有功能都做出来，而是帮用户在最有限的设备上，优先完成他们最想做的事情。

Why Accessibility Is An Operational Capability, Not A Feature

你有没有遇到过这样的情况：一个网站上的按钮怎么点都没反应，或者一段视频没有字幕，你完全不知道里面在说什么？对很多人来说，这不是偶然，而是日常。这篇文章想讨论一个更深的问题：为什么很多公司和团队明明知道要让产品对所有人友好，却总是做不好？答案可能不是缺技术，也不是缺意愿，而是他们把这件事放错了位置。

很多人觉得，让产品好用的无障碍设计（accessibility）就像给软件加一个功能，比如给图片加一段文字描述，或者让界面能放大。做完这些，就完事了。但文章指出，这种想法本身就有问题。因为把无障碍当成一个“功能”，就等于把它当成一个可以被砍掉、被推迟、被忽略的东西。功能可以排在优先级列表的最后，可以等版本2再做，可以因为时间紧就不做。而真正的无障碍，应该是一种运营能力（operational capability），意思是整个团队从第一天起就具备持续做好这件事的习惯和流程，就像做饭的时候必须洗菜切菜一样，不是可选项目。

举个例子：一个团队如果只是让设计师在最后阶段检查一下颜色对比度够不够，那就像盖房子到最后才想起来要装窗户。真正有效的方式是，从画草图的时候就把各种不同能力的用户考虑进去。比如产品经理写需求的时候，就写明“这个按钮要能被键盘操作”；设计师画图的时候，就标注出“这里要留够空间给放大文字的用户”；开发写代码的时候，就用能自动检查无障碍问题的工具；测试的时候，让视障或听障用户也参与进来。每一步都做一点，而不是最后集中补救。

文章里提到一个重要的比喻：无障碍不是终点线，而是跑道本身。意思是，你不能跑完比赛再回头铺跑道。你从一开始就要在跑道上跑。如果你把无障碍当作一个功能，那你永远在追着它跑，永远觉得它是个额外负担。但如果你把它变成运营能力，它就变成了团队默认的工作方式，就像代码要能运行、界面要能响应一样自然。

那么，怎么判断一个团队是否真的把无障碍变成了运营能力呢？文章给出了一些信号。比如，团队里有没有人专门负责这件事？是不是每次开会都会讨论？有没有明确的流程和工具？当工期紧张的时候，无障碍是被砍掉的第一项，还是被当作必须保留的部分？如果答案是后者，那才说明它真正融入了日常。

读到这里，你可能已经明白，这篇文章不是在教你怎么写代码或设计界面，而是在讲一种思维方式。它想告诉所有做产品的人：如果你真的想让产品对所有人友好，不要把它当作一个可以勾选的清单，而要把它变成你每天做事的方式。就像安全驾驶不是一项任务，而是一种习惯。当你习惯了，你甚至不会觉得它在额外消耗你的精力。

最后，文章提醒我们一个朴素但重要的道理：一个对残障人士友好的产品，往往对所有人更好。比如，给视频加字幕，不仅听障人士需要，你在嘈杂环境里也看得懂。按钮做得大一点，不仅手指不灵活的人方便，你在跑步时也能点准。所以，把无障碍变成运营能力，最终受益的不仅是少数人，而是每一个用户。读完这篇文章，你会重新审视自己每天使用的产品，也会思考：如果换我来做，我会把它当成功能，还是能力？

What does the future of UX look like?

如果你是一名设计师，或者你身边有做设计的朋友，你可能会听到他们经常讨论一个词：用户体验（UX，User Experience）。简单说，就是一个人用某个产品时，感觉顺不顺手、开不开心。但你可能也会发现，最近几年这个领域好像有点焦虑。很多人问：人工智能（AI）来了，设计师会不会被取代？未来的用户体验会变成什么样？这篇文章就是来回答这个问题的，但它没有给出一个确切的预言，而是提供了一组思考方向。

文章开头就抛出一个有趣的观点：未来的用户体验，可能不再只是“屏幕上的东西”。过去二十年，我们习惯了在手机或电脑的屏幕上点来点去。但接下来，产品会越来越融入我们的环境。比如，你走进一个房间，灯会自动调暗，音乐会自动播放，温度会自动调节，你甚至不需要掏出手机。这种体验叫“环境计算”（ambient computing），意思是计算能力无处不在，但你看不到它。那么，设计师的工作就不再是画一个漂亮的按钮，而是设计一种看不见的互动方式。

另一个趋势是，人工智能会让产品变得更“懂你”。但文章提醒我们，懂你不一定是好事。想象一下，一个购物网站根据你的浏览记录自动推荐商品，这很方便。但如果它推荐的东西让你觉得自己被监视了，或者它猜错了你的意图，你就会觉得不舒服。所以，未来的用户体验设计，核心挑战之一是如何让AI的“懂”变得让人信任，而不是让人害怕。设计师需要思考：什么时候应该主动帮忙，什么时候应该闭嘴？什么时候应该问用户一句“你需要吗”，而不是直接替用户做决定？

文章还提到一个重要的概念：包容性设计（inclusive design）。这不是一个新词，但未来会变得更加紧迫。因为当产品越来越智能，它可能会无意中排除掉一部分人。比如，一个语音助手只听得懂标准口音，那有方言的人就用不了。一个手势控制设备只识别年轻人的动作幅度，那老年人可能就玩不转。所以，设计师必须从一开始就考虑各种不同的人：不同年龄、不同文化、不同能力。这不是为了政治正确，而是因为只有这样才能做出真正好用的产品。

那么，这些变化对设计师本人意味着什么？文章认为，设计师的角色会从“画图的人”变成“搭建系统的人”。过去，设计师的工作成果是一张张设计稿。未来，他们可能更多地在定义规则：比如，当用户情绪低落时，产品应该做什么？当用户连续失败三次时，系统应该怎么回应？这些规则不是一张图能表达的，它们更像是一套行为准则。所以，设计师需要学会和工程师、产品经理、数据科学家更紧密地合作，甚至要懂一点心理学和伦理学。

读到这里，你可能会觉得，未来听起来很复杂。但文章也给出了一个让人安心的结论：无论技术怎么变，用户体验的核心目标不会变，那就是让人的生活变得更好。工具会变，形式会变，但人对好体验的渴望不会变。所以，如果你正在做设计，或者打算进入这个领域，不必焦虑。你只需要记住：未来的用户体验，不再是关于一个屏幕，而是关于一个完整的生活场景；不再是关于功能，而是关于信任；不再是关于你自己，而是关于所有人。

最后，文章用一句话收尾，我觉得很值得记住：最好的用户体验，是你甚至感觉不到它的存在。就像你呼吸的空气，只有当它变得糟糕时，你才会注意到它。未来的设计师，就是那个确保空气始终清新的人。读完这篇文章，你会对身边那些“看不见”的设计多一份敬意，也会对未来的可能性多一份期待。

Adam Mosseri: AI is a tailwind for authenticity

如果你最近刷过 Instagram，你可能已经注意到，平台正在悄悄变味。以前你看到的更多是朋友发的照片，现在却越来越多地看到不认识的人拍的视频，甚至是一些明显由人工智能生成的图片或动画。这让人困惑：社交网络到底想让我们看什么？Adam Mosseri，Instagram 的负责人，最近在一次访谈里谈到了他对这个问题的看法。他的核心观点听起来有点反直觉：AI 非但不会让平台变得更假，反而可能成为“真实内容”的助推器。

要理解这个说法，得先想清楚一个现实问题：在 Instagram 这样的平台上，什么是“真实”？过去，真实意味着你朋友用手机拍的一张有点糊的照片，或者一段记录日常生活的短视频。但如今，AI 可以轻松生成以假乱真的图像，甚至能模拟一个人的面孔和声音。这听起来像是“真实”的末日。但 Mosseri 认为，恰恰相反。当 AI 生成的内容变得泛滥时，用户会开始更珍惜那些有“人味”的东西，比如一个人对着镜头吐槽今天遇到的倒霉事，或者一个手工博主展示她怎么用旧布料缝了一个包。这些内容虽然也可能被 AI 模仿，但那种笨拙的、不完美的、带着个人情绪的特质，是机器很难完全复制的。

Mosseri 还提到了一个具体的例子：Instagram 上的“Close Friends”（密友）功能。这个功能允许用户只对一小群最亲近的人分享内容。他发现，用户在这个圈子里发布的内容往往更随意、更真实，因为不用担心被很多人评判。而 AI 的介入，反而可能让这种私密分享变得更有价值，因为当公开信息越来越“假”时，那些只在小圈子流传的真实瞬间就成了稀缺品。这就像在一个到处都是塑料花的房间里，一朵真花哪怕有点蔫，也会让人忍不住多看两眼。

当然，这并不是说 AI 没有风险。Mosseri 承认，平台必须更努力地标记和限制那些误导性的 AI 内容，比如伪造的新闻图片或虚假的名人视频。但他认为，技术本身是中性的，关键是人怎么用它。如果创作者用 AI 来辅助自己讲一个真实的故事，比如用 AI 生成一段动画来配合自己的旁白，那它反而能增强内容的感染力。所以，AI 不是真实性的敌人，而是催化剂：它迫使平台、创作者和用户都重新思考，到底什么才是值得被看见的。读完这篇文章，你可能会想，下次刷到一条完美无瑕的视频时，不妨多问一句：这东西背后，有活人吗？

The great tightrope act

想象一下，你是一个建筑工地的总指挥。你手上有几十个工人，每个人都有自己的专长：有人擅长砌墙，有人擅长布线，有人负责设计图纸。现在，业主给了你一个任务：在三个月内盖好一栋楼。但问题来了，你只有一份模糊的草图，而且业主每隔两周就会改一次主意。更麻烦的是，你手头的材料随时可能缺货，而工人们还时不时因为工具不好用而罢工。这就是很多软件工程团队每天面对的现实。

这篇文章讨论的是一个几乎所有技术公司都会遇到的难题：如何在不确定性和不断变化的需求中，依然能按时交付一个质量过得去的产品。作者把这个过程比作走钢丝（tightrope act），一头是“速度”，另一头是“质量”，而中间的平衡点几乎每天都在移动。很多团队会犯一个错误：要么拼命赶工，结果交出一个满是漏洞的东西，用户用起来火冒三丈；要么过度追求完美，花几个月打磨一个功能，结果上线时市场已经变了。

文章里提到了一个具体的方法来应对这种困境，叫做“规划周期”（planning cycle）。它不是指一开始就制定一个详尽的年度计划，而是让团队每隔几周就坐下来，重新评估当前最重要的事情是什么。这就像你开车去一个陌生的地方，不是一上来就规划好全程路线，而是每开一段路就看一眼导航，根据路况调整方向。文章还强调，规划不只是经理的事，工程师、设计师、测试人员都应该参与进来，因为只有真正干活的人才知道哪里可能卡住。

另一个关键点是“技术债务”（technical debt），这个词听起来很专业，其实意思很简单：为了赶进度，你写了一些潦草的代码，就像为了快点把墙砌完，用了不太合适的砖头和水泥。短期看，墙是立起来了，但时间一长，裂缝就会出现，甚至整面墙都可能塌掉。文章建议，团队应该像定期还信用卡账单一样，主动留出时间来“还债”，也就是回头清理那些潦草的代码，而不是等到问题爆发才手忙脚乱地修补。

读这篇文章，你不会得到一个万能公式。但它会让你明白，软件开发的本质不是“按计划执行”，而是一个持续做权衡的决策过程。每个选择都有代价，关键在于你能不能看清代价是什么，并且愿意在必要的时候放弃一些东西。对于没有技术背景的人来说，这其实是一个很好的提醒：下次当你用到一个 App 卡顿或者闪退时，背后可能不是一个懒惰的程序员，而是一个团队在无数个两难选择中，做了一个不那么完美的决定。

Does Your Form Really Need a Dropdown List?

你打开一个网页，准备填表。姓名、邮箱都写好了，突然看到一个下拉菜单，问你“您所在的行业是什么？”选项有几十个，你得一个一个往下翻，翻半天才找到“教育”。你心想，为什么不能直接打字呢？这个问题，就是一篇来自尼尔森诺曼集团（Nielsen Norman Group，一家专门研究用户如何与网站、软件互动的咨询公司）的文章要讨论的。文章标题问：你的表单真的需要下拉菜单吗？

下拉菜单（dropdown list）就是那种点击后展开一列选项的控件。它看起来整洁，不占地方，但文章说，它其实常常让用户更慢、更容易犯错。比如，选项超过五六个，用户就要花时间扫描、比较，甚至可能点错。而如果改用单选按钮（radio button，就是一组小圆圈，只能选一个），所有选项都直接摆在那里，用户一眼就能看完，选择更快。文章举了一个例子：一个机票预订网站让用户选择“乘客数量”，用了下拉菜单。但大多数人只选1到2个人，为什么不让用户直接点数字按钮呢？这样连下拉都不用。

那什么时候下拉菜单真的有用？文章说，当选项很多，比如选择国家（超过200个），或者选项本身是用户不熟悉的、需要按分类浏览的，下拉菜单就合理。但即使如此，也要优化：比如输入几个字母就能自动筛选（autocomplete，自动补全），或者把常用选项放在最前面。文章还提醒，移动设备上下拉菜单更难用，因为屏幕小，手指容易点错。

所以，设计表单的人要问自己：用户真的需要从这么多选项里挑吗？能不能让用户自己打字？能不能用其他控件代替？文章的核心建议是：少用下拉菜单，多用单选按钮、复选框（checkbox，小方框，可以多选）、输入框（input field，直接打字的地方），或者干脆不要这个字段。用户的时间很宝贵，别让他们在表单里翻来翻去。

Ambsheets: A spreadsheet for exploring scenarios

想象你是一个产品经理，正在规划明年的一款新软件。你需要预测不同定价策略会带来多少收入。传统做法是用电子表格（spreadsheet，比如Excel或Google Sheets）：把假设的数字填进去，公式自动算出结果。但问题是，你只能看到一组数字。如果你想知道“如果涨价20%但用户减少10%，收入会怎样？”你就得手动改数字，或者建一堆分表。这很麻烦，而且容易漏掉可能性。

一家叫Ink & Switch的研究实验室（他们专门探索未来人们如何与电脑交互）做了一个叫Ambsheets的原型工具。Ambsheet这个词是Ambiguity（模糊性）和Sheet（表格）的组合，意思是一个能处理不确定性的表格。它不是一个普通电子表格，而是一个让你可以同时探索多种可能性的工具。比如，你不必只填一个“预期用户数”，而是可以填一个范围，比如“5万到10万”。Ambsheets会自动计算每种可能性下的收入范围，并用图表展示出来。你还可以拖动滑块，实时看到不同假设如何影响结果。

文章说，Ambsheets的价值在于它帮助人们“思考”，而不是“计算”。传统电子表格是确定性的，你输入一个数，得到一个数。但现实世界充满不确定性，产品经理、工程师、金融分析师都需要在模糊中做决策。Ambsheets让你可以轻松地探索“如果……会怎样”的场景，而不必手动构建复杂的模型。它甚至允许你输入文字描述，比如“用户增长可能会放缓”，然后系统会自动转换成数值范围。

这个工具还在实验阶段，但它的理念很有启发性：未来的工具应该更懂人的不确定性，而不是强迫人假装一切都很确定。就像文章说的，一个好的工具应该让你能“玩”数据，而不是被数据锁死。当你下次面对一堆数字时，不妨想想：有没有办法同时看到所有可能的结果，而不是只盯着一个？

Product Coaching and AI

想象一下，你是一个产品经理，每天要跟工程师、设计师、销售、老板开无数个会，还要分析数据、写文档、做决策。你手下没有直属员工，却要推动一群人做出好产品。这时候，如果有一个经验丰富的前辈坐在你旁边，每周跟你聊一次，帮你理清思路，告诉你哪些坑可以避开，你会不会觉得轻松很多？这种角色就叫产品教练（product coach）。硅谷产品集团（SVPG）那帮人，就是专门做这件事的。他们服务过很多公司，从初创公司到谷歌、微软这样的巨头都有。现在他们发现，人工智能（AI）正在改变产品教练的工作方式，而且这种改变不是让教练失业，而是让教练变得更强。

文章里讲了一个很具体的例子。一个产品教练在辅导一个团队时，发现团队成员对用户需求的理解不一致。以前，教练只能靠开会、提问、让大家画图来对齐认知，这个过程很慢，而且容易遗漏细节。现在，教练可以借助AI工具，比如让AI分析用户访谈录音，自动提炼出关键需求、痛点、情绪变化，然后生成一个可视化的需求地图。团队看到这个地图，一下子就明白了用户真正想要什么，争论立刻减少了。AI在这里不是替代教练，而是帮教练更快地做那些重复、琐碎的分析工作，让教练能把精力花在更高层次的判断上，比如“这个需求到底值不值得做”“用户说的和用户真正要的之间有什么差距”。

另一个场景是关于产品决策的。产品经理经常要面对很多选项，比如“这个功能该不该做”“先做A还是先做B”。以前教练会教产品经理用一些框架，比如机会评分（opportunity scoring）或影响与努力矩阵（impact-effort matrix），但每个框架都需要手动收集数据、计算、讨论。现在AI可以自动从历史数据、用户反馈、市场报告中提取信息，然后生成一个评分表，甚至给出建议。但教练的价值在于，AI的建议不一定对，教练需要帮产品经理理解AI为什么给出这个建议，以及哪些因素AI没有考虑到，比如公司战略、团队士气、合作伙伴关系。教练成了一个翻译者，把AI的分析结果翻译成人类能理解的决策依据。

文章还提到一个重要的观点：AI不是万能的，尤其在涉及人性、创造力、直觉的时候。产品教练的核心能力是建立信任、提出好问题、激发团队潜能，这些AI目前做不到。教练可以借助AI来放大自己的影响力，比如用AI生成多个版本的方案供团队讨论，或者用AI模拟不同决策的后果。但最终拍板的是人，教练要帮人学会做更好的决策，而不是依赖AI做决策。

所以，这篇文章真正想说的是：在AI时代，产品教练这个角色不会消失，反而会进化。他们会从“教你怎么做”变成“教你怎么用AI帮你做得更好”。对于产品经理来说，学会跟AI协作，把AI当成一个超级实习生，而不是一个全能老板，才是未来的核心竞争力。读完这篇文章，你会明白，产品教练的价值不在于他们知道多少答案，而在于他们能帮你提出更好的问题，而AI恰好能帮他们更快地找到那些问题的线索。

Four Levels Of Customer Understanding

你有没有遇到过这种情况：你做了一个产品，你觉得很好用，但用户就是不用；或者你做了很多调研，问用户想要什么，用户说了一堆，你照着做了，结果用户还是不满意。问题出在哪里？很可能是因为你只停留在表面理解用户，没有真正走进用户的心里。Smashing Magazine的这篇文章把用户理解（customer understanding）分成了四个层次，就像爬楼梯一样，每上一层，你对用户的认知就更深一层，产品也就更容易成功。

第一层叫“人口统计学理解”（demographic understanding）。这是最浅的一层，就是你只知道用户的一些基本属性，比如年龄、性别、收入、住在哪里。很多公司做用户画像（user persona）就停在这一层，比如“我们的用户是25到35岁的城市白领”。但问题是，两个同样年龄、同样收入的人，可能因为性格、生活方式、价值观的不同，对同一个产品的反应完全不同。这一层的信息只能告诉你“谁可能是用户”，但不能告诉你“用户为什么用你的产品”。

第二层叫“行为理解”（behavioral understanding）。这一层比第一层进了一步，你开始观察用户做了什么，比如他们点击了什么按钮、买了什么东西、花了多少时间。很多数据分析工具能帮你得到这些信息。但行为理解也有局限，因为它只告诉你“发生了什么”，不告诉你“为什么发生”。比如你发现用户很少点某个按钮，但你不知道是因为按钮位置不好，还是因为用户根本不关心那个功能。

第三层叫“情境理解”（contextual understanding）。这一层要求你把自己放到用户的使用场景中去。比如一个用户在用你的记账软件时，可能是在地铁上，只有几分钟时间；也可能是在家里，有半小时慢慢整理。不同的情境下，用户的需求和操作方式完全不同。如果你只看到行为数据，可能觉得用户“使用时长短”是一个问题，但如果你理解了情境，就会知道“短”反而是合理的，你需要让界面更简单、操作更快。

第四层叫“情感理解”（emotional understanding）。这是最高的层次，也是最难达到的。你要理解用户在使用产品时的情绪变化，比如焦虑、兴奋、沮丧、满足。文章里举了一个例子：一个用户用健身App记录跑步，如果App只显示“你跑了5公里”，用户可能没什么感觉；但如果App说“你比上次快了30秒，继续加油”，用户就会感到成就感。情感理解要求你不仅知道用户做了什么，还要知道用户做这件事时的感受，以及你的产品如何影响这种感受。

文章还提到，很多产品团队只做到第一层或第二层，因为这两层最容易用数据衡量。但他们忽略了，真正驱动用户持续使用产品的，往往是情感因素。比如用户为什么一直用某个社交App？不是因为它的功能多，而是因为朋友都在上面，用起来有归属感。这种归属感就是情感理解。

读完这篇文章，你会意识到，理解用户不是一次性的调研，而是一个不断深入的过程。你可以从问“用户是谁”开始，然后问“用户做了什么”，再问“用户在什么场景下做”，最后问“用户做的时候感觉怎么样”。每多问一个问题，你对用户的画像就更清晰一分，产品也就更容易打动人心。下次你听到有人说“我们很懂用户”，你可以想一想，他们懂到了第几层？

Insight Out 2025—how AI is reshaping customer understanding and the way product teams work

做产品的人一直有个头疼的问题：怎么才能真正知道用户想要什么？传统的做法是派一个人去跟用户聊天，或者发问卷，然后回来把零散的感受写成报告。这个过程很慢，而且不同人理解不一样，经常漏掉关键信息。Dovetail 这家公司做的工具就是帮产品团队整理用户研究资料的，比如把访谈录音转成文字、给内容打标签。他们最近发布了 2025 年的报告，核心发现是：人工智能正在改变这件事，而且速度比很多人想象的要快。

报告里提到一个很具体的场景：以前产品经理要花好几个小时听用户访谈录音，一边听一边记笔记，最后再自己总结出几个要点。现在有了 AI，工具可以自动把录音转成文字，然后直接识别出用户重复提到的痛点、愿望和情绪。比如用户反复说“这个按钮太难找了”，AI 能自动标记出来，并且统计有多少人说了类似的话。这样一来，产品团队就不需要靠某一个人的记忆来做判断，而是能直接看到数据背后真实的用户反馈。

但 AI 带来的不只是效率提升。报告指出，真正的变化是产品团队的工作方式变了。过去，用户研究的结论通常只停留在少数几个人手里，比如产品经理和设计师。其他人，比如工程师或者市场人员，很少直接接触到原始的用户声音。现在 AI 可以把这些信息整理成所有人都能看懂的形式，比如自动生成用户旅程地图或者痛点列表。这样整个团队，甚至公司里不同部门的人，都能基于同一套事实来讨论产品该怎么做。这听起来简单，但实际影响很大：它减少了“我觉得用户需要什么”这种主观猜测，让决策更贴近真实用户。

不过报告也提醒，AI 不是万能的。它擅长识别模式，比如发现很多人都在抱怨同一个功能，但它不理解这些抱怨背后的情感和上下文。比如用户说“这个功能让我很沮丧”，AI 能检测到“沮丧”这个情绪词，但它不知道这个用户是不是因为今天心情不好才这么说。所以报告强调，AI 应该辅助人，而不是替代人。最好的做法是让 AI 先做粗筛和整理，然后由人来解读和做最终判断。比如 AI 把几千条用户反馈按主题分组，产品经理再仔细看每组里的典型例子，理解用户到底在什么场景下遇到了麻烦。

最后，报告给出一个很实际的建议：产品团队应该从现在开始尝试让 AI 参与到用户研究流程里，哪怕只是从一个小项目开始。比如下一次做用户访谈时，用 AI 工具自动生成摘要，然后对比自己手动做的笔记，看看有没有遗漏。这样慢慢积累经验，团队才能知道 AI 在什么情况下最有用，在什么情况下需要谨慎。读完这篇报告你会感受到，AI 不是来抢产品经理工作的，而是来帮他们更高效地理解用户，让产品变得真正对用户有用。

Two heads are better than one: Building strong partnerships in the modern workplace

很多人觉得上班就是一个人对着电脑干活，但实际工作中大部分时间都在跟人打交道。尤其是做设计、工程和产品的人，他们需要紧密合作才能把一个想法变成真正的产品。Slack 的设计团队写了一篇文章，讲的就是这种合作怎么才能做好。他们不是空谈理论，而是用一个很具体的比喻开头：两个人一起干活，比一个人强。但前提是这两个人得知道怎么配合。

文章里举了一个例子：设计师和工程师一起做一个新功能。设计师画好了界面图，工程师开始写代码。但写着写着发现，有些设计在技术上行不通，或者实现起来特别慢。这时候如果两个人各干各的，设计师会觉得工程师不尊重他的设计，工程师会觉得设计师不懂技术限制，最后项目延期，大家都不开心。Slack 的设计团队说，更好的做法是让设计师和工程师从一开始就一起讨论。设计师在画图的时候，就可以找工程师问一句：“这个动画效果，技术上大概要多久？”工程师也可以主动说：“这个布局在手机上可能显示不好，我们换个方式？”这样双方提前知道了对方的难处，就能一起想出既好看又好实现的方案。

这种合作方式有一个专门的说法，叫“伙伴关系”（partnership）。文章强调，伙伴不是指两个人职位一样或者级别一样，而是指他们愿意把彼此的专业知识当成资源，而不是障碍。设计师懂用户需要什么，工程师懂技术能做什么，市场的人懂怎么推广，这些角色凑在一起，才能做出真正好用的产品。Slack 自己内部就经常让设计师和工程师坐在一起办公，甚至一起参加用户访谈，这样工程师也能直接听到用户的抱怨和期待，而不是只从设计文档里间接了解。

不过，文章也指出，建立这种伙伴关系并不容易。它需要信任，而信任来自日常的小事。比如工程师帮设计师解决了一个技术难题，设计师帮工程师理解了用户为什么需要一个看似奇怪的功能。这些小事积累多了，双方才会愿意在遇到分歧时先听对方说，而不是直接争吵。Slack 还提到一个很实际的建议：定期开短会，比如每周一次，让不同角色的人同步一下各自在做什么、遇到了什么困难。这种会不是为了汇报进度，而是为了让彼此知道对方的工作状态，从而主动提供帮助。

读完这篇文章，你会明白一个道理：好的产品不是一个人画出来的，也不是一个人写代码写出来的，而是一群不同背景的人通过不断沟通和妥协，共同创造出来的。而要做到这一点，每个人都需要放下“我懂你不懂”的姿态，真正把对方当成一起解决问题的伙伴。这种思路听起来简单，但实际做起来需要刻意练习，而 Slack 的文章给了很多具体的做法，值得每一个在团队里工作的人参考。

Designing for Mobile Accessibility: Enhancing the User Experience on Small Screens

你有没有在手机上点过一个按钮，手指按下去，却点到了旁边的链接？或者打开一个App，字小得眯起眼睛才能看清，菜单挤在一起，稍微点偏就跳到了不想去的页面？这不是你的问题，是设计没有考虑到手机屏幕的特殊性。今天要聊的这篇文章，来自UX Matters，讲的就是怎么让手机上的应用对所有人更友好，尤其是那些视力不好、手指不灵活、或者暂时只能单手操作的人。

文章先讲了一个很常见的场景：你在地铁上，一只手握着扶手，另一只手拿着手机，拇指在屏幕上划来划去。这时候，如果App的按钮太小，或者间距太窄，你很难精准点中。设计师管这个叫“触摸目标”（touch target），也就是手指能可靠点击的区域。苹果和安卓都有官方建议：触摸目标至少要有44x44像素。但很多App的按钮只有30像素左右，看起来节省空间，实际上让用户反复点错，非常恼火。文章举了一个例子：某银行App的转账按钮只有38像素高，用户经常误点旁边的“账户明细”，导致操作中断。后来他们把按钮放大到48像素，误点率下降了35%。这不是一个技术问题，而是对人手指物理尺寸的尊重。

接着，文章谈到了色彩对比度（color contrast）。你可能没注意过，但有些人看屏幕时，浅灰色文字在白色背景上几乎看不见。手机屏幕小，环境光线变化大，在户外阳光下，低对比度的文字更难辨认。WCAG（网页内容无障碍指南，Web Content Accessibility Guidelines）要求普通文字与背景的对比度至少达到4.5:1，大号文字至少3:1。文章提到一个旅行App，它的出发日期用了浅灰色，在晴天户外根本看不清，用户不得不把手遮在屏幕上才能操作。后来设计师把文字改成深黑色，对比度提升到7:1，用户投诉立刻减少。这听起来很简单，但很多团队为了“美观”或“轻盈感”牺牲了可读性。

文章还重点讨论了手势操作（gestures）。手机App越来越依赖滑动、长按、双指缩放等手势。但对手部活动不便的人，比如关节炎患者或老人，这些手势很难完成。文章举了一个新闻App的例子：它把“收藏文章”设计成向右滑动，但很多用户无意中滑到了，或者滑不动。后来他们增加了一个“长按弹出菜单”的替代方式，用户可以选择用点击代替滑动。这个改动让老年用户的收藏率提升了20%。关键点是：不要只提供一种操作方式，要给人选择。

除了这些，文章还提到了字体大小可调、避免自动播放视频、给图片加文字描述（alt text）等做法。你可能觉得这些是“小众需求”，但文章引用了一个数据：全球有超过10亿人存在某种形式的残疾，其中很多人只是暂时性的，比如眼睛受伤、手臂骨折，或者只是手里拿着东西。也就是说，无障碍设计（accessibility）其实能让所有人受益。

读完这篇文章，你会意识到，手机App的友好程度不是靠花哨动画，而是靠那些看不见的细节：按钮够大、颜色够深、操作够简单。下次你打开一个App觉得顺手，很可能是因为有人替你想到了这些。

Don’t Outsource the Learning: Why Human-Led Research Still Matters in the Age of AI

你大概已经见过这样的画面：一家公司想了解用户为什么不喜欢某个功能，于是把几千条聊天记录扔给人工智能，几分钟后收到一份报告，写着“用户主要抱怨加载速度慢”。报告看起来有理有据，但产品经理拿着它去改代码，改完后用户依然不满意。问题出在哪里？出在公司把“学习”这件事外包给了机器。

尼尔森诺曼集团（Nielsen Norman Group）是一家专门研究用户体验的权威机构，他们在这篇文章里提醒大家：人工智能可以帮你整理数据，但它不能替你理解人。理解人这件事，必须由真人研究者亲自去做。为什么呢？因为用户说出来的话，和用户真正经历的事，中间常常隔着好几层。比如一个用户说“这个按钮不好找”，背后可能意味着他当时很着急、页面太花了、他刚被另一个弹窗打断了思路，或者他其实根本不想找按钮，只是不好意思承认自己没耐心。机器只能记录“不好找”这三个字，而一个有经验的研究者会追问、会观察、会从用户的表情和停顿里读出更多信息。

文章讲了一个具体的例子：一家公司用人工智能分析客服对话，发现“退款”这个词出现的频率很高，于是推断用户最关心退款流程。但真人研究者去现场看了几通电话后才发现，很多用户打电话来根本不是要退款，而是因为产品出了问题，他们只是随口说了一句“再这样我就退款了”。真正的问题不是退款流程复杂，而是产品本身有故障。如果只看人工智能生成的词频报告，公司就会花三个月优化退款页面，而用户真正需要的故障维修却没人管。

为什么公司容易犯这个错误？因为用人工智能做研究实在太方便了。你不需要招募用户、不需要安排访谈、不需要写观察笔记，只需要把数据喂给模型，它就能吐出漂亮的图表和关键词。但文章指出，这种便利付出了代价：你失去了对“上下文”的感知。上下文就是用户当时所处的环境、情绪、设备状态、社会关系等等。比如一个用户在深夜用手机访问网站，和他在办公室用电脑访问网站，行为可能完全不同。人工智能拿到的是剥离了上下文的数据，就像看一张只拍了人脸的证件照，你永远不知道这个人当时是刚跑完步还是刚哭过。

真人研究者能做什么机器做不到的事？他们会先花时间建立信任，让用户愿意说出真实想法。他们会注意到用户说“这个功能还行”时语气犹豫，于是追问一句“你刚才犹豫了一下，是有什么顾虑吗？”这一问，可能就挖出用户不好意思直说的痛点。他们还会走进用户的实际使用场景，比如去用户家里看他怎么用智能音箱，发现他因为客厅太吵，每次都要凑到音箱跟前喊，而音箱说明书上写的是“请在安静环境下使用”。这个发现，任何远程数据分析都得不到。

文章并没有否定人工智能的价值。它只是说，人工智能应该被当作研究者的助手，而不是替代品。研究者可以用人工智能快速处理大量数据，找出初步模式，但接下来的深度理解、原因探究、方案设计，必须由人亲自完成。就像医生可以用血液检测仪快速拿到指标，但诊断病情、制定治疗方案，还是得靠医生本人的经验和与病人的交流。

读到最后你会发现，这篇文章真正想说的是：当工具越来越强大时，我们反而要更珍惜那些工具无法替代的人类能力，比如好奇、共情、追问、以及把零散线索拼成一个完整故事的能力。如果你负责产品或者设计，下次想用人工智能快速出结论时，不妨先问自己：这个结论背后，有没有漏掉某个用户的真实处境？有没有可能，机器只是帮你省了时间，却让你错过了真正重要的东西？

How tech workers are feeling in 2026: a workforce splitting in two

2026年，科技行业里正在发生一场安静的裂变。你大概听说过硅谷裁员、AI替代岗位这些新闻，但真正在科技公司里工作的人，感受并不只是“工作变少了”或者“AI抢饭碗”这么简单。Lenny's Newsletter 的这篇文章通过大量调查，发现科技从业者的心态正在分裂成两个截然不同的群体。一半人越来越焦虑，觉得自己随时可能被优化掉，另一半人反而觉得机会变多了，甚至比以前更主动、更乐观。这种分裂不是随机的，而是由你所在的岗位、你服务的公司类型，以及你掌握的技能共同决定的。

文章里提到一个很具体的场景：在那些已经大规模部署人工智能（AI）的公司里，做重复性工作的员工，比如初级数据分析、客户支持、内容审核，开始感到自己的价值在快速下降。他们每天做的事情，AI 已经能做七八成，剩下的两成也正在被自动化工具蚕食。这些员工发现，自己很难证明“为什么公司还需要我”。与此同时，做产品策略、复杂系统设计、跨团队协调的人，反而因为AI 承担了基础工作，得以把精力放在更高层次的问题上。他们的工作变得更像“指挥”而不是“执行”，因此满意度反而上升了。

这种分裂还体现在公司类型上。文章指出，那些仍然依赖传统软件外包或维护老旧系统的公司，员工普遍感到停滞和不安，因为这类工作很容易被更低成本的自动化方案取代。而专注于前沿领域，比如人工智能产品、企业级软件服务（SaaS）、数据基础设施，的公司，员工则更自信，因为他们做的事情门槛高、变化快，AI 暂时还很难替代。一个有趣的数字是，调查中超过六成在AI相关公司工作的人表示，过去一年他们的职业安全感反而增强了，而传统软件公司里只有不到三成的人有同感。

文章还捕捉到一种微妙的心态变化：过去科技从业者习惯把“学习新技能”当成一种保险，觉得只要自己不断学，就不会被淘汰。但2026年的现实是，学习的节奏已经赶不上工具更新的节奏。很多人发现，自己刚学会一个AI工具，下一个版本又出来了，而且能力更强。于是，焦虑的人开始怀疑“学什么都来不及”，而乐观的人则把注意力从“学工具”转向了“学判断”，如何定义问题、如何评估AI的输出、如何把不同AI的能力组合起来解决真实世界的麻烦。这两种心态的分歧，才是真正决定一个人未来走向的关键。

最后，文章给出一个很实用的观察：未来几年，科技行业里最稀缺的能力可能不再是写代码或者调模型，而是“翻译”，把业务需求翻译成AI能理解的任务，再把AI的输出翻译回人类能使用的决策。那些能做好这种翻译的人，不管在哪个公司，都会成为两个群体中更安全的那一半。而只依赖单一技能、不愿意面对不确定性的人，则可能越来越被动。读完你会明白，2026年的科技职场不是简单的“好”或“坏”，而是一面镜子，照出每个人对自己工作的理解到底有多深。

Backstitch 01 · Version Control for Space and Structure

想象你正在用画板软件画一张海报，画到一半，你觉得刚才删掉的那行字其实更好，于是按了撤销。但撤销只能回到上一步，如果你后来又画了十步，就再也回不到最初那个版本了。更麻烦的是，如果你想把海报的标题和背景分开调整，软件根本不理解“标题”和“背景”是什么，它只知道你画了哪些像素。这其实是今天几乎所有创意工具的共同问题：它们只记得你做了什么，不记得你做了什么结构。

Ink & Switch 实验室的 Backstitch 项目，想解决的就是这个“结构”问题。他们发现，人们在写文档、画图、做设计时，真正在做的其实是在反复调整内容的空间关系和逻辑关系，比如把一段文字从左边移到右边，把一张图片放到另一张图片前面，或者把一个大主题拆成几个小部分。但现有工具把这些操作都记录成扁平的历史列表，就像一本只按时间顺序记事的日记，不告诉你哪些修改是针对标题的、哪些是针对背景的。

于是他们做了一个叫 Backstitch 的原型工具，核心想法是“版本控制”不应该只控制时间，还应该控制空间和结构。什么意思呢？举个例子，你在 Backstitch 里写一篇文章，你可以把文章分成几个“区域”，每个区域有自己的版本历史。你修改了第一段，第一段的版本会单独保存，不会和第二段混在一起。你甚至可以给每个区域打标签，比如“标题区”“正文区”“脚注区”。这样一来，当你发现标题改坏了，你只需要回退标题区的版本，正文完全不受影响。这就像给每个房间单独装了一个时光机，而不是整栋房子只有一个。

更妙的是，Backstitch 还允许你“并行”探索不同的结构。比如你正在设计一个网页的布局，你可以同时尝试三种不同的排列方式，每种方式都保存在独立的“分支”里。你可以在分支之间来回切换，对比效果，甚至把其中一个分支的某一部分合并到另一个分支里。这听起来有点像程序员用的 Git 版本控制系统，但 Git 是为代码设计的，普通人很难用。Backstitch 的目标是用视觉化的方式，让设计师、作家、产品经理这些非程序员也能享受版本控制的好处。

当然，这个项目还处于早期研究阶段，他们只做了一个可交互的原型，用来验证想法。但背后的洞察很扎实：创作的本质是不断调整结构，而现有工具把结构隐藏在了操作历史里。如果你曾经因为改了一处设计导致整张图崩掉，或者因为想找回一个旧版本而翻遍了几百步操作记录，你就会明白 Backstitch 在解决什么。它不是在做一个更快的撤销按钮，而是在重新思考“版本”到底意味着什么，版本不只是时间的切片，更是空间和结构的快照。读完之后你会意识到，未来真正好用的创意工具，可能不再是一张无限画布，而是一个能理解你“在做什么结构”的智能画布。

Language Model Sketchbook, or Why I Hate Chatbots

你有没有跟聊天机器人说过话，然后觉得它像个话痨的推销员，问一句答十句，还总想把你往某个方向带？作者Maggie Appleton是位设计师兼插画师，她一直在画“语言模型速写本”，记录自己跟这些AI打交道的感受。她发现，现在主流的聊天机器人界面，本质上是在强迫我们跟一个“会说话的数据库”对话。但语言模型真正擅长的，不是陪你闲聊，而是帮你“画草图”，快速生成多种可能性，让你从中挑选、修改、组合。

她用一个比喻来解释：想象你有一个超级助手，你给他一个模糊的想法，他立刻给你十张草图，每张都略有不同。你挑一张，在上面涂改，他又根据你的修改再给十张。这才是语言模型该有的用法，而不是像现在这样，你问“今天天气怎么样”，它回答“今天天气晴朗，温度25度，适合户外活动，记得涂防晒霜”。这种“一次性给出完整答案”的模式，浪费了语言模型最强大的能力：生成多个版本，让你自己判断。

Maggie在文章里画了很多示意图。比如她展示了一个“可能性空间”：每个想法都是一片区域，语言模型可以快速在这片区域里采样，给你看不同角落的样子。而聊天机器人界面只给你看一个点，然后问你“还要继续吗？”这就像你走进一家餐厅，服务员只给你一道菜，吃完才让你点下一道。但更好的方式是，服务员先给你一个品尝拼盘，里面有好几种口味，你尝过之后说“这个多一点，那个少一点”。

她认为，问题出在界面设计上。聊天机器人（chatbot）的交互模式是从客服系统继承来的：用户提问，机器回答。但语言模型不是客服，它是创意工具。如果你把它当客服用，你会觉得它啰嗦、不准确、爱编造。如果你把它当速写本，你会觉得它灵感不断，只是需要你动手修改。Maggie自己就用语言模型来生成文章大纲、探索比喻、甚至设计图标。她不是直接问“给我一个图标”，而是说“我想表达‘连接’这个概念，给我五个不同的视觉比喻”。然后她看着那些比喻，有的太直白，有的太抽象，她挑一个改改，就有了自己的作品。

这篇文章的核心观点是：我们不应该让语言模型替我们做决定，而应该让它帮我们探索可能性。聊天机器人界面把用户放在被动接收的位置，而“速写本”界面把用户放在主动选择的位置。作者希望未来的AI工具能更像画板、调色盘、工具箱，而不是一个喋喋不休的对话者。读完你会明白，为什么有时候跟ChatGPT聊天很累，因为你本不该跟它“聊天”，你该用它“画草图”。

Is This Okay? How Override Labs Built a Safety-First AI Consent Coach for Teen Boys

如果你是个十几岁的男孩，在网上跟人聊天，对方发来一张不太合适的照片，你会怎么办？你可能不知道该怎么回应，甚至不确定这是不是正常的。Override Labs做了一款AI产品，专门帮青少年男孩处理这种尴尬又危险的时刻。它不是那种监视你聊天记录的家长控制软件，而是一个“同意教练”，在你犹豫的时候给你建议。

这家公司发现，很多青少年男孩其实想做个好人，但缺乏经验。他们不知道什么算越界，不知道怎么拒绝又不伤人，也不知道什么时候该说“不”。传统性教育教的是“要取得同意”，但没教具体怎么说。比如，对方说“发张照片看看”，你不想发，但怕对方生气，怎么办？这款AI会教你一句温和但坚定的话：“我还没准备好，我们慢慢来。”

产品团队花了大量时间跟青少年男孩聊天，了解他们的真实困扰。他们发现，男孩们最怕的不是犯错，而是被当成“怪人”或者“坏人”。所以AI的语气不能是说教，而是像一个大几岁的朋友，用他们能接受的方式说话。比如，当AI检测到对话中可能出现压力时，它会弹出一个选项：“要不要我帮你想想怎么回？”而不是直接替用户回复。

这款产品设计得非常谨慎。它不会自动读取聊天内容，而是需要用户主动点击“需要帮助”按钮。AI给出的建议也不是命令，而是几个可选方案。比如“你可以说‘哈哈这个有点过了’，或者‘我不太舒服，我们聊点别的’”。这样既保护了用户的自主权，又给了他们一个安全网。

Override Labs的创始人说，他们做这款产品的动力来自一个简单的问题：“我的儿子在网上遇到这种情况，我希望他怎么做？”答案是：希望他能有勇气说“不”，也知道怎么说“不”。这款AI不是要取代家长的沟通，而是给那些不好意思问家长的孩子一个随时可用的工具。

读完这篇文章，你会意识到，AI产品不一定要追求“智能”，有时候它更需要“体贴”。一个能理解青少年尴尬、不评判、只提供选项的AI，可能比任何监控软件都更能保护孩子。

Build vs Buy in the Age of AI

过去，一个公司想用软件解决一个问题，总要先做一道选择题：自己开发（build）还是买现成的（buy）。自己开发意味着要养一个技术团队，花几个月甚至几年写代码、修bug、上线，好处是软件完全按自己的需求来。买现成的则是从外面的软件公司买一个产品，比如用Salesforce管理客户关系，用Workday管人力资源，好处是马上能用，但功能只能按别人的设计走。这道选择题几乎每个公司都做过，而且通常很纠结。

现在人工智能（AI）来了，这道题的答案开始变得不一样。文章的作者是硅谷产品集团（Silicon Valley Product Group）的成员，他们长期观察科技公司怎么做产品，现在他们发现，AI正在模糊“自己开发”和“买现成的”之间的界限。过去，一家公司想做一个带AI功能的软件，比如一个能自动回答客户问题的聊天机器人，如果自己开发，需要雇AI专家、买算力、训练模型，成本极高；如果买现成的，只能买到通用产品，比如市面上的聊天机器人，功能固定，不一定适合自家业务。但现在，有了大语言模型（large language models，一种能理解并生成人类语言的AI技术，比如ChatGPT背后的技术），公司可以花很少的钱租用这些模型，再搭上自己公司的数据，就能快速做出一个高度定制化的AI功能。这既不是完全自己开发，也不是完全买现成的，而是一种新的混合方式。

作者举了一个例子来说明这种变化。假设一家保险公司想用AI来帮助理赔员快速审核理赔报告。过去，如果自己开发，需要从零训练一个模型，耗时耗钱；如果买现成的，市面上没有专门为保险理赔设计的AI产品。但现在，这家公司可以租用一个大语言模型，然后把自己公司过去成千上万份理赔报告和审核标准输入进去，让模型学习什么是好的理赔判断。这样，几周之内就能做出一个AI助手，理赔员把新报告贴进去，AI就能给出初步建议。这个AI助手既不是完全自研的，也不是现成的，而是“基于现成的AI能力，用自家数据定制出来的”。作者把这种方式叫做“组装”（assemble），意思是公司不再需要从零造轮子，而是把已有的AI部件和自家数据拼在一起。

这个变化对产品经理和公司决策者来说，意味着要重新思考怎么做产品。过去，产品经理在决定“自己开发还是买”时，主要考虑成本、时间、控制权。现在，因为AI能力变得像水电一样可以随时租用，产品经理可以更快地试验想法：先租一个AI模型，搭一个简单版本，看看用户是否真的需要这个功能，如果验证成功，再决定是否投入更多资源做深度定制。作者强调，这种新模式让产品发现（product discovery，即弄清楚用户真正需要什么的过程）变得更便宜、更快。过去，做一个AI功能可能需要先花几十万买服务器、雇专家，等做出来才发现用户不想要；现在，花几千块租几天AI模型就能做出原型，用户试了不满意就换方向，损失很小。

不过，作者也提醒，这种混合方式不是万能的。如果公司需要的AI功能非常特殊，比如要识别某种罕见疾病的医学影像，而市面上的通用AI模型根本没见过这种影像，那还是得自己从零训练模型。另外，如果公司对数据安全要求极高，比如银行不能把客户交易数据送到外面的AI模型去训练，那也得自己搭建全套AI系统。所以，选择题并没有消失，只是选项变多了：除了传统的“自己开发”和“买现成的”，现在多了一个“基于AI能力快速组装”。

读完后能带走的判断是：AI并没有消灭“自己开发还是买”这道选择题，而是给了一个更灵活的中间答案，先租用AI能力快速验证，再决定要不要深度投入。对没有技术背景的读者来说，这意味着未来你所在的公司可能会更频繁地尝试AI小工具，而且这些工具可能不是花大钱请人做的，而是产品经理用现成的AI模型和公司数据拼出来的。你不需要懂代码，也能参与讨论：这个AI功能真的解决了实际问题吗？数据给出去安全吗？这些才是更关键的问题。

A primer on product management for engineers

想象一个场景：你是一个工程师，正在写代码，突然产品经理跑过来说，客户的某个需求很紧急，能不能加个新功能？你问为什么，产品经理说“客户想要”。你回去写了两天代码，上线后客户却说不是这个意思。这种事情在科技公司里经常发生，因为工程师和产品经理之间互相不理解对方的角色。这篇文章就是写给工程师看的，解释产品经理到底在做什么，以及工程师怎么和产品经理配合得更好。

文章的作者是Increment杂志的撰稿人，Increment是一本专门讨论软件团队如何工作的杂志。作者指出，很多工程师觉得产品经理就是“传话筒”，把客户的需求原样转达给工程师。但实际不是这样。产品经理的核心工作是弄清楚“我们该做什么”，而工程师的核心工作是“怎么做出来”。一个优秀的产品经理，不会直接把客户说的“我要一个红色按钮”转给工程师，而是会先搞清楚客户为什么想要红色按钮，也许客户是想让按钮更显眼，那么解决方案可能是把按钮变大、加动画，甚至改变页面布局，而不是简单地涂成红色。产品经理要做的是定义问题，而不是定义解决方案。

作者用一个叫“产品发现”（product discovery）的概念来解释产品经理的工作方式。产品发现不是坐在办公室里猜用户想要什么，而是走出去和用户聊天、看用户怎么用产品、做实验验证想法。比如，产品经理可能会先做一个纸上的草图，拿给用户看，用户说“这不是我想要的”，那就不用浪费工程师的时间去写代码。或者产品经理做一个非常简陋的版本，只包含核心功能，让几个用户试用，如果用户觉得有用，再正式开发。这个过程就像侦探破案，产品经理收集线索，缩小范围，最后给工程师一个清晰的问题描述，比如“我们需要让用户能在三秒内找到最近的加油站”，而不是“在首页加一个加油站列表”。

文章还特别强调了一个常见的误解：产品经理不是老板。在好的公司里，产品经理和工程师是平等的合作伙伴，而不是上下级。产品经理负责决定“做什么”和“为什么做”，工程师负责决定“怎么做”和“什么时候能做好”。如果工程师觉得某个功能技术上不可行，或者有更好的实现方式，产品经理应该认真听取意见。反过来，工程师也应该理解，产品经理不是故意提无理需求，而是基于对用户和市场的了解在权衡。作者举了一个例子：产品经理说“我们需要支持一百万用户同时在线”，工程师说“那得花六个月重构服务器”。这时候双方需要一起讨论，能不能先支持十万用户，等产品验证成功再优化，而不是直接吵架。

对于没有技术背景的读者来说，这篇文章的价值在于理解一个科技公司内部是怎么协作的。你可能会听到“产品经理和工程师吵架”的故事，但真正的合作不是谁赢谁输，而是共同找到用户真正需要的东西。产品经理像翻译官，把用户的语言翻译成工程师能执行的任务；工程师像建造师，把任务变成实际可用的软件。如果翻译错了，建出来的房子就不是用户想要的。所以，下次你看到一个App更新了一个奇怪的功能，可以想想：这个功能是用户真的需要，还是产品经理和工程师没有配合好？

读完后能带走的判断是：产品经理和工程师不是对手，而是搭档。产品经理负责搞清楚“该造什么”，工程师负责“怎么造”。如果两者能互相理解对方的专业领域，产品就会更好用，工程师也不会白干活。对于非技术背景的读者，这个道理同样适用，在任何团队里，弄清楚“做什么”和“怎么做”是两件不同的事，需要不同的人来负责，但必须紧密沟通。

How we measure AI quality at Dovetail

你有没有用过那种号称“智能”的工具，结果它给你的答案完全不着调？比如你问它“帮我整理一下用户访谈里提到支付问题的部分”，它却把关于“支付”的闲聊也塞进来，或者干脆漏掉了关键内容。这就是AI质量的问题。Dovetail是一家做用户研究分析的公司，他们的产品靠AI帮用户从大量访谈录音、视频和文档里自动提取洞察。但AI不是天生就会做对事，它需要不断被衡量和调整。这篇文章就是Dovetail团队自己分享他们怎么给自家的AI“打分”，确保它真的有用而不是添乱。

他们用的方法听起来很直白，但做起来很讲究。核心是“人工评估”，也就是让人去检查AI的输出对不对。比如，AI从一段用户访谈里自动总结出“用户觉得注册流程太复杂”，那评估员就要看这个总结是不是准确、完整，有没有遗漏重要细节，或者有没有添加AI自己瞎编的东西。他们不只是看对错，还会给每个输出打分，比如“完全正确”“部分正确”“错误”。这样他们就能知道AI在哪些场景下表现好，哪些场景下容易翻车。

一个关键发现是：AI质量不能只看一个整体数字。比如整体准确率90%听起来不错，但如果你细分到不同任务，比如“提取用户痛点”和“提取用户建议”，AI的表现可能差很多。Dovetail团队会按任务类型、语言、甚至数据来源（是英文访谈还是中文访谈）来分别看质量。这样他们就能有针对性地改进，而不是盲目地优化所有地方。

另一个有意思的点是：AI质量不只是技术问题，还和用户怎么用它有关。比如，如果用户给AI的指令太模糊，AI就容易出错。Dovetail发现，当用户提供更具体的提示词时，AI的准确率明显提升。所以他们也在产品里加了一些引导，帮助用户写出更好的指令。这就像教一个人怎么用好工具，而不是只怪工具不好。

读完这篇文章，你可能会意识到一个道理：AI产品的质量不是一次测试就能定性的，它需要持续观察、分场景评估，并且和用户的使用习惯紧密相关。一个好的AI产品，背后一定有一套严谨的“体检”流程，而不是靠运气。

How to Make a Big Impact with a Small Team: Design Ops at Slack

想象一个只有几个人的设计团队，却要负责一个几千万人用的产品。这就是Slack的设计团队曾经面临的局面。Slack是那个很多人用来和同事聊天的办公软件，它的设计团队一度非常小，但要做的事情却很多：设计新功能、维护已有界面、确保所有产品体验一致、还要和工程师、产品经理等不同角色配合。这时候，一个叫“设计运营（Design Ops）”的角色就出现了。它不是设计师，也不是管理者，而是一个专门帮设计团队“扫清障碍”的人。

这篇文章来自Slack的设计团队，他们分享了设计运营具体做了什么。简单说，设计运营就像团队的“后勤总管”。比如，当设计师需要和工程师沟通时，设计运营会建立一套标准流程，让双方都知道什么时候该做什么，避免反复扯皮。又比如，当团队要同时做好几个项目时，设计运营会帮忙排优先级，确保最重要的事情先被处理。他们还负责收集用户反馈，整理成设计师能直接用的信息，而不是让设计师自己去翻海量数据。

一个具体的例子是，Slack的设计运营团队创建了一个“设计系统”。这个系统里包含了所有按钮、颜色、字体等设计元素的标准样式。这样设计师就不用每次从头画一个按钮，直接拿来用就行，而且保证整个产品的视觉风格统一。他们还设立了“设计评审”机制，让设计师定期互相看作品、提建议，帮助大家共同进步。

文章里还提到一个很重要的观点：小团队要产生大影响，关键不是拼命加班，而是把精力花在最有杠杆效应的事情上。设计运营做的就是找到那些“做一次能帮到所有人”的事情，比如建立模板、优化流程、共享资源。这样一来，设计师就能把更多时间花在真正需要创意和思考的设计工作上，而不是被杂事拖累。

读完这篇文章，你会明白一个道理：在一个大公司里，一个很小的团队也能做出很大的改变，前提是有人专门负责让团队高效运转。设计运营不是设计本身，但它让设计成为可能。这就像一支球队里，除了球员，还需要教练、队医和后勤，他们不直接得分，但少了他们球队赢不了。

Designing for the User: How Form Insights Shape UX Design Decisions

你打开一个网站，想注册账号。你填完姓名、邮箱、密码，点击提交。页面告诉你“密码格式不对”，但没说哪里不对。你改了好几次，还是不行。你有点烦，可能就关掉页面，去用别家的服务了。这个场景，就是用户体验（user experience）糟糕的典型例子。用户体验说的是一个人使用一个产品或服务时的全部感受，包括好不好用、顺不顺心、有没有被理解。

文章讲的是，好的产品设计不能只靠设计师的直觉，而要真正从用户的行为里找线索。比如用户填表单（form）时，总在某个字段（field，就是输入框）卡住，或者反复填错，这些细节就是“形态洞察”（form insights）。形态洞察不是看用户说了什么，而是看用户做了什么，鼠标在哪里停留、删除了什么内容、提交前犹豫了几秒。这些动作背后藏着用户的困惑和真实需求。

举个例子。一个电商网站发现，很多用户在“地址”这一栏填到一半就离开了。设计师原本以为用户嫌麻烦，但一看数据发现，问题出在地址字段的格式太死板。用户习惯写“北京市朝阳区”，但系统只接受“北京 朝阳区”这种写法。用户反复改，改不对，就走了。设计师把输入框改成更灵活的格式，允许用户按自己的习惯写，系统再自动识别。结果，填完地址的用户多了很多。

这个例子说明，用户的行为数据比用户说的话更可靠。用户不会告诉你“你的地址框格式有问题”，但他们会用行动告诉你，他们填到一半就放弃，或者填错很多次。设计师要做的，就是观察这些行动，找到问题，然后改掉它。

文章还提到一个关键概念：认知负荷（cognitive load）。认知负荷是指一个人完成一项任务时，大脑需要同时处理的信息量。如果表单太复杂，或者每一步都让用户思考“这里该填什么”，用户的认知负荷就会很高，容易累，容易出错。好的设计要降低认知负荷，比如用清晰的标签、合理的分组、实时的错误提示，让用户不用动脑子就知道该怎么做。

最后，文章强调，设计决策不能拍脑袋，而要基于数据。这个数据不是冷冰冰的数字，而是用户行为背后的故事。读懂这些故事，才能做出让用户觉得“这个产品懂我”的设计。读完你会明白，一个好的表单，不只是把问题问完，而是让用户感觉不到自己在填表单。

Crafting AI Explanations for Every Role in Your Enterprise

想象一下，你是一家大公司的市场部员工，老板突然说：“下周开始，我们用一个AI工具来帮忙写营销文案。”你打开这个工具，输入几个关键词，它立刻生成了几段话。但你心里犯嘀咕：它为什么选这些词？它从哪里学来的？它会不会把我公司的机密信息泄漏出去？你不敢直接用，又不好意思问。这种困惑，在越来越多的公司里正在发生。

这篇文章来自尼尔森诺曼集团（Nielsen Norman Group），一家专门研究用户体验的机构。它讲的是：当一家企业给员工、客户或者合作伙伴使用AI产品时，不能只把AI当成一个黑盒子（black box，意思是内部运作完全不透明的东西）。不同的人需要不同层次的解释，否则他们要么不敢用，要么用错了，要么出了问题也不知道找谁。

比如，一个普通员工最关心的是：这个AI能帮我做什么？它靠谱吗？我用它会不会犯错？而一个技术主管可能更想知道：这个AI用的是哪些数据？它怎么保证不产生种族歧视或性别歧视的偏见？公司的法务则要问：如果AI给出的建议导致公司赔钱，责任算谁的？所以，给AI做解释，不能一套说法走天下。

文章里举了一个例子：一家医院引入AI来辅助诊断疾病。医生需要知道AI为什么推荐某种治疗方案，是依据病人的年龄、病史，还是最新的研究论文？而病人只需要知道这个AI是辅助工具，最终决定权在医生手里，而且自己的隐私数据会被保护。如果医院只给医生一份技术文档，给病人一份免责声明，双方都会不满意。

那好的解释应该长什么样？文章提出了一个框架：解释要分三个层次。第一层是“这是什么”（what），告诉用户AI能做什么、不能做什么。第二层是“它怎么做”（how），用简单的语言说明AI的工作原理，比如“它分析了过去十年里一百万份类似病例”。第三层是“为什么是这个结果”（why），给出具体理由，比如“因为它发现你的症状和某种罕见病的早期迹象匹配”。

不同角色需要不同深度的解释。高层管理者可能只需要第一层，用来决定是否投入资源；一线员工需要第二层和第三层，才能放心使用；而审计人员可能需要更底层的技术细节。文章建议企业做一个“解释矩阵”（explanation matrix），把用户角色列成行，把解释层次列成列，然后针对每个格子设计内容。

还有一个容易被忽视的点：解释的时机。不是等用户问才给解释，而是在用户第一次接触AI时、在使用过程中、以及遇到错误时，主动提供解释。比如，当AI给出一个低置信度的结果时，应该弹出一条提示：“这个判断的把握只有60%，建议你复查一下。”而不是让用户自己猜。

这篇文章的核心观点是：AI的解释不是技术文档，而是用户体验的一部分。如果企业只关注AI的算法有多强，却忽略了向不同角色解释清楚，那么再强的AI也很难真正落地。读完之后你会明白，一个好的AI产品，不仅要“会做事”，还要“会说话”，用每个人都能听懂的语言，告诉他们这个AI到底在干什么。

Make something agents want

想象你是一个软件开发者，过去十年你的工作就是写代码给人用。你要考虑人的眼睛怎么看、手指怎么点、阅读习惯是什么。但现在出现了一个新用户，它没有眼睛，没有手指，却可能比你见过的任何人类用户都更挑剔、更没有耐心。这个新用户就是AI代理（AI agent），也就是能自主完成任务的智能程序。这篇文章的作者认为，未来几年，最成功的工具可能不是那些让人用得舒服的东西，而是那些让AI代理用得顺心的东西。

为什么AI代理会变成重要用户？因为越来越多公司会把重复性工作交给AI代理去做。比如一个电商公司可能会让AI代理每天自动检查竞争对手的价格并调整自己的定价。这个代理需要访问价格数据、理解格式、做出决策、执行修改。如果它要用的工具界面是为人类设计的，比如一个需要点击按钮、填写表单的网页，那代理就会很痛苦。它得模拟人类点击，容易出错，速度也慢。但如果工具本身提供干净的应用程序接口（API，即程序之间直接对话的方式），代理就能像两个程序握手一样瞬间完成数据交换。

文章里举了一个很具体的例子。作者认识一位创业者，他做了一个给AI代理用的日历工具。传统日历App是为人类设计的，有漂亮的界面、拖拽功能、颜色标记。但这个创业者的日历没有界面，只有API。AI代理可以通过API直接查询空闲时间、创建事件、发送邀请。结果这个工具在AI代理圈子里非常受欢迎，因为代理不需要“看”日历，只需要“读”数据。作者说这就是“让代理想要”的产品。

那怎么判断你的产品是不是代理想要的？作者给出了几个思考角度。第一，你的产品有没有清晰的、机器可读的输入输出？如果数据散落在PDF里或者需要登录才能看到，代理就很难用。第二，你的产品有没有稳定的数据格式？如果今天返回JSON（一种结构化的数据格式），明天变成XML（另一种格式），代理就会混乱。第三，你的产品有没有幂等性（idempotency）？这个词听起来复杂，但意思很简单：同一个操作做一次和做一百次，结果应该一样。比如“把价格设为10元”，做一次是10元，做一百次还是10元，这就是幂等。如果操作是“增加10元”，每做一次价格就涨10元，那代理重复调用时就会出大问题。

这篇文章的核心洞察是，当AI代理成为主要用户时，产品设计的优先级会彻底改变。过去我们花大量时间优化人类用户的首次体验（onboarding），比如注册流程、引导教程。但AI代理不需要这些。它需要的是清晰的文档、稳定的接口、可预测的行为。作者甚至建议开发者应该先为代理设计，再为人设计。因为代理的容忍度更低，如果代理用不了，人类用户根本就不会有机会用。

读完后你会带走一个判断：未来的软件市场可能会分裂成两个世界，一个世界是为人类设计的漂亮界面，另一个世界是为AI代理设计的干净接口。而后者可能增长更快，因为代理不会抱怨，只会沉默地选择另一个能工作的工具。如果你在考虑做一个新工具，不妨先问问自己：如果我的用户是一个没有耐心的AI程序，它愿意用我的产品吗？

This solo builder runs 24/7 local AI on his own hardware | Alex Finn

想象一下，你是一位独立开发者，不想依赖任何云服务，也不想把数据交给大公司，但你仍然想用上最新的人工智能。大部分人会觉得这不可能，因为训练和运行大型语言模型需要昂贵的显卡和复杂的服务器。但本文的主角 Alex Finn 却做到了。他一个人在自己的硬件上搭建了一套 24 小时运行的本地人工智能系统，不仅能写代码、回答问题，还能处理图像和音频。这听起来像是极客的玩具，但实际上，它揭示了一个正在发生的趋势：人工智能正在从云端走向个人设备，而独立开发者也可以成为这个趋势的参与者。

Alex 的配置并不神秘。他买了一台普通的台式机，装上了几块消费级的显卡，然后安装了一些开源的人工智能模型。关键是他没有使用任何云服务，所有计算都在自己家里完成。这意味着他不需要每月支付昂贵的云账单，也不用担心数据泄露。更重要的是，他可以完全控制系统的行为，比如调整模型的回答风格或者限制它访问某些信息。这对于那些对隐私敏感的用户来说，是一个巨大的吸引力。

但运行本地人工智能并不是插上电就能用那么简单。Alex 遇到了很多麻烦，比如如何让不同模型协同工作，如何管理内存，以及如何保证系统稳定运行。他像一个修理工一样，不断调试和优化。最终，他建立了一个叫做“本地人工智能工作站”的东西，可以同时运行多个模型，比如一个用于聊天，一个用于翻译，另一个用于图像识别。他的故事告诉我们，虽然门槛不低，但只要有耐心和一定的技术基础，个人也能拥有自己的“人工智能服务器”。

这篇文章的价值在于，它让我们看到了人工智能民主化的另一种路径。通常，我们听到的民主化是指大公司提供廉价或免费的云端服务，但 Alex 的实践表明，真正的民主化可能意味着个人能够拥有和掌控自己的模型。这对于产品经理和创业者来说，是一个值得关注的信号：未来可能出现专门为本地硬件优化的人工智能应用，或者针对隐私敏感用户的付费产品。读完之后，你可能会重新思考“云优先”的假设，并意识到在人工智能领域，小团队甚至个人也能做出有意义的创新。

Rethinking The Experience Of System Tools

你每天用电脑和手机，但你有没有注意过那些藏在角落里的系统工具？比如清理磁盘、备份文件、调整网络设置的小程序。它们通常界面简陋，按钮密密麻麻，普通用户根本不敢乱点。这篇文章想讨论一个简单但重要的问题：为什么这些系统工具不能做得像其他App一样好用？

文章先举了一个例子：Windows的磁盘清理工具。你打开它，看到一个列表，里面写着“临时文件”“系统缓存”“缩略图”之类的词。每个词后面跟着一个数字，告诉你这些东西占了多少空间。但问题来了，作为普通用户，你根本不知道“系统缓存”是什么，删了会不会让电脑出问题。所以你只能全选，或者一个都不选。这个界面没有告诉你每个选项的后果，也没有帮你判断哪些可以安全删除。

文章说，系统工具的设计者往往默认用户是专家。他们觉得用户应该懂“缓存”“日志”“注册表”这些概念。但现实是，绝大多数用户只想解决一个具体问题，比如“电脑太慢了”“磁盘快满了”。他们需要的是清晰的引导，而不是一堆技术名词。

作者建议，系统工具应该像其他消费级产品一样，先理解用户的意图。比如，当用户打开磁盘清理工具时，它不应该直接展示文件列表，而是先问一句：“你想做什么？是腾出空间，还是加快电脑速度？”然后根据用户的回答，自动选择最安全的操作。如果必须让用户做选择，也要用日常语言解释每个选项的作用，比如“删除临时文件（这些文件是程序运行时产生的，删了也没关系）”。

文章还提到，系统工具的错误处理方式也很有问题。当工具遇到问题时，它通常会弹出一个包含错误代码的对话框，比如“错误0x80070005”。普通用户看到这个代码完全不知道该怎么办。作者建议，错误信息应该直接告诉用户“发生了什么”和“接下来该怎么做”。比如，“你没有权限访问这个文件夹。请点击这里，输入你的管理员密码。”

文章的核心观点是，系统工具不应该因为“技术性”而放弃用户体验。它们服务的对象是所有人，包括那些不懂技术的用户。设计者应该把用户放在第一位，用简单的语言和清晰的步骤来引导他们完成任务。

读完后你会意识到，那些我们习以为常的“难用”工具，其实完全可以变得友好。关键在于设计者是否愿意从用户的角度出发，而不是从技术的角度出发。下次当你遇到一个难用的系统工具时，你可以想：这不是我的问题，是设计者没有做好他们的工作。

Jacquard 01 · Versioning and provenance for empirical research

科学家做实验时，经常需要记录很多细节：用了什么材料、怎么操作的、得到了什么数据。这些记录非常重要，因为别人要能重复这个实验，才能验证结果是否可靠。但现实中，很多实验记录非常混乱，有的用Excel表格，有的写在纸上，有的甚至只存在研究者的脑子里。这导致了一个问题：当别人想重复实验时，根本不知道原始数据是什么，也不知道数据处理过程中发生了什么变化。

这篇文章介绍了一个叫Jacquard的工具，它专门用来解决这个问题。Jacquard不是要取代现有的记录方式，而是提供一个框架，让研究者可以更规范地记录实验的“版本”和“来源”。所谓“版本”，就是实验过程中每一步的修改记录；所谓“来源”，就是每一条数据是从哪里来的，经过了什么处理。

文章举了一个具体的例子：一个生物学家在做基因测序实验。她从实验室的机器里拿到原始数据，然后用一个软件进行清洗和过滤，再用另一个软件做分析，最后得到一组结果。在这个过程中，她可能修改了参数，也可能删除了某些异常数据。如果她不记录这些操作，别人拿到她的最终结果，根本不知道这些数字是怎么来的。

Jacquard的做法是，让研究者把整个工作流（也就是从原始数据到最终结果的每一步）都记录下来，并且每一步都自动生成一个“快照”。这样，任何人随时都可以回溯到任何一个步骤，看到当时的数据是什么样子，以及做了什么操作。这有点像代码开发中的版本控制工具（比如Git），但专门为科学研究设计。

文章还提到，Jacquard的设计理念是“非侵入性”，也就是说，它不会强迫研究者改变他们现有的工作习惯。研究者可以继续用他们熟悉的工具（比如Python脚本、R语言、Excel），Jacquard会自动捕捉这些工具的操作记录，并整合到一个统一的视图中。

读完之后你会理解，科学研究中“可重复性”是一个大问题。很多论文发表后，别人按照论文描述的方法去做，却得不到相同的结果，原因往往在于原始记录不完整。Jacquard这样的工具，正是为了让科学实验更透明、更可靠。它告诉我们，技术不只是用来提高效率，也可以用来建立信任。

Local-first software: You own your data, in spite of the cloud

你有没有过这种时刻：打开一个在线文档，发现网络断了，你只能盯着那个转圈的加载图标，一个字都改不了。或者你用的某个笔记软件突然宣布要改版，你的数据被迁移到了一个你完全不认识的格式里，而你只能接受。再或者，你订阅了一个在线服务好几年，有一天它关闭了，你连把数据导出的机会都没有。这些体验背后有一个共同的根源：我们把自己的数据交给了云端，而云端是别人的服务器，别人的代码，别人的商业决策。你只是在使用权上拥有它，而不是所有权。

Ink & Switch 这个研究实验室在 2019 年发表了一篇长文，提出了一个看似矛盾但极其务实的愿景，local-first software，本地优先的软件。它的核心主张是：把数据的主权还给用户，让数据存储在本地设备上，同时依然保留云端的协作能力。这听起来像是一个技术乌托邦，但文章不是从理想出发的，而是从一群软件开发者自己的痛苦出发的。他们试过用 Dropbox 同步代码、用 Google Docs 写文档、用 Notion 管理项目，每一次当网络不好、服务变更或者公司政策调整时，他们都会感到一种无力感。他们想要一种软件，像本地文件一样可靠，像纸质笔记本一样私密，同时又像现代协作工具一样可以多人同时编辑。

文章提出了七个原则来定义什么是 local-first。第一条是“数据归你所有”（Your data is yours），意思是数据应该以标准格式存储在本地，用户可以随时读取、备份、迁移，不需要依赖某个服务商的 API 或者导出功能。第二条是“网络不是必须的”（The network is optional），你可以在没有网络的情况下完整地使用软件，网络只是用来同步和协作的，不是用来运行软件的。

第三条是“你的设备就是你的服务器”（Your device is your server），你的电脑或手机本身就是数据的宿主，不需要一个中央服务器来授权每一次读写。还有“协作是平等的”（Collaboration is equal），没有主从之分，每个参与者都拥有完整的数据副本，可以离线工作，然后合并。这些原则听起来很理想，但实现起来有巨大的技术挑战，尤其是如何让多个用户离线编辑同一份数据之后还能无冲突地合并。

文章花了大量篇幅讨论一种叫做 CRDT（Conflict-free Replicated Data Type，无冲突复制数据类型）的技术，这是一种可以让不同用户独立修改数据、最后自动合并而不产生冲突的数据结构。它不是新东西，但在 local-first 的语境里，它成了核心基础设施。

文章并没有只停留在技术层面。它用了一个很具体的例子来说明 local-first 和传统云优先的区别：想象你在一架飞机上，没有网络，你想修改一份共享的项目计划。在 Google Docs 里，你打不开文件，因为文档需要从服务器加载。在 local-first 的软件里，文件就在你的本地硬盘上，你可以直接编辑，等落地联网后，你的修改会自动同步给其他人。这个场景可能不常发生，但它揭示了一个更深层的问题：当我们把软件的使用权建立在对网络的依赖上时，我们就放弃了在离线状态下的自主性。而这种自主性，对于写作、编程、设计、笔记这些需要深度思考的活动来说，恰恰是最宝贵的。

最后，文章没有宣称 local-first 会取代云优先。它承认云优先在很多场景下依然合理，比如需要大量计算资源、需要全局搜索、或者需要严格管控权限的企业应用。但它认为，对于个人创作、小团队协作、以及对数据主权有要求的场景，local-first 提供了一条更健康的路。这篇文章不是一篇技术论文，更像是一份宣言，一份写给所有被云端绑架过的用户的邀请函：你可以拥有你的数据，即使你依然使用云。

Home-Cooked Software and Barefoot Developers

你有没有想过，你每天使用的那些软件，其实绝大多数都不是为你一个人设计的。它们面向的是成千上百万的用户，所以功能必须通用，界面必须标准化，更新必须照顾大多数人的习惯。但你的生活是具体的。你可能需要一个只记录你家附近菜市场价格的记账本，或者一个只追踪你孩子学校活动日历的提醒工具，或者一个只管理你收藏的几百本电子书的小程序。这些需求太小众了，没有任何一家公司会专门为你开发一个软件。于是你只能将就，用 Excel 表格、用 Notion 模板、用各种通用工具拼凑出一个勉强能用的方案。

Maggie Appleton 在她那篇广为流传的文章《Home-Cooked Software and Barefoot Developers》里，给这种困境找到了一个温暖的类比：家常菜。就像你不会每天去米其林餐厅吃饭一样，你也不会每天都需要商业级的大型软件。很多时候，你需要的只是一道家常菜，简单、私人、按你的口味调整、不需要遵循任何食谱标准。而做这道菜的人，就是那些“赤脚开发者”（barefoot developers）。这个说法借用了“赤脚医生”的概念，指的是那些没有受过专业训练、但为了解决自己或身边人的具体问题而动手写代码的人。他们可能是老师、图书管理员、小企业主、退休工程师，甚至是一个高中生。他们写的软件通常很小，可能只是一个脚本、一个简单的网页应用、或者一个自动化的表格。这些软件没有漂亮的界面，没有用户手册，没有版本更新计划，但它们精准地解决了一个问题。

Maggie 在文章里分享了自己的经历。她曾经为她的妈妈写过一个简单的食谱管理工具，因为妈妈总是把食谱写在纸条上然后弄丢。这个工具只有她妈妈一个人用，界面粗糙，功能单一，但它解决了一个真实的问题。她还提到了很多类似的例子：有人写了一个工具来管理自己小图书馆的借阅记录，有人写了一个脚本来自动整理家庭照片，有人做了一个简单的网站来分享社区里的二手物品信息。这些软件的生命周期通常很短，可能只用了几个月就被新的方式取代了，但它们在那个时间段里提供了巨大的价值。

这篇文章的核心观点是，我们不应该把所有软件开发都交给专业团队和大型公司。当普通人也能动手创造自己的工具时，软件就变成了一种表达方式，一种解决日常问题的手艺。它不需要完美，不需要可扩展，不需要有商业模式。它只需要“够用”，并且属于创造者自己。Maggie 把这种实践称为“home-cooked software”，并认为它和家庭烹饪一样，是一种值得鼓励的文化。它让技术不再是少数人的特权，而是每个人都可以参与的活动。当然，她也承认这种软件有很多问题：安全漏洞、缺乏维护、数据丢失的风险。但她认为，这些风险是可以接受的，因为对于很多小需求来说，有这样一个凑合的工具，比没有要好得多。而且，当越来越多的人开始动手写自己的软件时，他们也会更理解技术的工作原理，更懂得如何保护自己的数据。

这篇文章读完之后，你可能会开始留意那些你每天在使用但从未想过可以自己动手改进的小工具。也许你不需要成为一个专业的程序员，你只需要一个想法，一点好奇心，和一个周末的下午。就像 Maggie 说的，你做的菜可能不好看，但它一定是为你自己做的。

Malleable software in the age of LLMs

想象一下，你正在用一款记账软件，突然想加一个功能：每次买菜支出超过200元时，自动弹出一条提示“今天买菜有点多，要不要看看优惠券？” 但软件里没有这个选项。你只能要么忍受，要么等产品经理排期，要么自己学编程。绝大多数人选择了忍受。这就是我们和软件之间长久以来的关系：软件是固定的、不可变的，用户只能使用它预设的功能，不能按自己的需求随意修改。但 Geoffrey Litt 在这篇文章里提出，大语言模型（LLM）的出现可能会改变这一切，让软件重新变得“可塑”（malleable）。

他提到一个关键概念：生成式界面（generative UI）。过去，用户界面是由设计师和工程师预先设计好的，每个按钮、每个输入框都有固定用途。现在，借助 LLM，界面可以动态生成，根据用户的自然语言指令实时调整。比如，你说“把这个表格按日期排序，并且高亮最近一周的数据”，LLM 就能生成一段代码，直接修改界面。这听起来像科幻，但已经有原型产品在尝试了。Litt 自己就做过一个叫“Malleable”的实验性工具，用户可以用自然语言直接编辑网页上的表格、列表和卡片，LLM 在背后生成对应的 HTML 和 JavaScript 代码。

但更值得思考的是，这不仅仅是技术上的进步，它可能重新定义“用户”和“程序员”的边界。Litt 引用了一个观点：真正的终端用户编程（end-user programming）不是让每个人都学会写代码，而是让用户能用自己最自然的方式，比如说话、比划、点选，来改变软件的行为。LLM 恰好提供了这个桥梁。它可以把模糊的意图翻译成精确的程序逻辑。例如，一个市场分析师不需要懂 Python，只需要说“把上周的销售数据和本周的对比，如果下降超过10%就标红”，LLM 就能生成一个脚本嵌入到电子表格里。

当然，这条路并不平坦。Litt 也指出了几个挑战：首先是可靠性，LLM 生成的代码可能出错，尤其在边界情况下；其次是安全，允许用户随意修改界面可能引入漏洞；最后是理解成本，用户需要学会如何向 LLM 描述自己的需求，这本身也是一种新技能。但无论如何，这篇文章描绘了一个诱人的前景：软件不再是冰冷的水泥建筑，而是可以随用户心意变形的黏土。当我们不再受限于“软件就是这么设计的”时，每个人都能成为自己数字环境的建筑师。

Agents First

你有没有想过，当软件不再需要你手动点击按钮，而是由 AI 代理（agent）直接替你操作时，界面会变成什么样？传统软件的设计围绕“人类操作”展开：按钮、菜单、表单，每一项都在等待你的手指或鼠标。但“Agents First”这个框架提出了一种截然不同的思路：未来的界面应该首先为 AI 代理设计，其次才考虑人类。这不是一个遥远的科幻场景，而是一个正在发生的产品设计转向。

举个具体的例子：假设你是一个电商卖家，每天需要处理大量订单、库存和物流信息。传统做法是登录后台，查看表格，点击“发货”，再填写快递单号。如果引入一个 AI 代理，你可以直接说“把今天所有未发货的订单都发出去，用顺丰，运费到付”。代理会登录系统，找到订单，调用快递 API，完成操作。这时，界面还需要为人类提供那些复杂的筛选按钮和批量操作吗？不一定。代理需要的是一套结构化的 API 或数据接口，而不是视觉上的按钮。

“Agents First”框架的核心观点是：当机器（代理）成为软件的主要使用者时，界面设计应该优先满足机器的需求，比如清晰的语义化数据、可编程的接口、稳定的输出格式，然后再考虑人类如何通过自然语言或可视化界面与这些代理交互。这有点像移动优先（mobile-first）设计原则的升级版：不是屏幕尺寸变了，而是使用主体变了。

这个框架还强调了一个关键变化：从“用户界面”到“代理界面”（agent interface）。传统 UI 的每个像素都是为人的眼睛和手指准备的；而代理界面则是为机器的解析和决策准备的。例如，一个天气应用的传统 UI 会显示图标、温度数字和风速箭头；而代理界面可能直接输出 JSON 格式的数据，附带置信度评分和单位。人类用户则通过一个聊天窗口或语音助手来间接使用这些数据。

当然，这并不意味着人类完全被排除在外。文章认为，最好的设计是“人机协作”模式：代理负责执行，人类负责监督和决策。界面需要提供清晰的反馈，让人类知道代理正在做什么、为什么这么做，以及如何干预。比如，代理在批量发货前，会生成一个摘要让你确认；如果遇到异常订单，它会暂停并询问你的意见。这种设计思路正在被一些前沿产品采用，比如某些自动化营销工具和智能客服系统。

“Agents First”并不是要消灭传统界面，而是提醒我们：当 AI 代理成为数字世界的“原住民”时，我们的设计原则需要重新思考。从按钮到对话，从表单到数据流，软件正在经历一次静默的范式转移。如果你正在构建一个依赖 AI 的产品，不妨问问自己：我的界面是为谁设计的？如果代理是第一用户，它需要什么样的信息架构？

The Architecture Of Local-First Web Development

你有没有遇到过这种情况：在地铁上打开一个文档，刚编辑完一段，信号断了，你眼睁睁看着光标不动，然后刷新页面发现刚才写的内容全没了？或者你在一个协作表格里填数据，突然网络卡住，你只能等，什么也做不了。我们太习惯这种体验了，以至于觉得在线应用就该这样，网络就是一切，没网就什么都干不了。但有一群人正在试图改变这个前提，他们管这个方向叫“本地优先”（local-first）。

这篇文章来自 Smashing Magazine，讨论的是本地优先的 Web 开发架构。它不是在推销一个具体框架，而是在讲一种思维转变：为什么不能让应用像原生软件一样，数据存在本地，网络只是用来同步的？这样哪怕你在地铁、飞机上，甚至网络彻底断了，你依然可以打开应用、编辑数据，等网络恢复后自动同步到云端和其他设备。这个想法听起来很美，但实现起来非常难。文章花了大量篇幅在解释为什么难，以及现有的几种架构方案是怎么试图解决这些难题的。

本地优先的核心挑战在于“冲突解决”。想象一下，你和同事同时修改了同一个文档的同一句话，你在离线状态下改了，他也在离线状态下改了，等你们俩都连上网，两个版本谁说了算？传统在线应用靠服务器做裁决，但本地优先的应用里，每个客户端都是平等的，没有中央服务器来拍板。所以你需要一种机制，要么自动合并，要么让用户手动选择。文章里提到了几种常见的策略，比如“最后写入者胜出”（last-writer-wins），但这在协作场景下很容易丢数据；或者更复杂的“操作转换”（operational transformation）和“无冲突复制数据类型”（CRDT），这些技术能自动合并大部分冲突，但实现成本很高，而且有些场景下仍然需要用户介入。

文章还详细拆解了本地优先应用的典型架构层：本地数据库、同步引擎、冲突解决策略和远程存储。它特别强调，不要把本地优先简单理解成“加个离线缓存”，因为传统的离线缓存通常是只读的，或者只缓存静态资源，而本地优先要求本地也有完整的读写能力。这意味着你的应用逻辑需要能在无网络状态下独立运行，数据模型也要设计成支持离线修改。作者还举了一个例子：如果你做一个待办事项应用，本地优先意味着你可以在没网时添加、删除、修改任务，这些操作都会先记录在本地，等有网时再同步到服务器。但如果你的应用涉及多人实时协作，比如一个共享购物清单，那冲突就不可避免了，你删除了“牛奶”，但伴侣在离线时又加上了“牛奶”，同步后到底该保留还是删除？

读这篇文章，你不需要立刻成为本地优先的专家，但你会意识到一个问题：我们现在的 Web 应用本质上把用户的控制权交给了网络，而本地优先试图把控制权还给用户和设备。它不是一个简单的技术选项，而是一种对用户体验的重新思考。文章最后也承认，本地优先并不适合所有场景，比如需要强实时一致性的金融交易系统，或者需要严格审计日志的合规场景。但对于文档编辑、笔记、项目管理、个人数据管理等大量日常应用来说，本地优先可能是未来更人性化的方向。读完你会开始留意，哪些应用其实可以做得更好，而不仅仅是依赖网络。

Product Leadership Archetypes

如果你在科技公司做产品，你可能听说过“产品经理”和“产品负责人”这些头衔，但“产品领导力”这个词听起来有点虚。它不像“写 PRD”或“排优先级”那么具体，但硅谷产品集团（SVPG）这篇文章试图把它讲清楚。文章提出了一个框架，把产品领导者分成了几种原型（archetypes），每种原型对应不同的能力组合、工作重点和适合的阶段。它不是为了给你贴标签，而是帮你理解：你现在更像哪一种？你团队里需要哪一种？以及，你未来想成为哪一种？

文章里提到的几种原型包括“产品愿景家”（Product Visionary）、“产品建设者”（Product Builder）、“产品增长家”（Product Grower）和“产品运营者”（Product Operator）。每一种都有鲜明的特征。比如产品愿景家，他们擅长描绘未来，能提出让人兴奋的长期方向，但可能不太关注日常执行和细节；产品建设者则相反，他们擅长从零到一，把想法变成可用的产品，注重快速迭代和工程协作；产品增长家更关注数据、实验和规模化，他们擅长在已有产品上找到增长杠杆；而产品运营者则擅长优化流程、提升效率，让产品团队运转得更顺畅。

文章特别强调，没有一种原型是“最好的”，关键在于匹配。一个初创公司早期可能需要产品愿景家来定义方向，但到了产品市场匹配（product-market fit）之后，可能更需要产品建设者来打磨体验，或者产品增长家来推动用户增长。如果公司已经成熟，产品运营者能帮助团队避免混乱。但问题在于，很多产品领导者只擅长一种原型，却试图在所有阶段都用同一套方法。比如一个愿景家型的产品 VP，在公司已经需要精细化运营时，仍然只讲宏大叙事，团队就会觉得他“不接地气”。反过来，一个运营者型的产品负责人，在需要探索新方向时过于关注流程和效率，可能会扼杀创新。

文章还讨论了如何识别自己的主导原型，以及如何补足短板。它建议产品领导者定期做自我评估，看看自己在哪些方面花时间最多，哪些方面被忽略了。同时，团队也需要多元化的领导力组合，不是要求一个人全能，而是不同原型的人可以互补。比如愿景家搭配一个建设者，就能既看到远方，又能把路铺好。

这篇文章的读者可能是一位正在困惑的产品总监，或者一位刚晋升为产品 VP 的人。它不会直接告诉你“该怎么做”，但会让你停下来想想：我现在扮演的角色，是不是公司真正需要的？我是不是在用自己舒适的方式工作，而不是用公司需要的方式？这种自我反思，往往比任何方法论都更重要。读完你会明白，产品领导力不是一套技能，而是一系列在不同情境下需要切换的思维模式。而真正的成长，就是学会在需要的时候，变成那个最合适的原型。

Harness engineering for coding agent users

想象一下，你是一个软件团队的负责人，刚刚给团队引入了一款能写代码的AI助手。大家都觉得新鲜，有人用它生成了几百行代码，有人让它帮忙写测试。但问题很快来了：这些代码到底能不能用？有没有安全隐患？AI生成的内容和团队自己写的混在一起，怎么保证质量？Martin Fowler在文章里讨论的，正是这个新现实下的工程挑战。他提出了一个概念叫“驾驭工程（harness engineering）”，意思是说，当AI成为编码的参与者时，团队需要一套新的工程实践来“驾驭”它，而不是放任它自由发挥。

为什么需要专门的驾驭工程？因为AI编码助手和人类开发者有一个本质区别：人类会主动理解上下文，知道自己为什么写这段代码，而AI只是根据提示词生成最可能的输出。它可能写出语法正确但逻辑有漏洞的代码，也可能引入过时的库或者不安全的模式。更麻烦的是，AI生成的代码往往没有“意图”，它不会告诉你它为什么这么写，所以审查起来特别困难。Martin Fowler举了一个例子：假设你让AI写一个处理用户输入的函数，它可能写得很漂亮，但忘了做输入校验。人类开发者看到这段代码，可能会想“这里应该加校验”，但AI不会主动提醒你。

那么驾驭工程具体怎么做？文章里提到几个方向。首先是“提示工程（prompt engineering）”的升级版，不只是教你怎么写提示，而是把提示当作代码的一部分来管理。团队可能需要建立提示词库，记录哪些提示能稳定生成好代码，哪些容易出错。其次是“测试策略”的改变。传统测试主要验证人类写的代码，但现在你需要测试AI生成代码的边界，比如故意给AI一些模糊的提示，看它会不会产生危险输出。还有“代码审查”的调整：审查者不仅要看代码本身，还要看AI生成它的上下文，甚至要判断AI是否被“误导”了。

文章还强调，驾驭工程不是一次性工作，而是需要持续维护的。因为AI模型在变，团队的使用方式也在变。今天好用的提示，下个月可能就失效了。Martin Fowler把这件事比作“驯马”：你不能把马放出去就不管了，得给它套上缰绳，训练它，还要随时观察它的状态。在AI编码的场景里，这个“缰绳”就是你的工程流程、测试用例和审查标准。

读到最后你会发现，Martin Fowler其实在说一个更根本的道理：AI不会取代工程师，但它会改变工程师的工作方式。以前你只需要写好代码，现在你还需要学会“驾驭”一个会写代码的AI。这听起来像额外负担，但如果你做得好，团队的生产力可能会翻倍。关键是，不要把AI当成一个黑盒子，而是把它当作团队里一个需要“管理”的新成员。

Expanding Stripe Radar to protect more of your business

如果你在网上卖东西，最怕的事情之一就是遇到欺诈交易。一个骗子用偷来的信用卡下单，你发货了，结果钱被银行追回，货也没了。Stripe的Radar产品就是专门对付这个问题的，它在支付瞬间分析交易风险，帮你拦截可疑订单。最近Stripe宣布扩展Radar的功能，让它能保护更多业务环节。

以前Radar主要盯着支付那一刻：用户的IP地址、设备指纹、历史行为，这些信息综合起来算出一个风险分数。如果分数太高，交易就被拒绝。但Stripe发现，欺诈的套路在变。有些骗子会先下一个小额订单试探，如果成功了，再下大单。还有些人会创建多个账户，慢慢“养号”，等账户看起来正常了再作案。这些行为在单次支付里可能看不出异常，但拉长时间线就能发现模式。所以Stripe给Radar增加了“账户级”的保护，比如监控账户创建速度、登录频率、订单取消率等。

另一个扩展方向是“争议管理（dispute management）”。以前Radar主要帮你预防欺诈，但万一交易还是出了问题，客户发起争议（也就是银行拒付），处理起来很麻烦。Stripe现在把Radar的能力延伸到争议阶段，比如自动收集证据、分析争议原因，甚至预测哪些争议值得申诉。文章里举了一个例子：一个卖电子产品的商家，经常因为“商品未收到”被争议。Radar分析后发现，这些订单的地址集中在某个区域，而且都是下单后几小时就发起争议。商家根据这个信息调整了发货策略，争议率立刻下降了。

Stripe还强调，Radar的扩展不仅仅是加功能，而是让保护变得更“智能”。比如它现在能识别“合成身份欺诈”，骗子用真实信息和虚假信息混合创建身份，传统规则很难识别。Radar通过关联多个数据源，比如把邮箱、电话、地址放到一起看，如果发现某个邮箱是新注册的，但电话已经出现在多个欺诈案例里，风险分数就会提高。

对于用Stripe的商家来说，这些更新意味着什么？简单说，就是更少的欺诈损失，更少的争议处理时间，以及更顺畅的用户体验。因为Radar拦截得准，真客户不会被误伤。Stripe在文章里给了一个数据：使用Radar的商家，欺诈率平均降低了65%。现在Radar覆盖了更多场景，这个数字可能会更高。

最后，Stripe提到一个关键点：欺诈防护不是静态的。骗子在进化，防御也必须进化。所以Radar的模型会持续学习，每次交易、每个争议都在帮助它变得更聪明。对于商家来说，这就像有了一个24小时不休息的保安，而且这个保安还在不断变强。

Craft in design: What it is & why it matters

你打开一个应用，点了一个按钮，页面切换了，动画流畅，文字清晰，每个像素好像都待在它该待的地方。你未必会专门夸它，但如果哪里不对劲，按钮弹出一毫米、颜色偏了一点点、加载时闪了一下白屏，你立刻就能感觉到。这种感觉，就是设计行业里常说的“工艺”（craft）。Slack 设计团队写了一篇文章，专门讨论这件事：为什么有些产品用起来就是比别人舒服？那种舒服到底是从哪来的？它是不是只是视觉上的“好看”？

文章开头讲了一个很具体的例子。Slack 的工程师和设计师在做一个新功能时，发现用户经常在消息列表里误触。他们不是加一个弹窗警告，而是花了很长时间去调整消息卡片之间的间距、阴影的深度、点击区域的边界，让用户的手指在滑动时自然避开错误目标。这看起来是“小修小补”，但背后是一种态度：设计不是把功能画出来就算完，而是要把每一个交互瞬间都打磨到让人感觉“理所当然”。文章把这个过程叫做“craft in design”，它不是锦上添花，而是产品信任感的基础。

那到底什么是“craft”？文章没有给一个干巴巴的定义，而是从几个侧面来说。首先，它是对细节的执着。比如 Slack 的加载动画，不是随便转个圈，而是用了一个细微的弹跳，让等待的几秒钟不那么焦虑。其次，它是跨角色的协作。设计师、工程师、产品经理一起盯着一个像素的偏移，讨论它会不会影响用户的理解。最后，它是一种持续的投入。不是上线就完事，而是每次迭代都重新审视那些“已经可以了”的部分。文章里提到一个比喻：好的工艺就像好的木工，榫卯严丝合缝，你不一定看到接口，但你知道它牢固。

文章也提醒，追求工艺不能变成自我陶醉。它最终要服务于用户的目标。如果一个按钮的动画慢了半秒，用户觉得卡顿，那再好看也是失败。Slack 团队的方法是：先让功能跑通，再一层层打磨。他们会在内部反复使用新版本，模拟真实场景，直到觉得“这个细节值得用户花时间”。这种态度让工艺变成了产品策略的一部分，而不是设计师的自嗨。

读下来，你能感受到 Slack 想传递的核心判断：工艺不是装饰，是信任。当用户觉得一个产品“靠谱”，往往不是因为它功能多，而是因为它每一个小地方都经得起推敲。这种信任很难建立，但一旦建立，用户就会愿意忍受产品暂时的不足，因为他们知道团队会继续打磨。所以，下次你被某个产品的流畅体验打动时，不妨想想那些躲在屏幕后面的设计师和工程师，他们可能为一个像素、一帧动画、一个点击区域，反复讨论了好几天。

How to power your product strategy with customer intelligence—a PM’s guide

你是一个产品经理，每天要开会、写文档、看数据，但最让你头疼的可能是：用户到底想要什么？你做了调研，分析了数据，可产品上线后用户还是不买账。Dovetail 的这篇文章就是给这种困境写的一本操作指南。它讲的不是怎么做调研，而是怎么把调研变成能驱动产品战略的东西，他们管这个叫“客户情报”（customer intelligence）。

文章先讲了一个常见的误区：很多团队收集了大量用户反馈，但都散落在会议记录、邮件、Excel 表里，没人去整理，更没人用它来决策。作者把这种状态叫做“数据丰富但情报贫乏”。那怎么改变呢？他们提出了一个三步走的方法。第一步是建立统一的客户洞察库，把所有的访谈记录、支持工单、用户测试、NPS 评论集中到一个地方，并且给它们打上标签。比如“注册流程”、“支付失败”、“竞品对比”这样的主题标签。第二步是定期做主题分析，不是看单个用户说了什么，而是看哪些问题反复出现。比如十个用户里有七个都提到“找不到设置按钮”，那这就是一个战略级的问题。第三步是把洞察转化成行动，比如开一个跨部门的“洞察同步会”，让设计师、工程师、市场人员一起看这些主题，然后决定优先级。

文章里举了一个具体的例子。某 SaaS 公司发现用户流失率很高，他们用客户情报工具分析后发现，用户并不是因为功能不够，而是因为 onboarding（新手引导）太复杂，用户在前两周内没有体验到核心价值。于是团队重新设计了引导流程，把“让用户完成第一个关键动作”作为目标，结果留存率提升了 20%。这个例子说明，客户情报不是让你去问用户“你想要什么”，而是让你从用户的行为和语言里发现他们真正的痛点。

文章还强调了客户情报和产品策略的关系。很多团队做年度规划时，拍脑袋定方向，然后去找数据验证。作者建议反过来：先看客户情报里反复出现的主题，再决定做什么。比如用户反复说“我需要更快的导出功能”，那你的路线图里就应该有性能优化，而不是加一堆新功能。这样产品策略就有了根基，而不是飘在空中的愿景。

最后，文章给了一个很实用的建议：不要等完美。哪怕只是把最近十次用户访谈的笔记整理出来，打上标签，你就能看到一些模式。然后每周花半小时回顾这些模式，问自己：这个星期我们做了什么来回应这些洞察？这样做下去，客户情报就会变成一种习惯，而不是一个项目。读完后你会明白，产品经理的核心工作不是画原型，而是把用户的声音翻译成产品决策。那些最成功的产品，往往不是因为技术最先进，而是因为他们最懂用户。

Bliki: Architecture Decision Record

很多软件团队都遇到过这样的场景：一个新成员加入项目，看着代码库里的某个关键设计，问“为什么这里要用消息队列而不是直接调用？”没人能立刻说清楚，因为当初做决定的人可能已经走了，或者大家早就忘了讨论的细节。更糟的是，几个月后，同样的争论又重来一遍，因为没有人记录下当初为什么选A而不是B。Martin Fowler 在 bliki 上介绍的架构决策记录（Architecture Decision Record，简称 ADR）就是为解决这个问题而生的。

它不是那种冗长的设计文档，而是一种轻量级的记录方式，专门用来捕捉每一个重要的架构决策及其背后的理由。一个典型的 ADR 只有几个部分：标题、状态（比如“已提议”“已接受”“已废弃”）、上下文（Context）、决策（Decision）和后果（Consequences）。上下文部分描述当时面临的问题、约束条件和可选方案；决策部分明确写下了最终选择以及为什么选它；后果部分则诚实地评估这个决策带来的正面和负面影响。

比如，一个团队决定用微服务架构，他们可能在 ADR 里写下：上下文是单体应用已经难以维护，团队规模扩大到 20 人，部署频率需要从每月一次提高到每周多次；决策是拆分为六个微服务，每个服务独立部署，理由是降低耦合、提升团队自治；后果则是增加了网络通信的复杂性、需要引入服务发现和分布式追踪。这个记录本身就是一个活文档，随着项目演进，状态可以变为“已废弃”，并引用新的 ADR 说明为什么放弃。Fowler 强调，ADR 的价值不在于记录了多少技术细节，而在于保留了决策的“为什么”。当新成员加入，或者老成员遗忘时，他们可以快速理解设计的初衷，避免重复踩坑。

更重要的是，ADR 让架构演进变得可追溯，你可以像读故事一样，看到团队是如何一步步做出权衡的。比如，为什么后来决定把某个服务合并回去？因为流量没预期大，拆分带来的运维成本超过了收益。这个理由记录在 ADR 里，就让后来的决策有了依据。如果你在团队里推行 ADR，可以从一个简单的模板开始，放在代码仓库的 docs/adr 目录下，每次做出重要架构决策时就写一篇。不用很长，三四百字就够了。关键是养成习惯，就像写代码注释一样自然。久而久之，它就会成为团队最宝贵的知识资产之一。

Research into how AI can help users understand skin conditions

想象一下，你发现手臂上长了一个奇怪的红色斑点，不疼不痒，但就是让人不放心。你可能会先上网搜一下，结果被各种图片和描述吓到，越看越觉得自己得了绝症。或者，你可能会直接去看皮肤科医生，但挂号排队可能要等好几周。Google Research 最近发表的一篇博客，介绍了他们如何利用人工智能帮助用户更好地了解自己的皮肤状况。这不是一个诊断工具，Google 反复强调，它不能替代医生，而是一个辅助工具，让用户在去看医生之前，能有一个更靠谱的参考。

具体来说，他们开发了一个基于 AI 的皮肤状况识别系统，用户可以用手机拍下皮肤、头发或指甲的问题区域，然后通过一个网页应用上传照片。系统会分析图像，并给出一个可能匹配的皮肤状况列表，比如湿疹、接触性皮炎、痤疮等，同时提供相关的医学信息和常见问题解答。这个系统的背后是一个深度学习模型，它经过了大量皮肤科图像的训练，包括不同肤色、不同年龄、不同身体部位的照片，以确保它对各种人群都公平有效。

Google 在训练数据上花了很多心思，特意收集了来自不同地区的皮肤图像，避免模型只擅长识别浅肤色人群的皮肤问题。在测试中，这个模型的准确率与皮肤科医生相当，但 Google 也坦诚，它仍然存在局限性，比如对于某些罕见病或早期症状可能不够敏感。所以，用户看到的结果只是一个参考，上面会明确提示“这不是医学诊断，请咨询专业医生”。这个工具的出发点很实际：很多皮肤问题并不紧急，但用户又需要一些初步信息来缓解焦虑或决定下一步行动。

比如，一个家长发现孩子腿上起了疹子，拍个照上传，系统提示可能是“接触性皮炎”，并建议避免接触可能的过敏原，同时推荐去看儿科或皮肤科。这样，家长就有了方向，而不是盲目猜测。Google 还特别注重隐私保护，用户上传的照片不会用于训练模型，只会在分析后删除。目前，这个功能已经在一些国家上线，作为 Google 搜索的一部分。你可以想象，未来这种 AI 辅助的自我评估工具会越来越普及，它不会取代医生，但能帮助人们更高效地管理自己的健康，尤其是在医疗资源紧张的地区。

Building OpenCode with Dax Raad

你有没有想过，一个独立开发者是怎么从零开始，把一个AI产品做出来的？Dax Raad就是这样一个开发者，他做了一个叫OpenCode的产品，本质上是一个能帮你写代码的AI助手。但这个故事有意思的地方，不在于AI本身有多厉害，而在于他做产品的过程，几乎每一步都和我们熟悉的“大公司做法”反着来。

Dax Raad之前做过一个叫Screenshot.rocks的产品，赚了一些钱，也积累了对开发者工具的理解。他注意到，虽然GitHub Copilot已经很强了，但很多开发者其实想要一个更开放、更可定制的版本。于是他就开始做OpenCode，一个开源的AI代码助手。你可能会想，开源怎么赚钱？他选择了一种很直接的方式：基础功能免费，高级功能收费，同时代码完全公开，任何人都可以自己部署。

他的开发方式也很特别。他不做用户调研，也不写详细的需求文档。他直接把自己当成用户，每天用自己写的工具写代码，哪里不舒服就改哪里。比如他发现AI生成的代码经常有错误，他就加了一个“自动运行测试”的功能，让AI写完代码后立刻跑一遍测试，如果失败就自动修正。这个功能后来成了OpenCode的核心卖点之一。他也没有专门的测试团队，而是让用户通过GitHub Issues直接提bug，他当天就修。

更让人意外的是他的定价策略。很多SaaS产品会精心设计套餐，区分个人版、团队版、企业版，价格也定得很有层次。但Dax Raad的做法很简单：个人用户每月20美元，不限制使用次数。他说，定价越简单，用户越容易理解，也越容易付费。他还故意不设置免费试用期，因为免费试用往往吸引来大量不付费的用户，反而增加了服务器成本。他宁愿让用户先通过开源版本体验，觉得好用了再付费。

这个故事里最值得留意的一点，是Dax Raad对“竞争”的看法。很多人觉得GitHub Copilot那么强，OpenCode怎么可能有机会？但他的逻辑是：Copilot面向的是最广泛的开发者，追求通用和稳定；而OpenCode可以更灵活，比如支持更多编程语言、允许用户自定义AI模型、甚至可以离线使用。这些功能未必适合所有人，但对那些有特殊需求的开发者来说，就是不可替代的价值。他做的是“小而美”的产品，而不是试图取代Copilot。

读完这个故事，你可能会有一个感觉：做AI产品不一定非得烧很多钱、拉很多投资、组很大的团队。一个懂技术的独立开发者，用开源的方式，把自己当成用户，快速迭代，也能做出有人愿意付费的产品。这背后其实是关于“产品市场匹配（product-market fit）”的另一种理解：与其花几个月做调研，不如花几天做一个能用的版本，然后看用户用不用、愿不愿意付钱。Dax Raad的做法可能不适合所有产品，但对于那些有明确用户画像的工具类产品，这确实是一条值得参考的路。

Better tools made Copilot code review worse. Here’s how we actually improved it.

GitHub Copilot的代码审查功能，一开始其实做得不太好。你可能会想，Copilot不是已经很厉害了吗，怎么还会做不好？问题恰恰出在“工具变好了”这件事上。

事情是这样的：GitHub的工程团队发现，随着Copilot的代码补全能力越来越强，开发者写代码的速度确实快了，但代码的质量反而下降了。原因很简单：AI生成的代码看起来像模像样，但经常有隐藏的bug或者不符合最佳实践。以前开发者自己写代码，会仔细思考每一行；现在AI帮忙写了大部分，开发者就只是扫一眼，觉得“差不多”就提交了。结果就是，代码审查（code review）的工作量暴增，而且审查者发现的问题越来越多。

于是GitHub团队决定改进Copilot的代码审查功能。但他们一开始走了一条弯路：他们觉得问题出在工具不够智能，所以拼命提升AI的审查能力，比如让AI能发现更多类型的bug、能自动修复问题。结果呢？开发者反而更不认真了，既然AI会帮我检查，那我写的时候就更随便了。这就像一个人本来走路很小心，后来有了拐杖，反而开始闭着眼睛走路，因为觉得拐杖会扶住他。

那他们后来是怎么解决的？关键转变是：不再把AI当成一个“更聪明的审查者”，而是把它当成一个“引导者”。他们做了一个新功能，叫“Copilot Code Review Suggestions”。这个功能不是直接指出问题，而是在开发者写代码的过程中，实时给出提示和建议。比如你写了一个循环，AI会在旁边说：“这个循环可以用列表推导式（list comprehension）写得更简洁。”或者“这个函数没有类型注解，要不要加上？”这些提示不会打断你的思路，但会让你停下来想一想。

这个改变背后的理念是：好的工具不是取代人的判断，而是帮助人做出更好的判断。GitHub团队发现，当开发者自己意识到问题并主动修改时，代码质量提升的效果，远比AI直接替他们改要好得多。而且开发者也更愿意学习，因为每次提示都是一次微小的教学。

还有一个细节很有意思：他们做了一组实验，对比了两种模式。一种模式下，AI直接给出修改建议，开发者一键接受；另一种模式下，AI只给出提示，开发者需要手动修改。结果发现，后一种模式下的代码质量提升更明显，而且开发者的满意度也更高。因为手动修改的过程，让开发者真正理解了问题所在，下次就不会再犯同样的错误。

这个故事其实在讲一个很朴素的道理：工具越强大，人越容易变得懒惰。而真正好的工具，不是帮你把所有事情都做了，而是帮你保持专注和思考。GitHub团队最后总结说，他们学到的最重要的一课是：不要只关注AI的能力，更要关注AI和人之间的互动方式。这个教训，对于所有做AI产品的人来说，都值得反复琢磨。

Solo founding is at an all-time high: Top performers have these traits in common

你有没有注意到，过去几年里，一个人创办公司的人越来越多了？Stripe 最近在一篇博客里提到，单人创业（solo founding）的比例已经达到历史最高。这不是偶然的。工具越来越便宜，AI 让一个人能做的事变多了，市场也更愿意接受小团队甚至个人做出的产品。但 Stripe 观察到一个有意思的现象：不是所有单人创业者都能成功。那些真正跑出来的“顶级表现者”，身上有一些共同的特质。

这篇文章不是教你怎么融资、怎么找产品市场匹配（product-market fit），而是直接聚焦在“人”本身。Stripe 基于他们平台上大量创业者的数据，总结出几个关键特质。比如，顶级单人创业者往往有极强的“取舍”能力，他们知道什么该做，什么不该做，而且能毫不犹豫地放弃那些看起来不错但会分散精力的事情。另一个特质是“快速学习”，尤其是在自己不熟悉的领域，比如一个工程师背景的创始人，能迅速学会销售和营销的基本逻辑。

你可能会想，这些特质听起来有点虚。但文章里举了一个例子：有一个创始人，他的产品早期用户反馈很差，他没有像很多人那样反复调整功能，而是直接打电话给每一个流失的用户，问他们为什么走。这个动作听起来简单，但绝大多数人做不到，因为太难受了。他花了两个星期，打了五十多个电话，然后发现用户真正需要的不是他正在做的那个功能，而是一个完全不同的东西。他立刻转向，三个月后产品开始增长。

Stripe 还提到一个容易被忽略的点：单人创业者更容易陷入“完美主义陷阱”，因为没有人帮你做决定，你会反复打磨一个功能，直到它“完美”。但顶级表现者会故意让自己不舒服，他们会尽早把不完美的版本丢出去，哪怕自己觉得丢脸。这背后是一种“对反馈的渴望”，而不是对完美的追求。

读到这里，你可能会觉得这些特质更像是性格，而不是可以学的东西。但文章强调，这些特质可以被刻意练习。比如“快速学习”可以通过设定每周学习目标来训练，“取舍”可以通过每天列出三件最重要的事来练习。Stripe 的结论是：单人创业的黄金时代已经来了，但能不能抓住它，取决于你愿不愿意面对自己最不愿意面对的那些事。

An IC’s guide to roadmap planning

很多人觉得，制定产品路线图（roadmap）是经理或者总监的事，自己作为独立贡献者（individual contributor，IC），只管把分配下来的任务完成就好。但如果你是一个工程师、设计师或者数据分析师，真的甘心只做一个执行者吗？这篇文章恰恰就是写给那些不想只当执行者的IC的。它想回答一个很实际的问题：一个不带队、不汇报的人，怎么也能参与到路线图的规划里，甚至主动推动方向？

文章一开头就把一个常见的困境摆了出来。很多IC觉得规划是别人的事，因为自己“没有权力”或者“信息不够”。但作者认为，IC其实有一个经理们很难替代的优势：你对具体的技术细节、用户痛点和代码库里的坑，比任何人都清楚。经理可能会从商业目标或者老板的指示出发去画路线图，但IC知道哪些功能虽然听起来漂亮，实现起来却会引发技术债；哪些小改动看起来不起眼，却能让用户每天的操作顺畅很多。这种“来自地面的视角”恰恰是规划里最缺的。

那具体怎么做呢？作者给了几个很务实的建议。第一个是“从你的日常工作里提炼信号”。比如，你在处理用户反馈或者客服工单时，是不是反复看到同一种抱怨？你在做代码审查时，是不是总发现某个模块特别容易出bug？这些都不是偶然的，它们就是路线图上的“待办事项”。你可以把这些信号整理出来，用数据说话，比如“这个bug每个月影响200个付费用户”，然后主动向你的经理或者团队提出来。

第二个建议是“学会写一个简单的提案”。很多IC害怕写文档，觉得那是产品经理的事。但作者说，你不用写几十页的PRD（产品需求文档），只需要写一页纸：说清楚当前的问题是什么，为什么现在解决它很重要，大概需要多少工作量，以及预期的收益是什么。关键是，你要用团队能理解的语言，而不是纯技术术语。这样当你把提案放在团队面前时，大家不是在听你“要求”，而是在和你一起讨论优先级。

第三个建议更微妙：要理解路线图不是静态的，而是一个持续协商的过程。很多IC以为路线图是老板定下来就不能改的圣旨，其实不是。路线图会随着新信息、新数据、新用户反馈而调整。IC可以成为那个“提供新信息”的人。比如你发现某个第三方库快要停止维护了，或者某个竞品推出了一个很受欢迎的功能，你可以及时提醒团队，让路线图做出反应。这种“信息输入”本身就是一种规划参与。

作者还特别提醒，IC在参与规划时要避免两个陷阱。一个是不要只抱怨而不提方案。说“这个功能太难用了”很容易，但说“我们可以把那个按钮移到左边，这样用户点击率预计提升10%”就完全不同。另一个是不要过度承诺。IC往往对技术过于乐观，觉得“这个功能我两周就能搞定”，但实际可能涉及很多依赖和测试。在提案里留出缓冲时间，反而能让你的规划更可信。

读完整篇文章，你会发现核心其实不是教你如何画出一张漂亮的路线图，而是告诉你：一个好的路线图，应该是从上到下和从下到上两种力量共同作用的结果。经理提供战略方向和资源，IC提供地面实况和可行方案。如果你能主动把你在工作中发现的信号整理成提案，用数据说话，并且理解路线图是一个不断调整的过程，那你就不再只是一个被分配任务的执行者，而是真正参与了产品方向的塑造。这种参与感，往往比单纯的“完成任务”更能带来职业成就感。

How we developed a better way to learn at Slack Design

Slack 的设计团队遇到过一个很常见的问题：设计师们每天都在处理具体任务，但很难抽出时间系统性地提升自己。你可能也经历过类似场景，手头有十几个项目在跑，每个都需要深度投入，等忙完才发现自己已经很久没看过新案例、没尝试过新工具了。Slack 的设计团队发现，传统的学习方式，比如安排固定的培训日、让大家自己找时间看文章，效果都不好。要么被日常工作挤掉，要么学的东西太零散，记不住也用不上。

于是他们做了一件事：把学习直接嵌入到设计师的日常流程里。不是让大家额外花时间，而是让学习变成工作的一部分。具体做法是，他们设计了一个叫做“学习圈”（Learning Circle）的机制。每个圈子由 4 到 6 位设计师组成，大家共同选一个主题，比如“如何设计更好的空状态”或者“无障碍设计的实战方法”。然后每个人在两周内花少量时间（比如每天 15 分钟）去研究这个主题，收集案例、做小实验。两周后，大家聚在一起分享各自学到的东西。

这个做法的巧妙之处在于，它利用了设计师本来就有的好奇心和工作习惯。每个人研究的是同一个大主题，但切入角度不同。有人可能去翻竞品，有人去读规范文档，有人直接拿一个旧项目做修改实验。分享的时候，大家会发现同一个问题原来有这么多解法。而且因为时间短、目标明确，不会让人觉得是负担。

更重要的是，Slack 的设计团队没有把这件事做成一个项目，而是做成了文化。他们定期轮换主题，让不同背景的设计师都能参与。有的主题来自实际项目中遇到的难题，比如“如何让新手用户快速上手”，这样学习成果可以直接反哺工作。团队还专门留出空间，让大家把学到的东西记录下来，形成内部的小知识库。

这件事给我的启发是，学习不一定要靠大块时间和系统课程。对于设计师（其实对很多知识工作者也一样），最有效的学习方式可能是“短周期、小团队、聚焦具体问题”。不需要等到年底做个人发展计划，也不需要等公司安排培训。只要把学习拆成每天十几分钟的小动作，再配上同伴的分享压力，就能持续积累。Slack 的案例也说明，设计团队的管理者不一定非要制定严格的培训计划，而是可以创造一种环境，让学习自然发生。比如给设计师一点自主权去选择研究什么，再提供一个分享的场合。这样既尊重了每个人的节奏，又让集体知识不断增长。读完这个案例，我最大的感受是：与其想着怎么让大家“多学习”，不如想想怎么让大家“在工作中顺便学习”。

Matching AI Modality To User Intent: Designing The Right Interface

很多人第一次用AI助手时，会习惯性地把它当成一个对话框。你打字，它回复，像跟一个无所不知的朋友聊天。但用着用着就会发现，有些问题用对话框很自然，比如“帮我写一封辞职信”；有些问题却很别扭，比如“帮我分析这张图表里的销售趋势”。你不得不把图表里的数字一个一个打进去，或者上传图片后再追问好几轮，才能得到想要的答案。问题出在哪里？不是AI不够聪明，而是你用的交互方式（modality）不对。这篇文章讨论的核心，就是AI产品的交互方式必须匹配用户的真实意图，而不是一股脑地塞给用户一个对话框。

交互方式，或者说模态（modality），指的是用户与AI系统沟通的通道。最常见的是文字输入和语音，但还有点击、拖拽、手势、甚至眼神和脑电波。不同的模态适合不同的场景。打字适合精确表达，语音适合快速指令，而视觉化的操作，比如画一个圈、拖一条线，则适合表达空间关系或数量关系。文章举了一个很具体的例子：如果你想让AI帮你规划一个房间的家具布局，用文字描述“把沙发放在窗户旁边，茶几放在沙发前面”会非常繁琐，而且很难精确。但如果给你一个平面图，你直接拖拽家具图标到想要的位置，AI再根据你的摆放给出建议，整个过程就流畅得多。这就是模态匹配的力量。

文章进一步提出了一个设计框架，帮助产品经理和设计师判断什么时候该用什么模态。核心是理解用户的意图（intent）到底是什么。用户的意图可以大致分为几类：信息获取、内容生成、决策辅助、任务执行、创意探索。对于信息获取，比如“今天天气怎么样”，语音或文字对话框就够了。但对于决策辅助，比如“我应该买哪款手机”，单纯的对话框会让用户感到信息过载，更好的方式可能是让AI先问几个关键问题，然后展示一个对比表格，用户可以通过点击选择来细化需求。文章特别提到，很多AI产品失败的原因，不是技术不行，而是交互方式选错了。比如一个AI理财顾问，如果只提供一个对话框，用户不知道该怎么问；但如果提供一个仪表盘，用户可以看到自己的收支分类，点击某个类别后AI再给出建议，用户就更容易信任和使用。

文章还讨论了多模态（multimodal）交互，也就是同时使用多种方式。最典型的例子是手机上的视觉搜索：你拍一张植物照片，然后打字问“这是什么植物？怎么养？”拍照是视觉模态，打字是文字模态，两者结合比单独用任何一种都高效。设计多模态交互的关键，是让不同模态之间自然切换，而不是让用户觉得在“换工具”。比如，用户在编辑文档时，可以选中一段文字后直接语音说“加粗”，AI理解这个动作是“对选中的文字应用加粗格式”，而不是把语音当成独立指令。这种无缝的模态切换，需要AI理解用户当前的上下文和意图。

最后，文章给出了一个实用的建议：在设计AI产品时，不要默认从对话框开始。先列出用户可能的所有意图，然后为每种意图选择最自然的模态。有时候，一个简单的按钮或滑块，比一个聪明的聊天机器人更管用。对于产品团队来说，这意味着要花更多时间观察用户在实际场景中的行为，而不是闭门造车。读完这篇文章，你带走的不只是一个设计原则，而是一种思考习惯：下次再设计AI功能时，先问自己，用户此刻真正想做什么，然后选择那个最不费力的交互方式。

Microservice dogma nearly tanked our seed round

一家初创公司正在准备种子轮融资，创始人信心满满，因为他们按照教科书搭建了微服务架构。每个服务独立部署、独立扩展、用不同的技术栈，看起来非常“现代”。但投资人走进来，看到代码库被拆成几十个微服务，每个服务只做一点点事，却需要复杂的消息队列和 API 网关才能让它们互相说话，投资人的脸色变了。他们问了一个让创始人措手不及的问题：“你们现在有多少用户？每天多少请求？”创始人回答：“不到一千个用户，每天几百次请求。”投资人沉默了几秒，然后说：“你们这个架构，看起来像是为几百万用户准备的，但你们现在只有几百个用户。你们浪费了太多时间在基础设施上，而不是在解决用户问题上。”

这篇文章讲的正是这个陷阱。很多技术团队，尤其是工程师背景的创始人，容易陷入一种“教条主义”：认为微服务是先进架构，单体应用是落后架构。他们忘了架构选择应该服务于业务阶段，而不是反过来。种子轮阶段的公司，核心目标是找到产品市场匹配（product-market fit），快速迭代，验证假设。微服务带来的好处，独立部署、弹性伸缩、团队自治，在用户不到一万的时候几乎用不上，反而带来了巨大的认知负荷：你需要管理服务发现、分布式追踪、数据一致性、跨服务调试。这些工作对早期团队来说是纯粹的负债。

文章里有一个很形象的比喻：微服务像是一套精密的工业厨房设备，适合每天做几千份菜的大型餐厅。但如果你只是一个摆摊卖煎饼的小贩，你需要的只是一辆三轮车和一个炉子。硬要把工业设备搬到街边，只会让你连炉子都点不着。种子轮阶段的公司就应该用“三轮车架构”，最简单的单体应用，一个代码库，一个数据库，部署在一台服务器上。这样你才能快速试错，今天改一行代码，明天就能上线看用户反应。等你真的有了几万用户，再考虑把某个模块拆出来独立服务也不迟。

作者还分享了一个关键教训：不要为了“将来可能用到”而过度设计。很多团队在早期花大量时间搭建 CI/CD 流水线、容器编排、服务网格，这些工具在用户规模上来之后确实有用，但在早期它们只是拖慢迭代速度的石头。投资人看的是你的团队是否能把有限的时间花在刀刃上，理解用户、打磨产品、获取增长。如果你把一半的时间花在“架构现代化”上，投资人会怀疑你分不清主次。最终，那家创始团队放弃了微服务，回到单体应用，几个月后拿到了融资。他们的故事提醒我们：技术选择不是信仰问题，而是成本效益问题。在正确的时间做正确的事，比做“正确的事”更重要。

Stakeholders and the Product Model

很多做产品的人都有过这样的经历：你花了好几个星期研究用户、设计原型、验证假设，终于做出一个自信的方案。拿去给老板或业务方看，对方扫了一眼说：“这个功能先放一放，我们先把那个大客户的定制需求做了。”或者：“我觉得这个按钮应该放在左边，用户肯定更喜欢。”你心里知道这个需求跟产品方向没关系，那个按钮的位置也没有数据支撑，但对方是“利益相关者”（stakeholder），你很难直接反驳。

这就是硅谷产品集团（Silicon Valley Product Group，简称SVPG）那篇文章要讨论的核心问题：当公司采用产品模型（product model）来运作时，利益相关者到底应该扮演什么角色？产品模型的意思是，产品团队不是被动接需求的执行部门，而是被授权去发现（discover）什么值得做、什么不值得做，并且对结果负责。在这种模式下，利益相关者，比如CEO、销售副总裁、市场总监，不能再像传统项目经理那样，直接告诉产品团队“做什么”和“怎么做”。

但现实往往不是这样。很多公司虽然嘴上说“我们要用产品模型”，实际运作时，利益相关者还是会习惯性地下指令。文章里举了一个很典型的例子：销售副总裁跑来说，一个潜在客户要求加一个功能，否则就不签单。销售觉得这功能很简单，只要改几个字段就行。产品经理一看，发现这个改动会影响整个系统的数据模型，还会让其他客户的使用体验变差。如果直接做，短期能签单，长期却会积累技术债（technical debt）和产品碎片化。

这时候，利益相关者和产品团队之间的张力就暴露出来了。销售副总裁的KPI是签单额，他看到的“价值”是那个客户带来的收入。产品经理的KPI是产品健康和长期用户满意度，他看到的是“成本”，开发资源、维护负担、对其他用户的伤害。双方都没有错，但目标不一致。

文章的核心观点是，解决这个张力的关键不是让产品团队学会“向上管理”或“说服”利益相关者，而是要从组织层面重新定义利益相关者的角色。利益相关者不应该参与“如何做”（how）的决策，也不应该直接指定“做什么”（what），而应该聚焦在“为什么”（why）上。也就是说，利益相关者可以提出商业目标、战略方向、用户痛点，但具体用什么功能去达成这些目标，应该由产品团队基于用户研究和数据来决定。

为了让这个分工落地，文章建议产品团队主动建立一种“联合发现”（co-discovery）的工作方式。不是拿着做好的方案去给利益相关者“汇报”，而是在探索阶段就邀请他们参与用户访谈、原型测试。比如，销售副总裁亲眼看到用户在那个“简单功能”面前困惑的表情，他可能就不会再坚持要做了。亲眼看见的数据比任何报告都有说服力。

还有一个很实用的建议是：产品团队要区分“输入”（input）和“需求”（requirements）。利益相关者提供的都是输入，他们的经验、直觉、客户反馈，这些都是有价值的原材料，但产品团队需要用自己的专业能力去消化这些输入，转化成真正的产品方案。如果直接把输入当需求，那就回到了传统的“命令-执行”模式。

文章最后提醒说，产品模型不是产品团队单方面能推行的，它需要公司高层真正理解并支持这种分工。如果CEO自己还是习惯直接拍板功能细节，那产品团队再怎么努力也会被拉回旧模式。所以，改变利益相关者的角色，本质上是一场组织变革，需要从最上面开始。

读完这篇文章，你可能会意识到，那些让你头疼的“老板需求”或“业务方要求”，其实不一定是坏事。它们只是暴露了公司还没有真正建立起产品模型的分工机制。而作为产品人，你能做的不是抱怨，而是主动创造机会，让利益相关者参与到发现过程中来，用真实用户的行为和反馈，而不是会议室里的争论，来推动决策。

Building Reliable Agentic AI Systems

你正在用人工智能助手帮忙写一封邮件，它写得很流畅，但突然在称呼里写错了客户的名字。你发现后改了，心里却犯嘀咕：如果这是一份发给全公司的通知呢？如果是一个自动处理订单的系统呢？这种“大部分时候对，偶尔离谱”的特性，正是今天使用大语言模型（LLM）构建可靠系统时最棘手的难题。Martin Fowler 的这篇文章，没有从理论出发，而是通过一个真实案例来展开：一家名为 Bayer 的公司，如何把大语言模型嵌入到他们的核心业务流程中，并且保证它不出错。

Bayer 是一家农业科技公司，他们有一个叫 Climate FieldView 的平台，帮助农民管理农田。农民会拍照上传田里的杂草或病虫害，系统需要识别出问题并推荐合适的农药。过去这个任务靠人工专家完成，但专家数量有限，响应慢。他们想用大语言模型来自动化这个流程。但问题很明显：如果模型推荐错了农药，农民可能用了无效的药，造成经济损失甚至环境污染。所以系统必须极其可靠。

文章详细描述了 Bayer 团队如何设计这套系统。他们没有让模型直接输出答案，而是把任务拆解成多个步骤。第一步，模型先识别图片中的作物和杂草种类；第二步，根据识别结果去查询一个经过验证的农药数据库；第三步，再结合当地的气候和土壤数据，生成最终推荐。每一步的输出都经过格式校验和逻辑检查。比如如果模型识别出的杂草不在数据库中，系统会直接拒绝推荐，转而请求人工介入。这种设计思路叫做“人机回环”（human-in-the-loop），但更关键的是，他们把模型当成了一个不完美的组件，通过外围的校验逻辑来兜底。

文章还提到了一个重要的概念：可靠性不是模型自己的事，而是整个系统的属性。就像你不能只靠一个超级精准的传感器就让自动驾驶汽车安全，你需要冗余、校验、降级策略。Bayer 的案例里，他们甚至对模型的置信度做了量化：如果模型对某个识别结果信心不足，系统会主动降低自动化程度，把决策权交还给人类专家。这种“知道什么时候该认怂”的能力，反而比模型本身的准确性更重要。

读这篇文章时，最值得留意的是他们如何把抽象原则变成了具体代码。比如他们定义了一套“合约”（contract），规定模型输出的格式和取值范围，违反合约的输出会被直接丢弃。这听起来像是软件工程里常见的防御式编程，但应用到 AI 系统时，你需要想清楚：模型可能犯哪些错？哪些错是可接受的，哪些是不可接受的？Bayer 的答案是：宁可因为过于保守而频繁请求人工，也不让一个错误推荐流出。这种取舍背后，是对业务后果的深刻理解。

你可能会想，这样会不会太慢、太贵？文章给出了数据：在 Bayer 的系统中，大约 80% 的请求可以全自动处理，剩下的 20% 转向人工。这 20% 里，有一部分是模型确实不确定的，也有一部分是校验逻辑认为风险太高的。但正因为有了这 20% 的人工兜底，整个系统的可靠性才达到了生产环境的要求。这其实揭示了一个常常被忽视的事实：可靠的 AI 系统，不是靠把模型做到完美，而是靠设计一个能容纳不完美模型的架构。

最后，文章留下了一个值得反复琢磨的判断：在构建可靠 AI 系统时，最稀缺的资源不是更好的模型，而是对失败模式的想象力。你需要提前想清楚所有可能出错的地方，并针对每一种情况设计响应策略。Bayer 的团队花了大量时间模拟各种边界情况，比如用户上传了模糊的照片、照片里有多种杂草、或者当地法规禁止使用某种农药。这些场景在测试集里可能永远不会出现，但在真实世界里一定会发生。读完这篇文章，你带走的不应该是对某个技术细节的记忆，而是一种思维方式：把 AI 当做一个需要被管理的风险，而不是一个万能的答案机器。

The power of collaboration: How we can reduce traffic congestion

每天早晚高峰，你堵在路上的时候，会不会想：如果所有车都稍微让一让，是不是大家都能快一点？这个问题，Google Research 的一篇博客文章用真实数据给出了一个让人意外的答案。他们和以色列的交通管理部门合作，在一个城市做了实验：不是修路，不是限行，只是让一部分司机在导航里收到一条简单的建议，请靠右行驶，让后面的车从左边超车。结果，整个城市的平均通勤时间缩短了，而且不是只有收到建议的人受益，所有人都快了。

这个实验的背景是，交通拥堵很多时候不是因为路不够宽，而是因为车与车之间的“不协作”。比如一辆车在快车道上开得慢，后面的车只能跟着减速，然后连锁反应导致整条路堵死。如果那辆慢车能主动让到右边，后面的车就能顺畅通过。但现实中，司机很难判断自己是不是该让，或者让了之后自己会不会更慢。Google 的实验就是通过导航 App 给司机推送个性化的建议，告诉他们“你现在在快车道，但速度偏慢，建议向右变道”。

文章详细描述了实验的设计。他们选取了以色列的一个城市，在高峰时段对一部分使用 Google Maps 的司机推送这种协作建议。实验组和对照组是随机分配的，而且他们用了很严谨的统计方法来排除其他因素的干扰。结果发现，收到建议的司机中，有相当比例的人真的照做了。更关键的是，整个路网的平均车速提升了，拥堵持续时间缩短了。而且那些没有收到建议的司机，也因为路况整体变好而受益。这是一个典型的“正外部性”案例：个人的一个小动作，让整个系统变得更高效。

但文章并没有停留在“协作真好”这个层面。他们进一步分析了为什么这种简单的建议能起作用。一个原因是，司机在车里往往只关注自己前方的几辆车，看不到整个路网的状况。导航 App 拥有全局视角，可以告诉司机“你现在的位置是整个路段的瓶颈”。另一个原因是，很多司机其实愿意配合，只是不知道什么时候该配合。比如你可能在高速上开得不算慢，但后面有车更快，你如果知道让一下能帮助缓解拥堵，多半会愿意。问题是，你没法知道后面的车是不是真的急着赶路。App 的建议充当了一个中立的协调者。

这篇文章最有意思的地方在于，它把交通问题重新定义为一个协作问题，而不是一个工程问题。我们通常认为解决拥堵要靠修路、限行、收费，但这些手段成本高、争议大。而 Google 的实验展示了一种低成本的软性干预：通过信息引导，激发自发的协作行为。当然，这种方案也有局限性。比如它需要足够多的用户使用导航 App，而且需要司机愿意听从建议。但实验证明，只要有一部分人响应，效果就已经很明显了。

读这篇文章的时候，你可以想一想：还有哪些领域存在类似的“协作失灵”？比如办公室的空调温度设置、排队时的插队问题、甚至开源社区的代码贡献。很多时候，问题不是缺乏资源，而是缺乏一个让个体行为与整体利益对齐的信号。Google 的交通实验告诉我们，有时候一个简单的提示，就能让系统从内耗转向共赢。而作为用户，下次收到导航建议让你靠右时，你或许会多一份耐心，因为你知道，你让的不是后面那一辆车，而是整个城市里的每一个人。

Why is Meta destroying its engineering organization?

最近有一条消息让很多工程师感到不安：Meta 正在大规模调整它的工程团队。有人在社交媒体上抱怨，说 Meta 正在“摧毁”自己的工程组织。这里的“摧毁”不是指裁员，虽然 Meta 确实裁过很多人，而是指一种更深层的变化：它正在把工程师从“自己决定做什么”变成“听产品经理指挥的执行者”。

要理解这件事有多严重，你得先知道 Meta 以前是什么样的。在很长一段时间里，Meta（当时还叫 Facebook）的工程师文化是出了名的“自下而上”。工程师可以自己提想法，自己写原型，自己找用户测试。一个工程师可能因为看到一个数据问题，就花几周时间写一个内部工具，然后这个工具慢慢变成公司级的产品。这种文化让 Meta 诞生了很多重要功能，比如 News Feed、Like 按钮，甚至 React 这个前端框架。工程师不仅是写代码的人，他们也是产品经理、设计师、数据分析师。

但现在情况变了。根据 The Pragmatic Engineer 的分析，Meta 正在把权力从工程师手里收回来，集中到产品经理和总监手里。工程师不再被鼓励去探索新想法，而是被要求严格按照产品路线图（roadmap）执行。如果你是一个工程师，你的绩效不再取决于你做出了什么创新，而是取决于你是否按时交付了分配给你的任务。这听起来好像没什么问题，很多公司就是这么运作的，但对于 Meta 这种靠工程师文化起家的公司来说，这相当于动摇了根基。

为什么会发生这种变化？一个直接原因是增长放缓。当公司还在高速增长的时候，管理层愿意容忍工程师的“浪费”，比如花时间做一个最终被砍掉的原型。但当收入增长变慢、竞争加剧（尤其是来自 TikTok 的竞争），管理层开始追求效率。他们希望每一个工程师的每一分钟都用在能直接提升收入或用户参与度的事情上。从财务角度看，这很合理。但从创新角度看，这很危险。因为真正的创新往往来自那些“浪费”的时间。

还有一个更深层的原因：Meta 的 AI 战略。Meta 正在全力押注人工智能，尤其是生成式 AI 和推荐系统。但 AI 产品的开发方式和传统软件不同。传统软件可以靠工程师的直觉和快速迭代，但 AI 产品需要大规模的数据、计算资源和集中的模型训练。这意味着决策权必须集中，因为训练一个大模型不是几个工程师在周末就能搞定的。所以 Meta 把工程师变成执行者，某种程度上是为了配合 AI 时代的开发模式。

但问题在于，这种转变可能过度了。当工程师完全失去自主权，他们就不再是“工程师”而是“代码工人”。优秀的人才会离开，因为他们去别的地方可以拥有更多创造空间。事实上，已经有很多 Meta 的资深工程师跳槽到了创业公司或 OpenAI 这样的地方。如果 Meta 继续这样走下去，它可能会变成一个高效的执行机器，但也会失去那种能催生下一个 Facebook 的创新土壤。

这件事给所有做 AI 产品的公司一个提醒：效率和创新之间永远存在张力。你可以通过集中控制来提高短期效率，但长期来看，你可能会失去那些最优秀的人。而最优秀的人，恰恰是你最需要的人。

Prototypes vs Products

很多团队在做一个新功能或新产品时，容易陷入一个常见的误区：把原型当产品。原型（prototype）是用来验证想法、测试用户反应的快速实验，而产品（product）是经过打磨、能稳定交付价值、可以规模化使用的完整系统。硅谷产品集团（SVPG）的这篇文章，核心就是在帮我们理清这两个概念的区别，以及为什么混淆它们会带来大问题。

想象一下，你正在开发一个帮助用户管理订阅服务的应用。你花了一周时间，用低代码工具搭建了一个可以点击的界面，用户能添加订阅、查看每月总花费。这个原型看起来不错，内部演示时大家都觉得“差不多成了”。于是你直接把它推向市场，结果发现：用户一多服务器就崩溃，数据同步有延迟，支付环节根本没法走通。这就是典型的把原型当产品，原型只验证了界面交互的可行性，但没考虑后端架构、数据一致性、安全性、可扩展性等产品层面的要求。

文章用一个很形象的比喻来解释：原型像是用乐高搭出来的模型车，看起来有轮子、有方向盘，甚至能推着走，但它不能真的上路。产品则是经过工程设计的真车，有发动机、刹车系统、安全气囊，通过了碰撞测试，可以安全地每天开。产品经理和设计师的工作是确保原型能快速验证核心假设，而工程师的工作是把原型变成真正的产品。

那么，什么时候该做原型，什么时候该做产品？文章指出，在产品发现（product discovery）阶段，原型是核心工具。你需要快速制作低保真或高保真原型，去测试用户是否理解你的价值主张、是否愿意使用、操作是否顺畅。这个阶段的目标是学习，不是交付。一旦验证了关键假设，进入产品交付（product delivery）阶段，就要切换到产品思维：考虑代码质量、测试覆盖、性能指标、监控告警、文档、客服流程等等。很多团队失败的原因，是在发现阶段做得不够，直接跳到交付；或者反过来，在交付阶段还沿用原型的粗糙标准。

文章还特别提到一个常见陷阱：用原型的结果来预测产品的市场表现。原型阶段用户说“很喜欢”“愿意用”，不代表产品上线后用户真的会持续使用。因为原型没有真实的数据、没有加载时间、没有注册流程、没有付费障碍。用户对原型的正面反馈，更多是对一个想法的反馈，而不是对实际产品的反馈。真正的产品必须面对各种现实约束：网络延迟、设备兼容性、用户习惯迁移成本、竞品对比等等。

对于产品团队来说，一个实用的建议是：在每次开始构建之前，先明确问自己，“我们是在做原型还是做产品？”如果是原型，就要控制投入，快速迭代，不追求完美。如果是产品，就要按产品标准来，不能因为“先上线再说”而牺牲质量。文章强调，最好的团队往往能清晰区分这两个阶段，并且在每个阶段都使用最适合的工具和流程。

读完这篇文章，你会意识到，很多所谓的“失败产品”，其实不是产品本身不好，而是团队在错误的时间用错误的方式做了错误的事。把原型当产品，就像用模型车去跑拉力赛，结果可想而知。而真正的高手，懂得在原型阶段快速试错，在产品阶段扎实交付。这个判断，值得每个做产品的人带在身边。

Designing Where the Pixels Actually Live

当你打开一个应用，看到某个按钮、某个动画或某个空白页，你不会去想这些像素是怎么跑到屏幕上的。你只觉得它该在那里，或者不该。但设计师和工程师每天都在处理一个根本性的矛盾：他们在一个二维的画布上画界面，而用户最终看到的东西，却要经过操作系统、浏览器、设备分辨率、字体渲染、屏幕缩放和无数层抽象才能到达。

Slack 设计团队最近写了一篇文章，标题叫“设计像素真正存在的地方”。这个标题本身就是一个提醒：像素并不活在 Figma 文件里。Figma 里的界面是理想化的、静态的、不受环境影响的。但用户看到的是真实设备上的像素，那些像素会被系统字体渲染引擎改变形状，会被浏览器默认样式覆盖，会被用户设置的字体大小放大或缩小，甚至会被操作系统的无障碍缩放压扁。Slack 团队发现，很多设计问题只有到了真实设备上才会暴露出来，比如某个按钮在设计师的 Retina 屏上完美居中，在用户的低分辨率显示器上却偏了 2 个像素；某个图标在 Figma 里用 24x24 看起来合适，在 Windows 系统上因为字体渲染不同显得特别小。

所以他们在团队内部推行了一个原则：尽早把设计放到真实设备上看。不是等到开发完成再检查，而是在设计阶段就把 Figma 画板里的界面导出成截图，放到不同尺寸的模拟器里，甚至直接投到测试机上。他们管这个叫“像素验证”（pixel verification）。听起来很简单，但实际操作中，这要求设计师改变工作流程，不再只盯着 Figma 里的完美像素，而是主动去适应设备的不完美。

文章里讲了一个具体的例子：Slack 的侧边栏在 Mac 上看起来刚刚好，但在 Windows 上，因为系统字体渲染更粗、更宽，侧边栏的文字会溢出容器。如果设计师只在 Figma 里看，永远发现不了这个问题。只有把设计放到 Windows 机器上，才会看到文字被截断。解决方式不是去改 Windows 的渲染，而是调整间距和字号，让界面在两种系统下都能正常工作。

另一个例子是关于空白页的。Slack 里有一些空状态页面，比如还没有任何消息的频道。设计师在 Figma 里画了一个很漂亮的插画和一段提示文字，布局很舒服。但放到真实设备上，因为浏览器默认的滚动条宽度不同，或者因为某些设备有刘海屏，插画被遮住了一部分。这些细节在 Figma 里永远不会出现，因为 Figma 不知道你的设备有刘海。

这篇文章真正想说的不是技术细节，而是一种态度：设计不是画完就结束的工作，设计要一直负责到像素真正被用户看到的那一刻。这意味着设计师需要理解渲染管线的基本原理，需要和工程师讨论 CSS 属性，需要愿意走出 Figma 的舒适区，去面对那些“脏”的真实设备。

读完之后你会意识到，好的产品体验往往不是靠一个惊艳的设计稿，而是靠无数个这样的小修复堆出来的。每个像素的位置，最终都是由用户手里的那块屏幕决定的。

S&P Global’s innovative disaster recovery strategy using Amazon FSx for NetApp ONTAP snapshots

想象一下，你是一家全球金融数据公司的技术负责人。每天，你的系统要为成千上万的交易员、分析师和投资机构提供实时的市场数据，比如股票价格、债券收益率、大宗商品指数。这些数据一旦中断几分钟，就可能造成数千万美元的损失。更可怕的是，如果发生灾难，比如数据中心火灾、网络攻击或硬件故障，而你无法快速恢复数据，整个金融市场都可能陷入混乱。这就是 S&P Global（标普全球）每天面对的挑战。作为全球最重要的金融信息提供商之一，S&P Global 必须保证其核心数据服务在任何情况下都不中断。

为了应对这个挑战，他们需要一套极其可靠的灾难恢复（disaster recovery）方案。传统做法是：在另一个地理位置维护一套完全独立的数据中心，实时同步所有数据，一旦主中心出问题，立即切换到备用中心。但这意味着要购买双倍的存储设备、服务器和网络带宽，成本高得惊人。而且，金融数据的变化极为频繁，每秒可能有成千上万条交易记录、价格更新和指数计算，要保持两个数据中心完全同步，技术难度和运维负担都很大。

S&P Global 找到了一条更聪明的路。他们利用了 Amazon FSx for NetApp ONTAP 的快照（snapshot）功能。简单来说，快照就像是给文件系统拍一张“即时照片”，记录下某个时刻所有数据的完整状态。与传统的实时同步不同，快照是周期性创建的，比如每五分钟拍一张。如果主数据中心出问题，他们可以从最近的一张快照中恢复数据，而不是从零开始重建。这个方案的关键创新在于：他们不是简单地把快照存起来，而是设计了一套自动化的流程，让快照在多个 AWS 区域之间快速复制和恢复。

具体是怎么做的呢？S&P Global 在主要业务区域（比如美国东部）运行着 Amazon FSx for NetApp ONTAP 文件系统，所有实时数据都写在这里。然后，他们设置了一个自动化的快照策略，比如每五分钟创建一次快照，并把这些快照自动复制到另一个 AWS 区域（比如美国西部）的备用文件系统中。这个复制过程是增量的，只传输变化的数据块，而不是整个快照，所以网络带宽消耗很小，复制速度很快。当灾难发生时，他们可以在几分钟内将备用区域的文件系统挂载到计算实例上，恢复所有数据，然后继续提供服务。整个过程几乎不需要人工干预，因为所有步骤都通过 AWS 的自动化工具（如 AWS Lambda 和 AWS Step Functions）编排好了。

这个方案带来的好处非常明显。首先，成本大幅降低。不需要维护双倍的基础设施，因为备用系统只在需要时才会真正投入运行，平时只是以低成本保存快照数据。其次，恢复时间目标（RTO）和恢复点目标（RPO）都达到了金融行业最严格的要求：RTO 在 15 分钟以内，RPO 在 5 分钟以内。这意味着，即使发生最坏的情况，S&P Global 最多只丢失 5 分钟的数据，并且能在 15 分钟内恢复全部服务。对于金融市场来说，这已经是接近零中断的水平。更重要的是，这个方案具有很强的可扩展性：如果业务增长，他们只需要调整快照频率和复制策略，不需要重新设计整个架构。

从 S&P Global 的案例中，我们可以看到，灾难恢复不再是一个“花钱买保险”的沉重负担，而是可以通过云原生技术和创新架构，变成一种既高效又经济的战略能力。关键在于，不要被传统思路束缚，比如非要追求实时的完全同步，而是找到最适合自己业务场景的平衡点。快照加自动化恢复，就是一个很好的例子。对于任何依赖数据持续可用的企业来说，这个思路都值得借鉴：先定义清楚你能接受的最大数据丢失量和恢复时间，然后利用云平台的工具，设计出一个既能满足要求又不至于过度投资的方案。毕竟，在数字化时代，数据就是生命线，而保护生命线的方式，可以比想象中更聪明。

Designing For Distressed Users: Why Mental Health Apps Shouldn’t Follow Every UI Fashion

你打开一个心理健康应用，界面干净、字体纤细、留白很多，看起来很像那些获奖的消费级产品。但你正处在焦虑发作中，手指发抖，眼睛很难聚焦，那些精心设计的微交互动效反而让你更烦躁。你找不到紧急求助按钮，因为它被藏在汉堡菜单第三层。你试图输入感受，但那个漂亮的输入框要求你填写至少十个字，而你此刻连一个字都打不出来。

这篇文章提出的核心问题很简单：当用户处于痛苦状态时，那些在普通产品里被证明有效的设计模式，是否仍然适用？答案是否定的，而且否定得很彻底。文章以心理健康应用为具体场景，指出一个普遍存在的设计盲区，设计师和产品经理常常假设用户是冷静、理性、有耐心的，但心理健康应用的真实用户往往处于高度情绪化、认知资源被严重消耗的状态。他们可能正在哭泣、恐慌、暴怒，或者只是精疲力尽到连滑动屏幕都觉得费力。

文章举了一个很有说服力的例子：很多心理健康应用采用“日记式”界面，鼓励用户每天记录情绪。这个设计在常规产品里很常见，比如健康类应用让用户记录饮食和运动。但对于抑郁用户来说，写日记本身可能就是一种负担，因为抑郁的一个核心症状是丧失兴趣和能量。如果应用还要求用户选择情绪标签、添加描述、选择触发因素，那么这个“帮助用户”的功能反而变成了又一个让人感到挫败的任务。

那么应该怎么做？文章提出了几条具体原则。第一条是“降低认知负荷”。这意味着减少选择数量、使用更大的按钮和更清晰的对比色、避免让用户记住信息。比如，紧急求助按钮应该永远在首页最显眼的位置，而不是藏在设置里。第二条是“允许不完整的使用”。用户应该可以只完成一个动作就退出，比如只点击“我现在需要平静下来”，而不必填写后续问卷。第三条是“避免使用隐喻和抽象图标”。一个心形图标可能代表“喜欢”，但一个恐慌中的用户可能无法理解这个图标意味着什么。

文章还批评了当前很多心理健康应用盲目追随主流 UI 趋势的做法。比如，使用极浅的灰度字体，这在普通阅读场景下很优雅，但对于视力或认知能力暂时下降的用户来说，几乎无法辨认。再比如，大量使用微动效来增加“愉悦感”，但这些动效可能让焦虑用户感到更加不安。文章引用了一项研究，指出在高压状态下，用户更倾向于依赖习惯性的、可预测的界面行为，任何意外的动画或布局变化都会增加他们的压力。

读到这里，你会发现这篇文章不只是写给心理健康应用设计师的。它其实在提醒所有做产品的人：你的用户可能永远不是你以为的那个样子。他们可能在深夜、在通勤路上、在情绪低落的时刻使用你的产品。产品的“默认用户画像”往往是一个健康、有耐心、有时间的理想用户，但真实世界里的用户是疲惫的、分心的、急躁的。如果你只按照最佳实践和设计趋势来构建产品，你可能会无意中把最需要帮助的人推得更远。

文章最后给出的建议很温和但也很坚定：在做出设计决策之前，先问自己一个简单的问题，如果用户现在正在崩溃，这个设计会不会让事情变得更糟？如果答案是“可能会”，那就重新设计。这不是要放弃美学或创新，而是要把同理心放在比时尚更优先的位置。毕竟，一个应用如果不能在最糟糕的时刻被使用，那它在最好的时刻再漂亮也没有意义。

How we built saga rollbacks for Cloudflare Workflows

想象一下，你正在用 Cloudflare Workflows 构建一个多步骤的后端流程，比如用户注册后需要创建数据库记录、发送欢迎邮件、初始化存储空间、调用第三方 API 验证身份。这个流程有五个步骤，每一步都可能失败。如果第三步失败了，前两步已经产生的效果怎么办？数据库里多了一条不完整的记录，邮件已经发出去了，但用户实际上没有完成注册。这就是分布式系统中著名的“部分失败”问题。

Cloudflare 的工程师在这篇文章里详细讲述了他们如何为 Workflows 这个产品构建“回滚”（rollback）能力。回滚不是新鲜概念，数据库事务早就有了，但 Workflows 面对的场景更复杂：每个步骤可能调用外部 API、修改外部状态，甚至涉及第三方服务。你不能简单地像数据库那样“撤销”一条记录，因为外部系统的状态变化可能无法逆转。

文章用了一个非常具体的例子来说明他们面临的挑战：假设一个工作流（workflow）中有一个步骤是“发送 Slack 通知”，另一个步骤是“更新内部数据库”。如果数据库更新失败，你希望撤销已经发出的 Slack 通知。但 Slack 的 API 并没有提供“撤回消息”的通用能力，除非你在设计流程时就预设了撤回逻辑。更麻烦的是，有些步骤是幂等的（idempotent），即重复执行不会产生副作用；有些则不是。回滚系统需要区分这两种情况。

Cloudflare 的解决方案是引入“补偿动作”（compensation action）的概念。不是简单地回退到之前的状态，而是为每个步骤定义一个“反向操作”。比如，如果某个步骤是“创建文件”，补偿动作就是“删除文件”；如果某个步骤是“发送邮件”，补偿动作可以是“发送一封撤回邮件”或者“标记为待撤回”。这个思路借鉴了分布式系统里常用的 Saga 模式（一种管理长事务的架构模式），但 Cloudflare 把它实现在了无服务器（serverless）工作流引擎中，让开发者不需要自己编写补偿逻辑。

文章还提到了一个关键的设计决策：回滚必须是可观测的（observable）。当回滚发生时，开发者需要知道哪些步骤已经执行、哪些被补偿、补偿是否成功。Cloudflare 为此构建了专门的事件日志系统，记录每一步的状态变化，包括补偿动作的触发和结果。这样即使补偿本身失败，系统也能留下线索，让开发者手动介入。

读这篇文章最有意思的地方在于，它把“失败”当作一个正常状态来设计。很多工程师在设计系统时默认一切顺利，只在边缘情况里考虑错误处理。但 Cloudflare 的做法是：从一开始就假设每一步都可能失败，并且失败后需要一条清晰的撤退路径。这种思维方式在构建复杂分布式系统时尤其重要，因为随着步骤增多，部分失败的概率会指数级上升。

最后，文章总结了一个很实用的经验：不要试图让所有操作都可回滚，这是不现实的。相反，应该让开发者明确声明哪些步骤需要补偿，并为那些无法自动补偿的步骤提供清晰的告警和手动干预接口。这种务实的取舍，比追求完美的自动回滚更有价值。毕竟，在现实世界里，有时候最好的回滚策略就是让人知道出了问题，然后由人来决定怎么处理。

Context Architecture

你有没有想过，为什么有些App一打开就知道你想干什么，而另一些却让你在菜单里翻来翻去找不到北？答案可能不只是界面设计的好坏，还藏在一个更底层的东西里，叫“语境架构”。这个词听起来很技术，但说白了，就是系统能不能读懂你当下的处境。想象一下，你深夜打开外卖软件，它直接给你推荐了附近的夜宵店，而不是早餐套餐，这就是语境在起作用。

尼尔森诺曼集团（Nielsen Norman Group）的这篇文章，把语境架构定义为一套设计原则，目的是让系统根据用户的使用场景、设备状态、时间地点甚至情绪变化，自动调整信息呈现和交互方式。比如，一个导航App在你开车时和在家规划路线时，应该给出完全不同的界面：开车时按钮要大、信息要少、语音更重要。这听起来理所当然，但很多产品做不好，因为语境不是简单的一个变量，而是多个维度的叠加。

文章提出了几个关键维度：用户身份（你是谁）、任务（你在做什么）、环境（你在哪、用什么设备）、时间（现在几点、第几次使用）。更重要的是，这些维度不是静态的，而是动态变化的。比如，一个健身App，早上和晚上推荐的内容可能完全不同：早上是晨间拉伸，晚上是助眠冥想。如果系统能识别出你刚跑完步，那它应该直接问你要不要记录，而不是先展示社区动态。

那么怎么设计呢？文章给出了一个框架：先收集语境信号，比如传感器数据、用户历史行为、日历事件等；然后对信号做推断，比如“用户在地铁上”可能意味着“信号弱、时间碎片化”；最后根据推断调整界面。但这里有个陷阱：过度依赖推断可能会出错。比如，系统以为你在开会所以静音了通知，但你其实只是忘了关静音。所以好的语境架构要允许用户随时纠正，甚至主动告诉系统自己的状态。

这篇文章的价值在于，它把“智能”这个词具体化了。我们总说AI要懂用户，但懂的前提是有一个结构化的方式来理解语境。对于做产品的人来说，这意味着不能只盯着功能列表，还要设计一套“感知-推理-响应”的闭环。而对于普通用户来说，理解语境架构，就能明白为什么有些产品越用越顺手，有些却总是让人烦躁，差别往往不在功能多少，而在它有没有在正确的时间给你正确的东西。

From COVID Pivot to AI World Building: How Snapbar Reinvented the Photo Experience

2020年，新冠疫情让很多线下生意突然停摆。美国有一家叫Snapbar的摄影公司，原本主要业务是给活动、婚礼、毕业典礼拍照片，疫情一来，所有大型聚会都取消了，订单几乎归零。很多公司在这个阶段选择裁员或者等死，但Snapbar的创始人做了一个完全不同的决定：他们不打算只等疫情过去，而是重新思考“拍照”这件事到底还能怎么玩。

这篇文章来自Product Talk，讲的就是Snapbar如何从一家传统摄影公司，转型成一个用AI构建沉浸式拍照体验的公司。他们的核心洞察是：人们想拍的不再只是一张照片，而是一个“世界”。比如，你走进一个房间，里面布置了复古的布景，灯光、道具、背景全部到位，你站在中间，系统自动拍下你在这个“世界”里的样子，这比单纯修图或者加滤镜有意思得多。

Snapbar的做法是，把实体布景和AI技术结合起来。他们不再派人去现场按快门，而是设计了一系列主题场景，比如“太空漫游”“老上海”“童话森林”，然后通过AI实时处理照片，让用户不需要任何后期就能直接拿到一张看起来像电影海报的照片。疫情期间，他们把这种模式做成了“无接触拍照亭”，人们可以独自进入布景，系统自动感应、拍摄、合成，全程不需要和任何人接触。

但真正有意思的是，他们并没有止步于疫情时期的应急方案。随着AI技术发展，Snapbar开始把“世界构建”做得更深入。比如，他们用生成式AI让用户不仅能在实体布景里拍，还能在虚拟场景里“进入”任何想象的地方，你站在一个绿幕前，AI就能把你放进一个中世纪城堡或者未来的火星基地，而且光影、角度都自然得像真的一样。

这篇文章最有价值的地方，不是讲技术细节，而是讲一个传统行业怎么通过理解用户的深层需求（不是“要一张照片”，而是“要一段沉浸式的体验”）来重新定义自己的业务。对于做产品的人来说，Snapbar的故事提醒我们：当外部环境剧变时，与其收缩防守，不如借机追问“用户真正想要的是什么”。有时候答案就藏在那些看似过时的业务里，只是需要换一个视角去看。

Building Lorikeet: How AI Humility and a Dual-Agent Architecture Are Redefining Customer Support

如果你用过现在市面上那些号称“AI客服”的产品，大概会有一种熟悉又失望的体验。你打过去，一个声音听起来很礼貌的机器人接电话，但它只能处理最机械的问题，比如“查余额”“改地址”。一旦你说“我上个月账单里有一笔交易我没做过，而且我换了手机号收不到验证码”，它立刻就卡住了，然后把你转给人工。转过去之后，你还得把刚才跟机器人说过的话再跟人工说一遍。整个过程并没有变快，只是多了一层让人烦躁的障碍。

Lorikeet 这家公司想做的，就是彻底拆掉这层障碍。但他们没有走最常见的路，做一个更聪明的单一AI，试图听懂所有复杂问题。他们发现，客户支持里最核心的矛盾不是AI不够聪明，而是“用户到底想要什么”这件事，天然就分两个层面。第一个层面是用户自己说出来的话，比如“我要退货”。第二个层面是用户没说出来的真实情况，比如他其实是因为买错了尺寸，又不好意思承认，所以才说“质量有问题”。一个AI如果只盯着字面意思，就会在错误的方向上费力解释，最后双方都不满意。

Lorikeet 的解法是双智能体架构。第一个智能体叫“倾听者”，它不做任何判断，只负责把用户说的话、语气里的犹豫、重复提到的词、甚至停顿的长短，都忠实地记录下来。它不急着回答，也不急着分类。它就像一个人坐在你对面，先听你说完，不插嘴。第二个智能体叫“推理者”，它拿到倾听者整理好的信息之后，才开始分析用户到底需要什么、最可能的解决方案是什么、需要调用哪些系统权限。这两个智能体分开跑，互不干扰，但数据是联通的。

这个设计有一个非常微妙的优点，作者称之为“AI的谦逊”。倾听者不假装自己什么都懂，它只做最笨的事，记录。推理者不急着下结论，它等够了信息再行动。这听起来简单，但在实际部署中效果很好，因为用户面对一个“先听再想”的系统，会比面对一个“边听边猜”的系统更有耐心。用户能感觉到对方在认真听，而不是在套模板。

更具体一点，Lorikeet 在部署时还会做一件事：让推理者在给出答案之前，先把它的理解用一句话复述给用户确认。比如“我理解您是说，您收到了一个破损的包裹，并且希望在今天之内得到退款方案，对吗？”这一步看似多余，但实际上是整个流程里最关键的安全阀。因为一旦用户说“不是，我不是这个意思”，推理者就立刻知道它走偏了，可以重新分析，而不是硬着头皮给一个错误答案。这个“确认循环”让 Lorikeet 的首次解决率比传统AI客服高出一大截，而且用户转人工的比例降到了很低的水平。

从商业角度看，这个案例给做AI产品的人一个很实在的提醒：很多时候，用户对AI的不信任，不是因为它能力不够，而是因为它“装懂”。一个愿意承认自己不确定、愿意先确认再行动的AI，反而更容易被接受。Lorikeet 没有追求让AI看起来像人，而是追求让AI看起来可靠。这两者之间有本质区别。读完这篇文章，你可能会开始重新思考，你的产品里那些“智能”功能，是不是其实在悄悄消耗用户对你的信任。

Using RAS to Guide UX Research Resource Allocation and Strategy

你有没有遇到过这种情况：公司里做用户研究的团队就那么几个人，但产品线有七八条，每个产品经理都跑来要求“帮我做个可用性测试”“帮我出个用户画像”。你心里清楚，资源根本不够，可又怕拒绝了会显得不配合业务。最后只能每个项目分一点时间，结果哪个研究都没做深，结论也不痛不痒。

Nielsen Norman Group 最近发了一篇文章，专门讲怎么用 RAS 框架来解决这类资源分配困境。RAS 是三个单词的首字母：Reach（触达范围）、Assurance（确定程度）、Scale（规模化程度）。听起来有点抽象，但你可以把它想象成一个三维坐标轴，每一维代表一个决策维度。比如你手头有一个研究需求，先问自己：这个研究结果要被多少人使用？如果只是给一个设计师看，触达范围就小；如果影响整个产品团队甚至公司策略，触达范围就大。再问：我们对这个领域已经有多少把握？如果是一个全新功能，用户行为完全未知，那确定程度就低，需要投入更多研究来降低风险。最后问：这个研究能不能规模化复用？比如你做一个用户细分研究，做完之后所有产品线都能用它来指导设计，那规模化程度就高。

文章举了一个很具体的例子。假设你在一家电商公司，产品经理想做一次购物车流程的可用性测试。用 RAS 来看：触达范围中等，因为只影响购物车相关团队；确定程度低，因为购物车转化率最近在下降，团队不知道原因；规模化程度低，因为这次测试的结果很难直接用到其他流程上。综合下来，这个项目优先级不算特别高。但如果你换成一个跨产品线的用户旅程地图研究，触达范围大，确定程度低，规模化程度高，那它就值得投入更多资源。

RAS 框架的真正价值不在于给你一个绝对答案，而是让团队在讨论资源分配时有一个共同语言。以前大家可能靠嗓门大小或者谁跟老板关系好来决定资源，现在可以坐下来，对着三个维度打分，然后理性地排序。文章还特别提醒，RAS 不是一次性的，它应该成为团队每个季度甚至每个月的例行工具，因为业务优先级在变，研究需求也在变。

读完这篇文章，你可能会意识到，用户研究团队面临的资源问题，本质上不是“人太少”，而是“怎么选”。RAS 提供了一个结构化的选择方法，让有限的资源花在刀刃上。下次再有人来要研究资源，你可以先请他一起给 RAS 打个分，再决定做不做、做多深。

Principles of Mechanical Sympathy

当你写代码的时候，有没有想过电脑实际上是怎么执行它的？大多数时候我们不需要想，框架、库、高级语言帮我们屏蔽了底层细节。但有些时候，程序突然变慢了，你加了更多服务器，却发现性能没有线性提升。这时候，你可能遇到了一个叫做“机械同理心”（Mechanical Sympathy）的问题。这个词最早是赛车手杰基·斯图尔特（Jackie Stewart）说的：他不需要懂怎么造发动机，但他必须理解发动机在什么转速下工作最好、刹车在什么温度下最有效，这样才能把车开到极限。写程序也是一样：你不必成为硬件工程师，但如果你不理解内存、缓存、磁盘、网络这些“机械”是怎么工作的，你的软件就永远跑不到它理论上能跑到的速度。

举个具体的例子。你写了一个循环，遍历一个数组里的数据。在代码层面，这看起来很简单。但在硬件层面，CPU 不会直接从内存里读数据，它会先把数据加载到自己的缓存（cache）里，因为缓存比内存快几十倍。如果你的数组在内存里是连续存放的，CPU 就能一次性把一大块数据预加载到缓存里，然后循环几乎以光速执行。但如果你的数据是散落在内存各处的指针（比如链表或者对象数组），CPU 每次都要去内存里“取”，速度就慢下来了。这就是为什么有时候用数组比用链表快得多，不是因为算法复杂度，而是因为缓存命中率。

马丁·福勒（Martin Fowler）在这篇文章里提出了一组原则，帮助开发者在设计系统时培养这种机械同理心。他并没有让你去读 CPU 手册，而是让你养成几个习惯：第一，理解你的数据在内存里是怎么布局的；第二，知道哪些操作是昂贵的（比如一次磁盘 I/O 可能比一次内存访问慢一百万倍）；第三，学会测量，而不是猜测。他特别强调，很多性能优化之所以失败，是因为开发者对“慢”的原因有错误的直觉。比如，你以为瓶颈在数据库查询，结果其实是网络延迟；你以为加更多线程能提速，结果因为锁竞争反而更慢。

文章还讲了一个真实的故事。有一家公司的系统每天要处理大量交易，他们发现系统偶尔会突然变慢几秒钟，查了很久找不到原因。后来他们用机械同理心的思路去分析，发现问题出在垃圾回收（Garbage Collection）上。Java 的垃圾回收器在回收内存时，会暂停所有线程（Stop-the-World）。平时暂停时间很短，但一旦内存碎片化严重，暂停时间就会飙升。他们通过调整内存分配策略，让对象更紧凑地排列，减少了碎片，问题就解决了。这个案例说明，很多时候性能问题不是“代码写得不对”，而是“代码和硬件配合得不好”。

读完这篇文章，你可能会开始用一种新的眼光看代码。每次写一个数据结构、选一个框架、设计一个接口，你都会问自己：这个操作在底层要花多少时间？数据是怎么流动的？有没有办法让硬件更舒服地执行？这种思维方式不会让你立刻变成性能专家，但它能让你在遇到性能问题时，有一个正确的方向去排查，而不是盲目地加机器或改代码。机械同理心不是一种技术，而是一种态度：尊重你所运行的机器，理解它的脾气，然后和它合作，而不是对抗。

How we layered product principles to refresh Slack notifications

你有没有过这样的经历：手机震了一下，你以为是重要消息，结果是群聊里有人发了个表情包；或者你正在专心写东西，突然被一条通知打断，结果发现那只是系统自动提醒。通知太多、太乱、太吵，几乎成了每个职场人的日常困扰。Slack 作为全球最流行的办公协作软件之一，它的通知系统每天要处理数亿条消息。但 Slack 的设计团队发现，用户对通知的抱怨从来没有停过，不是嫌太多，就是嫌太少，或者嫌该来的没来、不该来的却来了。于是他们决定重新设计整个通知体系，而这次重新设计的方法很有意思：他们不是直接动手改界面，而是先坐下来，梳理并分层了一套“产品原则”（product principles）。

这套原则不是那种挂在墙上的口号，而是真正用来指导每一个设计决策的标尺。Slack 团队把原则分成了三层。第一层是“核心原则”（core principles），这是所有产品决策的根基，比如“尊重用户的注意力”，意思是通知应该帮助用户而不是打扰用户。第二层是“通知特有原则”（notification-specific principles），专门针对通知这个场景，比如“每条通知都应该有明确的行动价值”，如果用户看到通知后不知道该做什么，那这条通知就不该出现。第三层是“可操作指南”（actionable guidelines），更具体，比如“不要在通知里重复用户已经看到的信息”。这三层原则像洋葱一样，从最抽象的价值观一层层剥到最具体的执行规则。

有了这些原则之后，Slack 团队开始重新审视每一个通知场景。他们举了一个很具体的例子：以前你在 Slack 里被 @提及（也就是别人用@符号直接叫你），系统会发一条通知，告诉你“张三在 #项目群 里提到了你”。这条通知看起来没问题，但仔细一想，它只告诉了你“谁在哪个频道提了你”，却没有告诉你“他到底说了什么”。你点进去之后可能发现只是一句“明天开会时间改到下午三点”，而这条消息本身并不需要你立刻回复。按照新的原则，“每条通知都应该有明确的行动价值”，这条通知就不过关，因为用户点进去之后并没有一个明确的行动要做。于是他们改成了在通知里直接显示消息内容的一部分，让你在锁屏上就能判断这件事是否需要立刻处理。

另一个有趣的案例是关于“通知分组”（notification grouping）。Slack 之前会把同一个频道里的多条通知合并成一条，比如“5 条未读消息来自 #设计组”。但用户反馈说，这种分组反而让人更焦虑，因为你不知道这 5 条消息里有没有紧急的事情，只能全部点开看一遍。设计团队重新思考了分组的逻辑：他们发现，真正有价值的分组不是按频道分，而是按“会话线程”（thread）分。比如你和同事在某个话题下连续回复了几条消息，这些消息应该被归为一组，因为它们是同一个对话的延续。而不同话题的消息混在一起，反而会让人失去上下文。这个改变听起来很小，但实际使用中，用户觉得通知变得更“有脑子”了，它知道哪些消息是同一件事。

Slack 团队还特别强调了一个设计哲学：通知的设计不应该只考虑“如何发送”，还要考虑“如何不发送”。他们引入了一个叫“通知静默期”（notification quiet hours）的机制，但这不仅仅是简单的“晚上不打扰”。他们发现，很多用户其实希望在非工作时间也能收到某些关键人物的消息，比如老板或者重要客户。于是他们设计了一个更精细的规则：你可以设置哪些联系人或频道可以突破静默期。这个功能背后反映的原则是“尊重用户的注意力，但也要尊重用户的判断力”，用户自己最清楚什么对他重要。

整个重新设计的过程持续了几个月，Slack 团队做了大量的用户研究（user research），包括访谈、日记研究（diary study）和 A/B 测试。他们发现一个反直觉的现象：用户嘴上说想要“更少的通知”，但实际行为却显示，他们真正想要的是“更相关的通知”。减少通知数量本身不是目的，目的是让每一条通知都有存在的理由。这个发现直接影响了他们的设计方向，不是一味地砍通知，而是让通知变得更聪明。

读完这篇文章，你会得到一个很清晰的判断：好的产品设计不是靠灵感，而是靠一套可以层层推导的原则体系。Slack 团队的做法给所有做产品的人一个启发，当你面对一个复杂问题时，不要急着画界面，先花时间把原则理清楚。原则越清晰，决策就越快，团队之间的争论也越少。而且，原则不是一次性的，它们会随着你对用户的理解而迭代。Slack 这次的通知重构，本质上是一次“用原则驱动设计”的实践，而最终的结果是用户觉得 Slack 更懂自己了，不是因为它发通知发得更勤快，而是因为它知道什么时候该闭嘴。

From Kickoff To First Concept: How To Turn Brand Strategy Into Visual Direction

想象一下，你是一家设计公司的负责人，刚拿到一份品牌策略文档，里面有目标受众画像、品牌价值观、市场定位……但接下来该怎么办？怎么把这些抽象的文字变成客户能看到的颜色、字体、图片风格？这就是很多设计师在项目启动阶段遇到的真实困境。Smashing Magazine 的这篇文章，讲的就是从品牌策略到视觉方向的第一步怎么走，而且走得不慌不忙。

文章没有一上来就讲色彩理论或者排版规则，而是先澄清一个前提：视觉方向不是设计师的“自由发挥”，而是策略的翻译。策略文档里那些“现代”“可靠”“温暖”这样的词，每一个都需要被转化成具体的视觉语言。比如“可靠”可能意味着稳重的衬线字体和低饱和度的蓝色，而“温暖”可能指向柔和的圆角、米色背景和带颗粒感的摄影。这个翻译过程，文章称之为“视觉概念化”（visual conceptualization）。

为了让这个翻译过程可操作，作者推荐了一个很具体的流程：先从品牌策略里提取三到五个核心关键词，然后围绕每个关键词做视觉探索（visual exploration）。探索不是直接找最终方案，而是收集大量参考，可以是其他品牌的网站、海报、摄影作品，甚至是建筑或服装的细节。这一步的关键是“广度优先”，先不要评判好坏，只管收集。然后，把这些参考整理成情绪板（mood board），但情绪板不是简单的拼贴，它需要有一个“视觉论点”（visual argument），也就是为什么这些图片放在一起能表达那个关键词。

文章里举了一个例子：假设品牌关键词是“手艺感”（craftsmanship），那么情绪板里可能包括手工陶器的纹理、老工具上的铜绿、手写标牌的墨迹变化。这些图片的共同点不是题材，而是“不完美但有温度”的质感。设计师需要向客户解释这种质感如何对应策略中的“手艺感”，而不是只说“我觉得这样好看”。

另一个关键点是“从宽到窄”的迭代。文章建议先做三个完全不同的视觉方向（visual directions），每个方向对应一个不同的策略解读。比如对同一个品牌，一个方向可能强调“极简科技感”，另一个方向强调“人文温暖感”，第三个方向强调“自然有机感”。这三个方向不是让客户选一个，而是通过讨论让策略更清晰，客户可能会说“我们要科技感，但不要冷冰冰”，这比一开始就说“我们要科技感”要具体得多。

最后，文章提醒不要过早进入细节。很多设计师拿到策略后直接开始设计 logo 或排版系统，但作者认为，在视觉方向没有确定之前，这些细节都是浪费。视觉方向应该先回答“整体感觉是什么”，然后才是“具体用什么字体”。就像盖房子，先确定建筑风格，再选门窗样式。

读下来你会觉得，这篇文章其实在讲一种“有纪律的创意”，把设计师的直觉和策略的理性结合起来。它不适合那些想找“快速出图技巧”的人，但如果你正在做一个品牌项目，或者需要向团队解释“为什么视觉探索这么重要”，它会给你一套很实在的思考框架。

Commercial vs Internal Products

想象一下，你在一家公司做产品经理，你的用户不是外面的消费者，而是公司内部的同事，财务部的人、客服团队、仓库管理员。你做的产品不卖钱，只用来提高内部效率。这就是内部产品（internal product）的处境。但很多人觉得内部产品比商业产品（commercial product）好做，因为没有竞争对手，用户没得选，只能忍。这种想法很危险。实际上，内部产品面对的是更挑剔的用户：你的同事。他们每天要用你的产品工作八小时，如果体验差、速度慢、功能不对劲，他们不会像外部用户那样默默流失，他们会直接抱怨、绕过系统用Excel、甚至当面骂你。而商业产品面对的是外部用户，用户觉得不好用可以换竞品，但公司至少能通过营销和品牌留住一部分人。内部产品没有这种缓冲。

那么，做内部产品和做商业产品，到底有什么本质区别？SVPG的文章指出，核心差异在于价值衡量方式。商业产品的价值最终体现在用户愿意付多少钱，或者广告能带来多少收入。你可以通过定价、付费转化率、用户获取成本（CAC）这些指标来判断产品做得好不好。但内部产品没有直接收入，它的价值体现在帮公司省了多少钱、省了多少时间、减少了多少错误。比如一个内部工单系统，如果能让客服处理一个工单的时间从10分钟降到5分钟，那每年节省的人力成本就是它的价值。但问题在于，这些价值很难精确计算，而且往往要等产品上线后才能验证。所以做内部产品时，你必须从一开始就想清楚：这个产品到底要解决什么业务问题？如何衡量它是否成功？

另一个关键区别是用户数量和需求多样性。商业产品面向海量用户，但你可以通过市场细分找到核心用户群，优先满足他们的需求。内部产品通常只服务几千甚至几百个员工，但这些员工来自不同部门，需求差异巨大。财务部想要报表自动生成，运营部想要实时库存看板，销售部想要客户历史记录。你不可能同时满足所有人。文章建议，内部产品经理也要像做商业产品一样，进行用户研究、划分用户角色、确定优先级。你不能因为用户是同事就跳过访谈和测试，反而要更频繁地收集反馈，因为内部用户的容忍度更低。

还有一个常被忽略的点：内部产品的“销售”方式完全不同。商业产品有市场团队、销售团队去推广，用户自己决定买不买。内部产品往往是强制使用的，公司决策层说“以后大家必须用这个系统”。但强制使用不等于用户会好好用。如果产品体验差，用户会消极抵抗，比如只完成最低限度的操作，或者找各种借口不用。所以内部产品经理需要花大量时间做“内部营销”：给用户培训、解释新功能的好处、收集痛点并快速迭代。你本质上是在争取用户的信任和合作，而不是用行政命令压他们。

最后，文章提醒了一个危险信号：很多公司把内部产品当成“二等公民”，认为不需要好的设计、不需要快速迭代，能跑就行。但正是这种心态导致内部系统越来越难用，最终迫使公司花大价钱采购外部SaaS产品来替代。实际上，内部产品如果能做到像商业产品一样注重用户体验和持续改进，它给公司带来的长期回报远超成本。一个优秀的内部产品不仅能提升效率，还能成为公司文化的一部分，员工会觉得公司重视他们的工作体验。所以，无论你做的是商业产品还是内部产品，核心原则是一样的：理解用户、定义价值、持续交付。只是内部产品更需要你把自己当成用户的同事，而不是供应商。

Malleable software: Restoring user agency in a world of locked-down apps

你有没有过这种感觉：用一款软件越久，越觉得是软件在指挥你，而不是你在指挥它。你想把一个表格里的数据换个方式展示，想修改某个按钮的行为让它更符合自己的习惯，或者想把两个工具的数据打通，但你没有权限，也没有办法。你只能按照开发者预设好的路径走。这种无力感，正是 Ink & Switch 那篇关于可塑软件（malleable software）的长文想要解决的起点。

文章首先点出了一个我们早已习以为常的现实：今天的软件，无论是手机上的 App 还是桌面上的 SaaS 工具，本质上都是“锁定”的。它们被封装成黑箱，用户能接触到的只有开发者精心设计的界面，而界面背后的逻辑、数据、交互方式，统统不可触及。这就像你买了一辆车，但引擎盖被焊死，你想换个轮胎都得找原厂。文章用了一个很形象的比喻：用户被降级成了“操作员”，而不是“使用者”。操作员只需要按按钮，使用者才有权改造工具本身。

那么，为什么软件会变成这样？文章并没有直接批判，而是从历史和技术演进的脉络去理解。早期个人电脑时代，软件是相对开放的，用户可以通过修改配置文件、编写脚本甚至直接修改代码来定制自己的工具。但随着软件产业的成熟，商业公司为了稳定、安全和盈利，开始把软件做成了封闭产品。再加上移动互联网和云服务的兴起，软件从“本地程序”变成了“远程服务”，用户连文件都存放在别人的服务器上，更别提修改了。这不是某个公司的阴谋，而是整个行业为了效率和规模而做出的选择，但代价是牺牲了用户的自主权（user agency）。

可塑软件的概念正是要找回这种自主权。它不是要回到命令行或者强迫每个人都学会编程，而是希望软件本身具备一种“可被修改”的天然属性。就像一张纸，你可以在上面写画、折叠、裁剪，而软件也应该允许你在使用过程中随时调整它的行为、外观和数据流动。文章举了一个很具体的例子：一个设计师团队用 Notion 管理项目，但 Notion 的数据库视图无法满足他们特定的筛选需求。在可塑软件的世界里，他们不需要等待 Notion 开发这个功能，而是可以直接在界面上添加一个自定义筛选器，甚至修改底层的数据模型来适配自己的工作流。

文章还深入讨论了可塑软件需要具备的几个关键特性。首先是“直接操作”（direct manipulation），即用户对软件的修改应该像使用工具本身一样直观，而不是打开一个完全不同的编程环境。其次是“渐进式学习”（progressive learning），用户可以从最简单的修改开始，比如调整颜色或布局，然后逐步深入，直到修改核心逻辑。最后是“安全沙箱”（safe sandbox），让用户可以放心地尝试修改，即使改坏了也能轻松回滚，不会破坏整个系统。

读到这里，你可能会觉得这听起来很像“低代码”或“无代码”平台。但文章特别澄清了区别：低代码平台往往是为了让非技术人员也能创建应用，但最终产出的仍然是一个封闭的“应用”；而可塑软件的目标是让所有软件都变得可塑，它不是一种新的开发范式，而是一种软件应有的品质。就像文字处理器应该允许你自由排版，而不是只提供几个预设模板。

最后，文章回到了一个更大的命题：软件应该服务于人的意图，而不是反过来。当我们习惯了被锁定在别人设计的流程里，我们也就慢慢失去了对数字环境的控制感。可塑软件不是要消灭专业开发者，而是重新分配权力，让每一个使用者都能在需要的时候成为自己工具的“作者”。读完这篇文章，你可能会开始留意自己每天使用的软件里，有多少地方是“本可以改改就好了”的，那正是可塑软件想要填补的空白。

Magic Ink: Information Software and the Graphical Interface

想象一下，你打开一个软件，它知道你现在在做什么、在什么情境下、想要达成什么目标，然后它直接把最需要的信息摆在最合适的位置，不需要你翻菜单、输关键词、调参数。你甚至感觉不到自己在“操作”软件，你只是在思考，然后信息就出现了。这个画面，就是 Bret Victor 在 2006 年那篇名为“Magic Ink”的著名文章里描绘的未来。

文章标题里的“Magic Ink”是一个隐喻。Victor 认为，理想的软件界面应该像一本精心设计的书：书页上的文字和图片不会跳出来让你点击，它们只是安静地呈现信息，而你的大脑会自然地去理解、吸收。软件也应该如此，不是一堆按钮和对话框，而是直接呈现与你当前任务最相关的信息，并且随着你的情境变化而动态调整。他称之为“情境感知软件”（situated software）。

为了说明这个想法，Victor 举了一个非常具体的例子：一个旅行指南 App。传统做法是，你打开 App，看到一堆分类：景点、餐厅、酒店、交通，然后你得逐个点进去，看列表，再点开详情。而情境感知的做法是：App 知道你此刻在哪个城市、什么时间、和谁在一起、预算多少，然后直接在地图上标出最合适的几个选项，并用颜色和大小暗示它们的推荐程度。你不需要搜索，不需要筛选，信息已经为你准备好了。

但文章并没有止步于这个理想画面。Victor 花了大量篇幅去分析为什么当时的软件（2006 年）做不到这一点，以及需要什么样的技术基础。他批评了当时主流的“直接操作”界面（direct manipulation interface），认为这种界面虽然让用户感觉可控，但实际上把大量认知负担转嫁给了用户，你需要记住功能在哪、怎么用、下一步该做什么。他提出，好的软件应该承担起“理解用户意图”的责任，而不是让用户去适应软件的逻辑。

为了实现这种理解，软件需要具备几个能力。第一是“感知”（sensing），即通过传感器、用户历史、上下文数据来了解用户所处的环境。第二是“推理”（reasoning），即根据感知到的信息推断用户当前的目标。第三是“呈现”（presentation），即把推理结果以最自然、最不干扰的方式展现出来。这三个环节环环相扣，缺一不可。

文章还深入探讨了“信息软件”（information software）的本质。Victor 认为，大部分软件本质上都是在处理信息：查找、比较、理解、决策。而传统的做法是把信息藏在一层层界面后面，让用户自己去发掘。Magic Ink 的愿景是让信息自己“浮现”出来，就像墨水在纸上逐渐显形一样自然。他甚至画出了详细的界面草图，展示了一个航班预订系统如何通过情境感知，直接告诉你“你应该坐这趟航班，因为它最符合你的时间和预算”，而不是让你去比较几十个选项。

读这篇文章时，你会不断被 Victor 的洞察和前瞻性所震撼。很多他在 2006 年提出的概念，比如上下文感知、预测性界面、主动式推荐，今天已经在一些产品中初步实现（比如 Google Now、Siri 的主动建议），但远未达到他描述的那种无缝体验。文章最后，Victor 提醒我们：技术的进步不应该只是让界面变得更花哨，而应该让界面变得更透明、更无形。真正好的软件，是你用它的时候感觉不到它的存在，只感觉到自己在思考。Magic Ink 不是一篇关于未来技术的预言，而是一份关于软件设计哲学的宣言，它质问每一个设计师和开发者：你是在帮助用户思考，还是在让他们替你思考？

A Treatise on AI Chatbots Undermining the Enlightenment

你有没有想过，当你在深夜对着一个聊天机器人倾诉烦恼，或者让它帮你写一封措辞复杂的邮件时，你其实正在参与一场微妙而深刻的思想变革？这不是科幻电影里那种机器人统治人类的戏码，而是一种更安静、更日常的改变，我们正在把一部分思考外包给机器，而这个过程，正在悄悄动摇一个我们习以为常的信念：理性思考是通往真理的唯一道路。Maggie Appleton 的这篇文章，就从启蒙运动讲起，为我们勾勒出这条信念从建立到松动的完整弧线。

启蒙运动的核心遗产之一，是“理性人”的假设。那时候的哲学家们相信，只要人类运用自己的理性，摆脱迷信和权威，就能获得可靠的知识，进而推动社会进步。这种信念塑造了现代教育、科学方法和公共讨论的根基。但文章提醒我们，这个假设本身就包含着一种暴力，它把“理性”抬高到了唯一正确的位置，贬低了情感、直觉、身体经验和社群智慧。而今天，当AI聊天机器人能流畅地模拟理性论证时，这个裂缝被撕得更大了。

想象一个场景：你让一个AI帮你分析一个复杂问题，它给出了一份逻辑严密的报告。你读了之后，觉得有道理，于是采纳了它的建议。但在这个过程中，真正进行推理的是谁？是你，还是那个在大量文本中统计出最可能回答的算法？Appleton 指出，AI的“理性”其实是一种模拟，它基于模式匹配，而非真正的理解。当我们在不知不觉中接受这种模拟理性时，我们也在重新定义什么是“好的思考”。这不仅仅是技术问题，更是认知政治问题：谁有权定义什么是合理的？

文章进一步探讨了这种变化对“启蒙理想”的具体冲击。启蒙运动强调个体的自主性，每个人都要用自己的头脑去判断。但如果AI能比我们更“理性”地得出结论，我们是否还应该坚持自己去思考？Appleton 没有简单地说“AI是坏的”或“AI是好的”，而是引导读者看到：我们正在进入一个后启蒙时代，在这个时代里，理性不再是唯一的权威，而只是众多认知方式中的一种。这听起来可能很抽象，但落实到日常中，就是当你更信任一个AI的理财建议而不是自己的直觉时，你已经在实践这种转变了。

最后，Appleton 提醒我们，这种转变既令人不安，也充满可能性。启蒙运动的遗产不会一夜消失，但它确实需要被重新审视。与其恐慌，不如主动思考：我们想要保留哪些启蒙价值（比如批判性思维、对真理的追求），又愿意放弃哪些（比如对纯粹理性的迷信）？AI的出现不是终点，而是一个契机，让我们重新追问那个古老的问题：作为人类，我们究竟如何知道我们所知道的？这篇文章不会给你标准答案，但它会让你在下次和聊天机器人对话时，多一层自觉，你正在参与一场认知革命，而这场革命的剧本，还没有写完。

A Brief Rant on the Future of Interaction Design

你打开手机，手指划过屏幕，照片放大、缩小、滑动。这个动作你已经做了几万次，熟练到不会多想。但如果有人告诉你，这种“触摸”其实根本不是触摸，你会怎么想？2011年，一位叫Bret Victor的设计师和工程师，在一篇后来被反复引用的文章里，毫不客气地说：我们现在引以为傲的触摸交互，本质上是在“用指尖戳一块玻璃”。他不是在抱怨手机不好用，而是在追问一个更根本的问题：人类的双手，生来是为了做更丰富、更精密、更有力量的事情的，为什么我们只让它们做这么一点点事？

Bret Victor在文章开头讲了一个小场景。他拿起一个iPhone，用手指在屏幕上滑动，照片随之滚动。他问：这个动作叫什么？我们通常说“滑动”（swipe），但仔细想想，你的手指真的在“滑动”吗？实际上，你的指尖只是在一块光滑的玻璃表面移动，玻璃本身没有任何纹理、阻力、温度变化。你感觉不到照片的厚度，感觉不到列表的边界，感觉不到任何物理世界的反馈。你的手指在做一件极其抽象的事：它在一个二维平面上移动，而屏幕上的内容根据一个预定义的算法做出响应。Bret Victor认为，这种交互方式不是在发挥手的潜能，而是在把人的手降级成一个“点选工具”。

他进一步对比了人手的真实能力。人的手可以感知温度、质地、重量、形状、软硬、湿度；可以抓、握、捏、拧、揉、撕、拉、压、弹、拍；可以同时做多个精细动作，比如弹钢琴时每根手指独立运动。而触摸屏呢？它只识别几种手势：点击、长按、滑动、双指缩放。而且这些手势的反馈几乎为零，没有物理阻力，没有触觉变化，没有力量感应。Bret Victor用了一个很形象的比喻：这就像你本来有一把瑞士军刀，却只用来当牙签。

文章的核心观点不是要否定触摸屏，而是指出：交互设计的未来不应该被“手指戳玻璃”这种单一模式锁死。他呼吁设计师和工程师去探索更丰富的交互方式，比如利用手的抓握、扭转、按压等自然动作，结合真实的物理反馈。他甚至举了一些例子：一个旋钮如果能在旋转时产生阻尼变化，就能让你“感觉”到数值的边界；一个按钮如果按下时有清晰的咔嗒感和力度变化，就能让你不用看也知道操作成功了。这些在传统机械时代很常见的设计，在数字时代反而被抛弃了，取而代之的是完全依赖视觉的、无触感的平面交互。

读这篇文章的时候，你会感受到一种强烈的紧迫感。Bret Victor不是在写一篇温和的行业观察，而是在发出一个警告：如果我们继续把交互设计局限于触摸屏，我们是在浪费人类几百万年进化出来的手部能力。他提醒我们，真正好的交互设计应该让工具成为身体的延伸，而不是让身体去迁就工具的局限。十多年过去了，这篇文章的论点依然锋利。现在的VR手柄、触觉反馈手套、甚至一些高级汽车的中控旋钮，都在尝试回应他的批评。但每当你在手机上因为误触、因为没有手感而反复调整音量或滚动条时，你就会想起那个2011年的质问：为什么我们还在戳玻璃？

读完这篇文章，你可能会开始用另一种眼光看待你每天使用的设备。你会注意到那些被忽略的触觉细节，也会意识到很多“创新”其实只是在玻璃上换了一种戳法。Bret Victor用他的怒意和洞察力，为交互设计留下了一个至今未被完全回答的问题。而这个问题，恰恰是所有关心产品体验的人无法绕开的起点。

Oratomic raises $300M to build a viable quantum computer that needs only 20K qubits

量子计算这个领域，过去几年你大概听到过很多次“多少多少量子比特”的新闻，比如谷歌声称实现量子霸权用了53个量子比特，IBM计划在2023年推出超过1000个量子比特的芯片。但一个冷酷的现实是，这些数字离真正能解决商业上有价值的问题，还差得很远。因为量子比特非常脆弱，容易出错，要纠错就需要大量物理量子比特来编码一个逻辑量子比特，所以一台有实用价值的量子计算机，可能需要上百万甚至上千万个物理量子比特。这正是当前行业最大的瓶颈。

一家叫Oratomic的创业公司，刚刚宣布拿到3亿美元融资，他们提出的方案听起来很反直觉：只需要2万个量子比特，就能造出有商业价值的量子计算机。他们的核心思路是，不追求量子比特数量上的军备竞赛，而是改善每个量子比特的保真度，也就是让每一个量子比特更可靠、更不容易出错。如果单个量子比特的质量足够高，纠错所需的冗余就可以大幅降低，最终总数量也能降下来。这就像你要盖一栋房子，与其用大量劣质砖头然后不断修补，不如直接用好砖，数量少一些也能建成。

Oratomic的技术路线基于一种叫做“中性原子”的量子比特，也就是用单个原子作为信息载体，用激光来操控它们。这个方向不像超导量子比特那么主流，但近几年开始被越来越多研究者看好，因为它天然具有一些优势，比如原子之间的一致性很好，而且容易扩展。Oratomic的创始人之前就在这个领域深耕多年，他们的关键突破是找到了一种方法，让原子量子比特的相干时间，也就是信息能保持稳定的时间，大幅延长，同时操控精度也显著提高。这样一来，纠错的开销就变小了。

3亿美元融资在现在的资本环境下不是小数目，领投方包括一些专注硬科技的顶级风投。这意味着投资者相信，Oratomic有可能跳过中间那些需要百万量子比特才能解决问题的阶段，直接用一个更小规模的量子计算机，在材料科学、药物设计、金融建模等场景里产生实际价值。当然，这条路还面临工程化挑战，比如如何把几万个原子稳定地排布在芯片上，以及如何让激光控制系统足够精确和低成本。但至少Oratomic给出了一个不同于巨量量子比特竞赛的路线图，而且用融资证明了资本愿意为这个新故事下注。对关注量子计算的人来说，这家公司值得持续跟进，因为它可能重新定义什么才算“够用”的量子计算机。

Apple sues OpenAI over alleged trade secret theft

苹果和OpenAI这两家公司，之前看起来关系还不错。苹果在2024年宣布和OpenAI合作，把ChatGPT集成到Siri里，用户可以直接通过语音调用聊天机器人。但到了2026年7月，剧情急转直下：苹果正式起诉OpenAI，指控后者窃取商业机密。诉讼的核心内容，按照TechCrunch的报道，是苹果声称OpenAI挖走了苹果在人工智能和隐私保护领域的关键员工，这些员工带走了苹果的专有技术，包括如何在不泄露用户数据的前提下训练大模型的方法。

苹果一直把隐私保护作为核心卖点，他们开发了一套名为“私有云计算”的架构，让AI模型能在设备端和云端之间安全地处理数据，用户信息不会被完整上传到服务器。这套技术是苹果多年投入的成果，也构成了其AI战略的护城河。苹果在诉状里说，OpenAI挖走的几位工程师曾深度参与这个架构的设计，他们离职后不久，OpenAI就发布了类似的技术方案，让模型能在用户设备上运行更复杂的推理，同时声称隐私保护级别很高。苹果认为这不可能是巧合。

OpenAI的回应也很强硬，他们否认窃取商业机密，表示公司一直有自己的隐私技术研发路线，并且苹果的指控是“毫无根据的”，目的是打压一个快速崛起的竞争对手。这场诉讼背后，其实反映了AI行业最核心的竞争已经不仅仅是模型能力，而是谁能先解决隐私和合规问题。苹果的商业模式建立在硬件和封闭生态上，用户信任是它的命根子；而OpenAI正在从纯云端模型转向混合部署，也开始重视本地运行和隐私保护。当两条路越来越近，技术人才和专利就成了最敏感的战场。

对于普通用户来说，这场官司短期内不会改变你使用Siri或ChatGPT的体验，但它会决定未来几年AI助手到底能在多大程度上了解你。如果苹果赢了，可能会限制OpenAI在某些隐私技术上的发展；如果OpenAI赢了，苹果可能需要重新思考自己的隐私优势还能保持多久。不管结果如何，有一点很清楚：AI的商业竞争，已经从比拼模型大小，进入到了比拼信任、隐私和系统级整合的阶段。而信任这种东西，一旦被放到法庭上辩论，往往没有赢家。

Build to Learn vs Build to Earn

你有没有遇到过这样的情况：一个产品团队花了好几个月开发一个功能，上线后却发现用户根本不怎么用？或者一个创业公司拼命迭代，用户量涨了，但收入始终起不来？硅谷产品集团（SVPG）的这篇文章，把这个问题归结为两种截然不同的产品思维方式：“为学习而构建”（Build to Learn）和“为赚钱而构建”（Build to Earn）。

“为学习而构建”听起来很美好，像是精益创业里说的快速验证假设。但文章指出，很多团队把“学习”当成了借口，不断做实验、做原型、做A/B测试，却迟迟不把产品推向真正的市场。他们可能在一个功能上测了十几种方案，最后选了一个，但用户并不买单。问题出在哪里？学习本身不是目的，学习是为了做出更好的决策。如果学习没有导向一个明确的行动，比如“这个功能应该砍掉”或者“这个定价应该翻倍”，那学习就是无效的。

“为赚钱而构建”则相反。它不是说产品只盯着钱，而是说产品最终必须创造可持续的商业价值。文章举了一个例子：一个团队做了一个新功能，用户很喜欢，使用率很高，但公司发现这个功能增加了服务器成本，却没有带来任何收入。团队觉得这是“用户价值”，但公司觉得这是“成本中心”。这种矛盾在B2B产品里尤其常见。文章提醒，为赚钱而构建不是要你牺牲用户体验，而是要你在设计产品时就考虑商业模式。比如，一个免费增值产品，免费版要足够好用，但高级功能必须让用户愿意付费。

文章的核心观点是，这两种模式不是非此即彼，而是应该形成一个循环。你先“为学习而构建”，快速验证某个功能是否解决用户问题。一旦验证了，就要立刻切换到“为赚钱而构建”，思考这个功能如何变成收入来源。很多团队卡在第一步，一直学一直学，从不商业化。或者反过来，一开始就拼命赚钱，结果产品体验很差，用户流失。真正健康的产品节奏是：学习、赚钱、再学习、再赚钱。

读完这篇文章，你可能会重新审视自己手头的项目。你是在做实验，还是在做产品？你的学习有没有转化为收入？如果答案是否定的，也许该问问自己：下一步是继续学，还是开始赚？

Show HN: Almanac – A self-updating wiki from your files

你有没有过这种经历：你电脑里散落着几十个文件夹，里面塞满了各种文档、笔记、截图、代码片段。你记得自己写过某个东西，但就是找不到。你试过用搜索，但关键词不对，或者文件太多，结果根本不相关。你开始想，要是这些文件能自己整理成一个知识库就好了，就像维基百科那样，但只属于你自己。Almanac（年鉴）就是为解决这个问题而生的。它是一个自更新的维基（self-updating wiki），直接从你的文件里提取内容，自动生成一个结构化的知识系统。你不用手动编辑，也不用操心分类，它就像有个智能管家，默默看着你的文件变化，然后帮你把零散的信息组织成可浏览、可搜索的页面。

你可能会好奇，它怎么知道哪些文件重要？怎么决定页面的结构？它用了一种类似搜索引擎索引（indexing）的方法，但不是简单列出文件名，而是理解文件之间的关系。比如你有一个项目文件夹，里面有设计稿、需求文档、会议记录，Almanac 会识别它们属于同一个项目，然后自动生成一个项目主页，把相关文件链接在一起。你改动了一个文件，它下次更新时就会反映出来。这听起来有点像 Notion 或 Obsidian 的自动整理功能，但 Almanac 更强调“自更新”和“从文件出发”。

它不要求你把所有东西都搬进一个特定应用，而是尊重你现有的文件存放方式。你继续用你习惯的编辑器、文件夹结构，Almanac 在后台工作，把你的文件变成可浏览的维基。这个理念很吸引人，尤其是对于长期积累了大量本地文件的人：开发者、研究者、写作者、项目经理。他们往往有很强的信息管理需求，但又厌倦了手动整理。Almanac 尝试用一种更被动的、自动化的方式来解决。它背后的假设是：你的文件本身就包含了足够的信息来构建知识网络，只是缺少一个能理解它们的工具。当然，这也有挑战：文件格式多样，内容质量参差不齐，自动提取的准确性如何保证？

隐私问题呢？文件都在本地，Almanac 是本地运行还是需要上传？从介绍看，它似乎更偏向本地优先（local-first），这符合很多技术用户的偏好。总的来说，Almanac 是在做一件很多人想过但没做成的事：让文件自己说话。它不承诺取代你的工作流，而是承诺让你从文件管理中得到更多。如果你是一个喜欢本地文件、讨厌手动整理的人，它值得你花时间试试看。你可以想象，未来你的文件不再是孤立的个体，而是一个不断生长的、相互关联的知识体。你打开 Almanac，就像打开一本只属于你的、永远在更新的百科全书。

The Hidden Why: Behavioral Economics for UX

你有没有遇到过这样的情况：明明设计了一个看起来很好用的界面，用户却总是做出“奇怪”的选择，比如忽略一个醒目的按钮、反复输入错误信息、或者坚持使用一个更复杂的路径？这不是用户笨，而是他们的大脑在“偷懒”。用户的行为并不总是理性的，他们依赖直觉、习惯和情绪做决定。这正是行为经济学（behavioral economics）能帮上忙的地方。

行为经济学融合了心理学和经济学，研究人们如何在实际决策中偏离“理性人”假设。丹尼尔·卡尼曼（Daniel Kahneman）和阿莫斯·特沃斯基（Amos Tversky）在20世纪70年代提出了前景理论（prospect theory），解释了为什么人们对损失的敏感程度远高于对收益的渴望。例如，损失100元的痛苦，大约需要赚到200元才能抵消。在UX设计中，这意味着如果你告诉用户“不这样做会失去什么”，往往比“这样做能得到什么”更有效。一个经典的例子是：在注册页面上，如果提示“您将失去免费试用资格”比“立即注册获得免费试用”更能推动转化。

另一个重要概念是系统1和系统2的思维模式。系统1是快速、自动、无意识的，比如你看到一张笑脸立刻知道对方开心；系统2是缓慢、理性、需要努力的，比如计算一道复杂的数学题。用户大部分时间都在用系统1，所以设计要迎合直觉，而不是强迫用户启动系统2。比如，一个默认选项（default option）就能大大影响用户的选择，因为人们倾向于不改变默认设置。在注册流程中，如果默认勾选“接收邮件通知”，大部分用户会保持勾选；如果默认不勾选，订阅率就会大幅下降。这就是所谓的“现状偏见”（status quo bias）。

还有一种常见的认知偏差叫“框架效应”（framing effect）：同一个信息用不同方式呈现，会导致不同决策。比如，一个手术有90%的存活率，听起来比有10%的死亡率更让人安心。在UX文案中，你应该选择对用户有利的框架。比如，错误提示不要说“您输入了无效的邮箱”，而是“请检查您的邮箱格式，确保我们可以联系到您”。

行为经济学还解释了为什么用户容易“信息过载”而放弃选择。当选项太多时，用户会感到焦虑，甚至直接离开。这就是“选择超载”（choice overload）。著名的果酱实验发现，当货架上只有6种果酱时，30%的顾客会购买；但当有24种时，只有3%的顾客购买。在设计中，减少选项、提供推荐或默认选择，可以减轻用户的决策负担。

最后，社会规范（social norms）也影响用户行为。人们倾向于模仿他人，尤其是当自己不确定时。显示“已有5000人购买了此课程”比“限时优惠”更能促进转化。这就是“社会证明”（social proof）。

理解这些行为经济学原理，并不是要“操纵”用户，而是帮助他们更轻松、更满意地完成目标。当你下次看到用户做出“不合理”行为时，不妨想想：是不是我的设计低估了他们的直觉？也许，那个被忽略的按钮，只是因为它的位置违背了用户默认的阅读路径。

读到这里，你会发现，好的UX设计不只是把界面画漂亮，更是对人性弱点的温柔体谅。

The 5 best real-time analytics platforms for developers, compared

想象一下，你刚上线了一个新功能，比如社交应用里的“一键分享视频”。你坐在电脑前，盯着屏幕，想知道现在有多少人在用这个功能。你刷新一次，数字变了。再刷新，又变了。但你真的知道发生了什么吗？实时分析（real-time analytics）就是解决这个问题的。它不是每天或每小时告诉你“昨天有1000人分享”，而是告诉你“就在此刻，有3个人正在分享，其中1个已经成功了”。对于开发者来说，这种能力极其重要，尤其是在做产品实验、监控系统健康、或者运营一场直播活动的时候。但问题来了：市面上那么多实时分析平台，到底该选哪个？PostHog 的这篇文章就帮你做了这个比较。

文章选了五个平台：PostHog 自己、Datadog、Mixpanel、Amplitude 和 Grafana。它们都能处理实时数据，但侧重点完全不同。Datadog 更像一个监控系统，它擅长告诉你服务器有没有挂，API 响应时间是不是变慢了。如果你是一个后端工程师，半夜被叫起来看告警，Datadog 很合适。但如果你想了解用户行为，比如“用户点击了哪个按钮才触发这次错误”，Datadog 就不太擅长了。Mixpanel 和 Amplitude 是经典的“产品分析”工具，它们能追踪用户事件，比如“注册”“购买”“分享”。它们也有实时视图，但更偏向于给你一个“实时看板”，显示过去几分钟的活跃用户数或事件数。不过，它们的实时性通常有几分钟的延迟，而且查询复杂历史数据时可能会更慢。

Grafana 是另一个路子。它是一个开源的可视化平台，可以连接各种数据源，比如 Prometheus、InfluxDB 或者 PostgreSQL。你可以自己搭建一个实时仪表盘，显示任何你想看的指标。但 Grafana 本身不存储数据，也不做分析，它只是一个画图工具。所以你需要自己搞定数据管道和存储。最后是 PostHog，它既是一个产品分析工具，也提供实时功能。PostHog 的实时视图可以显示最近几秒内发生的事件，比如“用户注册”“页面浏览”，并且你可以直接点击这些事件去查看具体用户的行为。它还支持“实时动作”（actions），比如你可以设置一个条件：当用户连续三次注册失败时，实时触发一个告警。

文章里还提到了一个关键区别：延迟。实时分析平台的延迟通常有两种：一种是“端到端延迟”，即从用户操作发生到数据出现在仪表盘上的时间；另一种是“查询延迟”，即你写一个查询到结果返回的时间。对于实时场景，端到端延迟更重要。PostHog 声称它的实时视图延迟在 1 秒以内，而 Mixpanel 和 Amplitude 的实时视图通常有 30 秒到几分钟的延迟。Datadog 的延迟也很低，但它是针对基础设施的，不是用户事件。

另外，文章还讨论了“采样”（sampling）的问题。有些平台为了降低成本，会对实时数据进行采样，只展示一部分数据。比如，你看到实时仪表盘上显示“100 个事件”，但实际上可能只有 10% 的数据被采样了，真实事件是 1000 个。如果你在做 A/B 测试或者调试一个罕见 bug，采样会让你误判。PostHog 和 Datadog 支持全量数据实时展示，但代价是成本更高。

最后，文章给出了一个很实用的建议：不要只看“实时”这个词，要看你到底需要实时做什么。如果你只是想知道“现在有多少人在线”，那么大部分平台都能做到。但如果你需要实时地调试一个用户问题，比如“为什么这个用户付款失败了”，那么你需要的是一个能实时查看单个用户事件流的工具，比如 PostHog 的“用户会话回放”（session recording）结合实时事件。如果你需要监控服务器性能，那就选 Datadog。如果你需要把实时数据和其他业务指标（比如收入）结合起来，Grafana 可能更灵活。

读完这篇文章，你会明白一个道理：实时分析不是一个功能，而是一系列权衡。没有完美的平台，只有适合你当前场景的工具。下次再有人跟你说“我们的平台是实时的”，你可以问一句：“实时到多少秒？采样吗？能看单个用户吗？”

The new product introduction process: How to make sure your Agent is ready every time you ship

想象一下，你是一个产品团队，刚刚开发了一个能自动回答客户问题的 AI 助手（Agent）。你兴奋地把它部署上线，结果第一天就出了岔子：客户问“我的订单什么时候到”，助手回答了一个完全错误的日期。客户生气，你的客服团队手忙脚乱，你的老板问“测试的时候怎么没发现”。这个场景是不是很熟悉？Intercom 的这篇文章就是来帮你解决这个问题的。他们提出了一套叫做“新产品引入流程”（New Product Introduction，简称 NPI）的方法，专门用来确保每次发布 AI 助手时，它都是真正可靠的。

NPI 听起来像是大公司才用的复杂流程，但 Intercom 把它拆解得很实际。核心思路是：不要把发布 AI 助手当成一次性事件，而要当成一个持续的过程。文章里分享了一个很具体的例子。他们曾经在发布一个 AI 助手时，因为对“用户意图”（intent）的边界定义不清，导致助手把“我想取消订单”和“我想修改订单”混为一谈。用户明明想取消，助手却给出了修改订单的流程，结果用户体验极差。这个教训让他们意识到，必须在发布前就对每个可能的用户意图进行严格测试。

那么 NPI 具体怎么做呢？Intercom 建议分几个阶段。首先是“准备阶段”（Readiness），你需要定义清楚你的 AI 助手要解决什么问题，它的边界在哪里。比如，你的助手是只能处理退货问题，还是能处理所有售后问题？边界越清晰，助手越不容易犯错。然后是“测试阶段”（Testing），这里不是简单跑几个测试用例，而是要模拟真实用户的对话。他们特别强调要测试“边缘案例”（edge cases），比如用户拼写错误、情绪激动、或者问一个非常模糊的问题。文章里提到，他们曾经用一个真实客服对话数据集来训练和测试，结果发现助手在 80% 的情况下表现良好，但在剩下 20% 的棘手对话中几乎完全失败。这让他们意识到，测试不能只看平均表现，要关注最差情况。

最后是“监控阶段”（Monitoring）。发布之后不是结束，而是开始。Intercom 会持续监控 AI 助手的对话，尤其是那些用户最终选择转人工的对话。这些对话往往暴露了助手的盲区。他们会定期分析这些“失败”对话，然后更新模型或者调整流程。文章里有个数字很关键：他们发现，通过这种持续监控和迭代，AI 助手在发布后的第一个月里，准确率可以从 70% 提升到 90% 以上。

读到这里，你可能会想，这听起来很合理，但做起来是不是很重？Intercom 也考虑到了这一点。他们建议从小处着手，先选择一个最核心的用户场景（比如“查询订单状态”），把这个场景的 NPI 流程跑通，再逐步扩展到其他场景。不要一开始就想覆盖所有问题。另外，他们强调要让客服团队深度参与。因为客服最了解用户真正在问什么，他们的反馈是改进助手的最佳来源。

这篇文章最终想传达的是：AI 助手不是写几行代码就能上线的玩具，它需要和传统软件一样严格的发布流程。但好消息是，这个流程并不神秘，它就是对“测试、发布、监控、迭代”这一经典循环的认真执行。如果你正在做 AI 产品，不妨从今天开始，为你的下一个助手定义一个简单的 NPI 流程。哪怕只是多花半天时间测试边缘案例，也会让你的用户少生一次气。

GPT-5.6 Sol vs. Claude Fable: Why OpenAI’s new model crushes my benchmark

如果你最近在关注AI领域的新闻，可能已经注意到一个现象：大模型公司之间的竞争，正在从“谁的模型更聪明”转向“谁的产品更让人想用”。这篇文章的作者Lenny，就是那位常年写产品增长策略的知名作者，他用自己的一个日常基准测试，亲身体验了这种转变。

Lenny有一个习惯：每当新模型发布，他都会用同一个任务去测试，让他自己的产品（一个AI写作助手）生成一段特定风格的文案。这个任务不算难，但很实际，不是那种数学竞赛题或者复杂的逻辑推理，而是真实的产品场景。过去，他一直在用Claude的某个版本（他称之为Claude Fable，一个内部昵称）来完成这个任务，效果一直不错。直到OpenAI发布了GPT-5.6 Sol（也是内部代号），他试了一次，结果让他惊讶，新模型不仅完成了任务，而且完成得更好，更自然，几乎不需要他再手动修改。

这个对比之所以有意思，不是因为GPT-5.6在某个排行榜上分数更高，而是因为它在Lenny的真实工作流里赢了。这恰恰是很多AI公司现在最焦虑的事情：你的模型在学术基准上再强，如果用户在实际使用中感觉不到明显差异，他们就不会切换。反过来，如果某个模型在某个具体场景里让用户觉得“哇，这比之前的好用多了”，那它就有可能真正赢得用户。

文章里没有停留在“谁赢谁输”的结论上，而是借这个例子讨论了一个更深的问题：为什么OpenAI这次能做出这样的改进？Lenny从自己的观察出发，认为关键在于OpenAI调整了训练和优化策略，更注重“有用性”而非“聪明度”。这不是一个容易量化的方向，因为“有用”对不同用户意味着不同的事情。但至少在这个案例里，GPT-5.6 Sol在生成文案时更少出现“过度解释”“过于礼貌”或者“无意义的啰嗦”，而是直接给出了一个可以用的版本。

对于产品经理和增长团队来说，这篇文章的启发可能不在于技术细节，而在于一个思路：评估AI产品时，与其盯着各种基准分数，不如建立自己的“用户任务基准”（user task benchmark）。就像Lenny做的，用一个你每天都在做的真实任务去测试，看哪个模型能让你少花时间修改、少感到挫败。这个思路其实也适用于其他AI工具，比如代码生成、数据分析、客服回复等。

当然，文章也提醒了一点：这种优势可能不持久。今天GPT-5.6 Sol在Lenny的测试里赢了，明天Claude的下一版可能又反超。真正的竞争不是一次性的胜负，而是谁能持续地让用户觉得“这个更好用”。对于AI产品公司来说，这意味着要不断关注用户的实际体验反馈，而不是只盯着技术指标。

最后，Lenny在文章里留了一个开放的问题：如果你也在用AI做类似的事情，不妨自己也试试这个“个人基准测试”。你可能会发现，你一直以为最好用的模型，其实已经被另一个悄悄超越了。这种亲手验证的感觉，比任何评测文章都更有说服力。

Design-System Maturity: A 6-Dimension Framework

很多团队在做设计系统，但做到一半就卡住了。组件库建了，文档写了，可设计师和工程师还是各用各的版本，新来的同事不知道去哪里找图标，每次改样式都要翻几十个文件。问题出在哪里？Nielsen Norman Group 这篇文章给出了一个框架，它不是告诉你“要不要建设计系统”，而是帮你判断你的设计系统走到了哪个阶段，以及下一步该往哪里走。

框架有六个维度：视觉设计、组件库、文档、治理、工具链、文化。每个维度都分五个成熟度等级，从“初始”到“优化”。比如视觉设计这个维度，最底层是完全没有统一规范，设计师凭感觉选颜色和字体；再往上一点，有了品牌指南，但没人强制执行；到了中间等级，有了可复用的设计令牌（design tokens），颜色、间距、字体大小都定义成变量，改一个值就能全局更新；最高等级则是系统能自动适应不同平台和场景，比如根据用户偏好切换暗黑模式。

这六个维度不是必须同步发展的。很多团队组件库已经做得很丰富，但治理跟不上，没有明确的决策流程，谁都可以往库里加东西，结果组件越来越多，质量参差不齐。或者文档写得很好，但工具链落后，设计师还在用 Sketch 手工标注切图，工程师却已经切换到 Figma 加代码生成。文章建议团队先评估每个维度的当前等级，然后找出最薄弱的环节优先改进，而不是平均用力。

举个例子，假设你的组件库已经覆盖了 80% 的常用界面，但文档只停留在“安装说明”阶段，没有使用示例、行为说明和可访问性要求。这时候你花再多时间做新组件，别人还是不知道怎么用、什么时候用。更聪明的做法是先把文档补到“推荐”等级，给每个组件配上交互演示、代码片段和设计准则，这样组件才能真正被用起来。

文化维度容易被忽视，但恰恰是决定设计系统能否持续的关键。如果团队里没有“组件优先”的意识，设计师每次做新页面都从零画起，工程师习惯复制粘贴旧代码，那系统再完善也救不了。文化成熟度高的团队会把设计系统当成“产品”来运营，有专人维护、定期更新、收集反馈，甚至像内部开源项目一样接受贡献。

读完这个框架，最大的收获可能不是具体怎么做，而是知道该往哪个方向用力。设计系统不是一次性的项目，而是一个需要持续投入和迭代的基础设施。下次你的团队在讨论“要不要重新设计按钮”之前，不妨先问问：我们现在的薄弱环节到底是什么？是组件不够全，还是大家根本不知道有组件？

AI Model Co-Design: Hardware-Friendly LLM Design

大语言模型越做越大，参数从几十亿涨到上千亿，但一个现实问题越来越突出：这些模型跑起来太费电、太费钱。训练一个 GPT-4 级别的模型，电费可能高达上亿美元，推理时每生成一个 token 都要消耗大量算力。硬件厂商和模型研究者开始意识到，不能各干各的，模型设计要考虑硬件特性，硬件设计也要为模型优化，这就是“AI 模型协同设计”（AI Model Co-Design）。

NVIDIA 的这篇文章讲的就是这个思路。传统的做法是，研究者先设计模型架构，比如决定用多少层 Transformer、多大的隐藏维度，然后再想办法把模型适配到现有硬件上。如果模型太大，就做量化（quantization）把参数从 32 位浮点数压缩到 8 位整数，或者做剪枝（pruning）去掉不重要的连接。但这些方法往往有精度损失，而且适配过程很痛苦。

协同设计反过来：在设计模型架构的时候，就把硬件的特性考虑进去。比如 GPU 擅长做矩阵乘法，但不太擅长处理稀疏数据；内存带宽有限，所以减少内存访问次数比减少计算量更关键。如果模型设计时就能让计算密集且连续，避免频繁的随机内存访问，那么即使参数量大，实际运行速度也可能更快。

文章举了一个具体例子：Transformer 模型中的注意力机制（attention）需要计算查询（query）和键（key）的点积，这个操作在 GPU 上可以并行加速。但标准的注意力实现需要把整个注意力矩阵存下来，占用大量显存。如果改成“Flash Attention”这种硬件感知的实现，通过分块计算和重计算，就能大幅减少显存占用，同时不降低精度。这就是协同设计的一个典型成果。

另一个方向是模型量化。传统量化是训练完模型后再做，现在研究者尝试在训练过程中就模拟量化效果，让模型学会在低精度下也能保持准确。比如在训练时把部分权重故意“四舍五入”到 8 位，然后计算损失，让模型自己调整参数来适应这种精度损失。这样训练出来的模型天生就对硬件友好，不需要后期再花大力气适配。

对于做 AI 产品的人来说，这个趋势意味着什么？如果未来模型更高效，同样的算力能跑更大的模型，或者同样的模型能跑在更便宜的硬件上，那么 AI 产品的成本结构就会改变。比如一个聊天机器人，如果推理成本能降低 10 倍，那么免费版就能提供更多对话次数，或者更复杂的模型也能开放给用户。

当然，协同设计目前还处于早期阶段，需要模型研究者、硬件工程师和编译器开发者紧密合作。但方向已经很清楚：与其让模型和硬件互相迁就，不如从一开始就让它们互相理解。

Open source AI matters more than ever, according to Hugging Face’s Clem Delangue

你大概已经注意到，过去一两年里，几乎每家大公司都在推出自己的大语言模型，从 OpenAI 的 GPT 到 Google 的 Gemini，再到 Meta 的 Llama。这些模型一个比一个大，一个比一个贵，训练一次动辄上千万美元。普通开发者、小公司甚至研究者，越来越觉得自己被排除在 AI 的“核心圈”之外。Hugging Face 的联合创始人兼 CEO Clem Delangue 最近在一个播客里谈到了这个问题，他的观点很直接：开源 AI 比以往任何时候都更重要，而且这不仅仅是一个技术选择，更关乎整个行业的健康。

Delangue 举了一个很具体的例子来说明开源的威力。他说，当 Hugging Face 在 2021 年发布 BLOOM 这个开源大模型时，很多人觉得“开源模型怎么可能比得上闭源模型？”但事实是，BLOOM 之后，社区基于它做了大量微调和改进，衍生出上百个变体，覆盖了从医疗到法律的垂直领域。这些变体中的一些，在特定任务上的表现甚至超过了当时最好的闭源模型。Delangue 强调，开源的价值不在于“复刻”一个 GPT-4，而在于让 AI 的能力可以被无数人“重新组合”和“定制”，从而解决那些大公司根本不会去碰的“长尾问题”。

他进一步解释，闭源 AI 的商业模式本质上是“卖水”，你只能买他们提供的模型，用他们设定的接口，接受他们制定的规则。这就像早期互联网只有 AOL 和 CompuServe 这样的封闭平台，直到开源协议和万维网的出现，才催生了今天丰富多彩的网站和应用。Delangue 认为，AI 行业正在重演这段历史：如果只有少数几家闭源模型，创新会变得非常缓慢，因为所有开发者都在同一个“水龙头”下排队等待更新。而开源让数千个“水龙头”同时出水，虽然每个水流可能小一些，但加起来覆盖的范围和多样性远超任何单一闭源模型。

当然，开源 AI 也面临现实挑战。Delangue 坦承，训练一个像 Llama 3 或 GPT-4 那样规模的模型，成本确实高得离谱，不是每个组织都能负担。但他指出，真正的突破可能不在“最大模型”上，而在“更小、更高效、更可定制”的模型上。Hugging Face 自己的研究显示，很多企业应用根本不需要千亿参数级别的模型，一个精心调校的 70 亿参数模型，配合领域数据微调，往往就能满足 90% 的需求，而且部署成本、推理速度和隐私安全性都更好。这就像你不需要一辆 F1 赛车去接孩子放学，一辆可靠的轿车反而更实用。Delangue 最后总结，开源 AI 的意义不是“免费”，而是“自由”，自由地检查模型内部做了什么，自由地修改它适应自己的场景，自由地不依赖任何一家公司的路线图。这种自由，才是 AI 行业长期健康发展的根基。

Meta removes controversial AI feature on Instagram after backlash

你有没有遇到过这样的情况：打开Instagram，突然看到一个由AI生成的你的头像，配上一句它替你写的话，像是“今天在公园散步，心情很好”，然后这个帖子被推给了你的所有好友。你可能根本不知道这件事发生了，直到朋友发来消息问“你最近怎么开始用AI发帖了？”这种尴尬不是假设，而是真实发生在许多Instagram用户身上的事。Meta最近推出了一项新功能，允许用户创建“AI角色”来代表自己，甚至可以用这个角色自动生成帖子、回复评论。

听起来像是未来社交的雏形，但实际体验却让很多人感到被冒犯。用户发现，这个AI角色会模仿他们的语气、使用他们的照片，发布一些他们自己绝不会写的内容。更让人不安的是，这个功能默认是开启的，很多人是在不知情的情况下被“AI化”了。社交媒体本来应该是展示真实自我的地方，哪怕那个自我是精心修饰过的，但至少是用户主动选择的。当AI开始替你表达，社交就变成了一场你不知道自己参与了的表演。Meta显然低估了用户对“控制权”的在意程度。在大量用户投诉、媒体曝光后，Meta不得不宣布暂停这个功能。

但问题并没有解决：为什么一家公司会认为用户会喜欢一个替自己发声的AI？这背后其实是硅谷对AI能力的过度乐观。工程师们看到技术能生成逼真的文本和图像，就默认用户也会觉得“好玩”，却忽略了社交产品最核心的信任问题。用户需要知道屏幕背后是谁在说话，这是社交的基本前提。AI可以帮你调滤镜、推荐好友、甚至写文案草稿，但一旦它取代你成为“发言人”，社交的意义就变质了。这次事件给所有做AI产品的团队一个提醒：技术越强大，越要尊重用户的边界。不是所有能做的事，都是用户想要的事。Meta的这次翻车，不是因为AI不够聪明，而是因为它太聪明，聪明到忘记了问用户一句：“你愿意吗？”

Build To Learn FAQ

很多做产品的人都会遇到这样一个困境：团队花了好几个月把功能做出来，上线后发现用户根本不买账。问题出在哪里？往往不是执行不够好，而是从一开始就没有弄清楚该不该做这件事。硅谷产品集团（Silicon Valley Product Group）的创始人马蒂·卡根（Marty Cagan）一直在倡导一个理念，叫做“为学习而构建”（Build to Learn）。这个理念听起来很简单，但真正做起来，需要整个团队对产品开发的理解发生根本性的转变。

传统的产品开发流程是“构建-发布-学习”（Build-Ship-Learn），团队先决定要做什么，然后花大量时间开发，最后发布出去，再通过数据或用户反馈来学习。但“为学习而构建”把顺序倒过来了：先明确你想要学习什么，然后为了验证那个假设，才去构建最小必要的东西。这个最小必要的东西可能不是一个完整的功能，甚至不是一个可用的产品，它可能只是一个原型、一个着陆页、一段视频，或者一个手动模拟的后台操作。关键是，构建的目的不是为了交付价值，而是为了减少不确定性。

举个例子，假设你的团队想在一个电商应用里加入“虚拟试穿”功能。传统做法可能是先花三个月开发图像识别和3D渲染，然后上线看用户用不用。但“为学习而构建”的做法是：先问自己“我们真正想验证的假设是什么？”可能是“用户愿意花时间上传自己的照片来试穿衣服”，或者“虚拟试穿能提高购买转化率”。为了验证第一个假设，你甚至不需要真正的3D渲染，你可以做一个简单的页面，让用户上传一张照片，然后手动发一张合成的效果图给他们。这只需要一两天，但你能很快知道用户是否愿意走完这个流程。如果没人上传照片，那后面的技术投资就完全没有必要。

卡根在他的文章里反复强调，这种思维方式最大的障碍不是技术，而是文化。很多产品经理、设计师和工程师习惯了“交付功能”的成就感，他们觉得做一个半成品或者手工模拟的东西不体面。但真正优秀的产品团队会意识到，浪费几个月做一个没人用的功能，才是最大的浪费。所以“为学习而构建”不是一种偷懒，而是一种更负责任的做法。

当然，实际操作中会有很多疑问：什么时候该用这种方法？什么时候该直接做完整功能？团队怎么衡量学习的效果？卡根在他的FAQ里回答了这些常见问题。比如，他建议当团队面对高度不确定性的假设时，就应该优先考虑“为学习而构建”。如果假设已经很明确，比如用户需要登录才能保存购物车，那直接做就好了。他还提到，学习的目标应该具体、可衡量，比如“在24小时内，有超过10%的访客点击了试穿按钮”，而不是模糊的“看看用户喜不喜欢”。

读完这篇文章，你可能会意识到，产品开发的核心不是产出代码，而是产出知识。每一次构建都是一次实验，而实验的目的是让团队对用户和市场的理解变得更清晰。如果你能接受这个前提，那么你的产品开发流程就会变得更快、更便宜，也更容易做出真正对的东西。

Show HN: Openleetcode – LeetCode runner where tests live in the repo

你刷 LeetCode 的时候有没有遇到过这种情况：一道题本地跑得好好的，提交上去就是不过，报一个莫名其妙的测试用例失败。你翻来覆去看自己的代码，觉得逻辑完全对，但就是不知道到底哪个边界没覆盖到。问题往往出在 LeetCode 平台自带的那些隐藏测试用例上。它们不会提前告诉你，你只能一次次提交、失败、再猜。OpenLeetCode 这个项目想改变的，就是这件事。

它本质上是一个 LeetCode 的运行器（runner），但做了一件很特别的事：把测试用例直接放在代码仓库里（tests live in the repo）。什么意思呢？就是你 clone 下来一个题目的仓库，里面除了你的解法代码，还有一个 tests 文件夹，里面放着对应的测试用例。这些测试用例不是你自己写的，而是项目作者预先整理好的，很可能就是 LeetCode 官方那些隐藏用例。你在本地跑一下测试，就能立刻看到你的代码在哪一个具体输入上失败了，输出是什么，期望输出又是什么。

这听起来好像只是一点小小的便利，但对刷题的人来说，体验差别巨大。传统做法是你在本地写代码，写完之后手动构造几个例子跑一下，觉得没问题就粘贴到 LeetCode 上提交。但人构造的例子往往太简单，或者太偏向自己代码的逻辑，很难覆盖所有边界。而 OpenLeetCode 把官方测试用例直接摊在你面前，你就能在提交之前，用和平台完全一样的测试集去验证。这等于把原来黑盒的评测过程变成了白盒。

项目是用 GitHub Releases 发布的，当前版本是 v1.0.2。作者显然希望这个工具能持续更新，随着 LeetCode 题库的变化同步调整测试用例。对于正在准备面试、大量刷题的人来说，这种工具能节省很多反复提交试错的时间，也能让学习过程更聚焦在算法本身，而不是在猜测测试用例上。

当然，它也有一个潜在的前提：你愿意在本地搭建一个运行环境，并且信任作者整理的测试用例和官方一致。不过对于已经习惯在本地用 IDE 写代码的开发者来说，这几乎不算门槛。OpenLeetCode 更像是一个小但精准的改进，把刷题流程中那个最令人沮丧的环节，看不见的测试用例，变成了你可以主动检查和理解的资源。读完之后你会觉得，有时候一个好的产品思路，就是把用户原本需要猜的东西，直接摆到桌面上。

Your New UX Habit: Establishing Baselines for Impact

想象一下，你刚上线了一个新的注册流程，把步骤从五步减到了三步。一周后，注册完成率从40%涨到了60%。你很高兴，觉得改对了。但等一下，你怎么知道这个提升不是因为恰好赶上了一个营销活动？或者是因为竞争对手出了故障，用户都涌过来了？你其实不知道，除非你在改动之前就知道那个40%是怎么来的。这就是基线（baseline）的意义。

基线不是一句口号，它是一个具体的、可测量的起点数据，用来对比你后续的改动到底有没有效果。很多团队犯的错误是：产品上线后直接看新数据，觉得不错就收工了。但如果没有基线，你永远没法区分“真正的改善”和“自然波动”。比如，你改了一个按钮颜色，转化率从5%变成6%，你以为是颜色起了作用，但其实可能是那天刚好是发薪日，用户花钱更大方。基线帮你排除这些干扰。

那怎么建立基线呢？文章给出了很实用的方法。首先，你必须在你改动之前就收集数据。这不是事后补的，而是提前规划好的。比如你要改搜索功能，先记录下当前用户搜索的成功率、平均搜索时长、点击结果的比例，至少持续一两周，确保数据稳定。其次，基线要覆盖关键指标，不只是最终转化率，还要包括过程指标，比如用户在哪一步流失最多、哪个页面加载最慢。这些细节能帮你定位问题，而不是只看到一个模糊的数字。

一个具体的例子是：某团队想优化结账页面，他们先记录了当前结账完成率是45%，然后发现用户主要在“输入地址”这一步离开。于是他们改成了自动填充地址，改完后完成率升到55%。但因为有了基线，他们知道这10%的提升是真实发生的，而不是因为季节性或促销活动。如果没有基线，他们可能只是庆祝一下，然后继续做下一个改动，而不知道真正有效的到底是什么。

建立基线还有一个容易被忽略的好处：它能让你在团队内部或跟老板沟通时更有说服力。当你拿着“改动前是45%，改动后是55%，提升22%”这样的数据，所有人都能理解你做了什么、为什么有效。而如果你只是说“我觉得改完以后好多了”，那别人只能凭感觉回应。

所以，下次你要做任何一个UX改动之前，先花一点时间记录当前的状态。哪怕只是简单记几个数字，也比没有强。养成这个习惯，你的每一次优化都会变得可衡量、可信赖，而不是靠运气。读完这篇文章，你带走的不只是一个方法，而是一种工作方式：在行动之前先看清自己站在哪里。

In-depth: DuckDB vs SQLite

如果你做数据分析，或者你只是用Excel处理过几万行数据然后电脑卡死过，你就知道“用什么工具来查数据”这个问题有多实际。DuckDB和SQLite是两个经常被拿出来对比的选择。它们都很轻量，不需要装服务器，文件就能跑，但它们的定位其实完全不同。

SQLite你可能更熟悉，它几乎是嵌入式数据库的代名词。手机应用、浏览器、甚至一些物联网设备都在用。它是一个完整的关系型数据库，支持SQL，数据存在一个文件里，读写都很快，尤其适合单用户、低并发、需要持久化存储的场景。比如你写一个记账App，数据存在本地，用SQLite就非常合适。

DuckDB则相对年轻，它专门为分析型查询（analytical queries）设计。什么意思呢？就是那种你要对几百万行数据做聚合、分组、排序、窗口函数这类操作。SQLite在这种场景下会很吃力，因为它是为事务处理（OLTP）优化的，一次处理一行数据很高效，但一次扫描整个表做统计就不太行。而DuckDB是列式存储（columnar storage），并且做了向量化执行（vectorized execution），所以处理大规模分析查询非常快。

举个例子，你有一个包含一年销售数据的CSV文件，有5000万行。你想算每个月的总销售额。用SQLite的话，可能得等几分钟，甚至更久。用DuckDB，同样的查询可能几秒钟就出结果。DuckDB还能直接读CSV、Parquet这些文件格式，不需要先把数据导入数据库，这对数据分析师特别友好。

那什么时候用哪个呢？文章给出了很清晰的判断。如果你的需求是：一个应用需要本地存储用户数据，并发读写不多，数据量在几百万行以内，那么SQLite是稳妥的选择。如果你是在做数据分析、数据科学、或者需要快速探索大量数据，而且查询模式是聚合分析为主，那么DuckDB更合适。另外，DuckDB还支持Python和R的接口，可以跟pandas无缝协作，很多数据科学家已经把它当作“更快版pandas”来用。

不过，它们不是非此即彼的关系。有些场景下，你甚至可以同时用两者：用SQLite做应用的后端存储，然后用DuckDB定期从SQLite导出数据做分析。这样各取所长，系统既稳定又高效。

读完这篇文章，你会明白一个道理：工具没有绝对的好坏，关键看你的使用场景。选错了，再好的工具也会让你头疼。而当你理解了事务处理和分析处理的本质区别，你就能在遇到类似选择时，做出更明智的决定。

What happens after coding is solved? | Fiona Fung (Manager of the Claude Code and Cowork Teams)

想象一下，如果有一天，写代码这件事本身不再值钱。不是程序员失业，而是写代码变得像打字一样简单，任何人用自然语言说一句话，计算机就能生成一个可以运行的软件。那之后，软件行业会变成什么样？这个问题听起来像科幻，但Fiona Fung，也就是Claude Code和Cowork团队的负责人，在Lenny的播客里认真讨论了这件事，因为她的团队正在亲手推动这个变化。Claude Code是Anthropic推出的一款AI编程工具，它不只是补全代码，而是能理解整个项目，自动修改文件、运行测试、甚至部署。

Fiona说，他们团队内部已经习惯了让AI写80%以上的代码，剩下的主要是审查和调整方向。那么问题来了：如果编程能力不再是瓶颈，什么才是真正稀缺的能力？Fiona的答案是：理解问题本身的能力。她举了一个例子：一个产品经理走进来说“我们要做一个用户反馈系统”，如果AI能直接生成一个完整系统，那产品经理必须非常清楚地知道自己到底想要什么，用户真正需要什么，哪些功能是核心，哪些是噪音。过去，程序员在实现过程中会帮产品经理修正需求，因为写代码太贵了，大家不得不精打细算。当代码成本趋近于零，需求定义的质量就变成了唯一的约束条件。这其实在倒逼整个产品团队变得更加严谨。

另一个被AI解放出来的能力是产品发现（product discovery）。Fiona观察到，当团队不再花大量时间写代码，他们可以把更多精力放在观察用户、做实验、验证假设上。以前一个想法从构思到上线可能需要几周，现在可能只需要几个小时。这意味着团队可以更快地试错，更快地学习。但这也带来一个风险：如果团队没有良好的产品判断力，快速试错可能会变成快速制造垃圾。

所以Fiona认为，未来的核心竞争力不是写代码的速度，而是判断“该做什么”和“不该做什么”的能力。她还谈到了一个有趣的现象：当AI能写代码后，工程师的角色会从“建造者”变成“审查者”和“决策者”。你需要快速阅读AI生成的代码，判断它是否合理，是否安全，是否符合架构。这其实需要更深的理解，而不是更浅。就像一个建筑师不再亲手搬砖，但他必须能看懂图纸，知道哪里可能承重有问题。所以Fiona建议工程师现在就应该开始练习“阅读代码”和“思考代码”的能力，而不是只关注“写代码”的技巧。

最后，Fiona提到了一个更长远的影响：当编程的门槛消失，软件行业可能会像出版业一样，每个人都能“出版”软件，但真正能被用户记住的，永远是那些解决了真实问题的产品。而解决真实问题，需要的是对用户的理解、对场景的洞察、以及对商业逻辑的把握。这些东西，AI暂时还学不会。所以，如果你是一个产品经理、设计师或者创业者，现在可能是最好的时代：你不再需要等一个程序员来帮你实现想法，你可以自己动手，用AI快速验证。但前提是，你必须比以往任何时候都更清楚，你在解决谁的问题，以及为什么这个问题值得解决。

How to measure the customer experience as AI scales

当一家公司开始用人工智能处理客户服务，最让人紧张的问题往往不是“AI能不能搞定”，而是“我怎么知道它搞得好不好”。过去，客服团队有很成熟的衡量方式：平均响应时间、首次解决率、客户满意度评分。这些指标背后站着真实的人，人的行为可以被观察、被训练、被复盘。但一旦把一部分对话交给AI，整个衡量体系就开始摇晃。你很难用同样的尺子去量一个机器，因为机器不会累、不会情绪波动，但它也可能用一种非常礼貌的方式把客户气走。

Intercom 这家公司长期做客服工具，他们自己也在产品里大量嵌入AI，所以他们思考这个问题不是从理论出发，而是从真实的产品场景里长出来的。他们发现，当AI开始处理客户对话，传统的满意度调查（CSAT）依然有效，但需要做两件事：第一，把AI和人工的对话分开测量，不能混在一起看平均数；第二，要在AI对话结束后立刻触发调查，因为客户对AI的记忆很短，过几个小时再问，他们可能已经忘了刚才和机器说过话。

更关键的是，他们提出一个概念叫“转人工率”（escalation rate）。如果AI把对话转给真人，这本身不一定是坏事，但转人工的原因很重要。是AI承认自己处理不了，还是客户主动要求转人工？如果是后者，那说明AI的边界没有被客户接受。Intercom 建议团队追踪“非必要转人工”，也就是AI本可以处理但客户仍然要求转人的情况。这个数字如果偏高，说明AI的沟通方式或者能力边界没有对客户透明化，客户对AI缺乏信任。

还有一个有趣的观察：客户对AI的耐心其实比很多人想象的要低，但也很容易被“提前告知”所改善。如果AI在对话一开始就说“我是AI助手，如果需要我可以帮你转接人工”，客户后续的满意度会明显更高。这听起来像是一个小细节，但它揭示了一个更深层的道理：衡量客户体验，不能只看AI能不能解决问题，还要看AI有没有管理好客户的预期。预期管理做得好，即使AI最后没有解决，客户也不会太生气；预期管理做得差，AI即使解决了问题，客户也可能觉得“被敷衍了”。

所以当一家公司说“我们要用AI来提升客户体验”，真正要做的不是替换掉原来的衡量体系，而是重建一套更适合混合服务模式的指标。Intercom 的经验是，保留传统的满意度调查，但增加AI专属的“转人工原因分析”和“预期清晰度评估”。同时，他们提醒团队不要只盯着“AI解决率”这一个数字，因为一个AI如果只挑简单问题回答，解决率可以很高，但它实际上把最复杂、最需要人工介入的问题全部漏掉了，反而让人工团队更累。

读到这篇文章，最值得带走的判断可能不是某个具体指标，而是一种视角的转换：衡量AI时代的客户体验，本质上是衡量人与机器之间的交接是否平滑。客户不会关心背后是AI还是人，他们只关心自己的问题有没有被理解、有没有被认真对待。所以，所有指标最终都应该指向同一个方向，客户有没有感到被尊重。如果AI能做到这一点，即使它偶尔犯错，客户也愿意给它第二次机会。

这篇文章来自 Intercom 的官方博客，他们写这类内容通常不是为了卖工具，而是为了推动整个行业对“AI客服”这件事有更成熟的认知。如果你正在做类似的产品或者负责客服团队，这篇文章能帮你避开很多“只看解决率”的坑。

How tech workers actually feel about AI in 2026 | Annual AI sentiment survey (Noam Segal)

2026年，距离ChatGPT首次引爆公众对生成式AI的热情已经过去了将近三年。这三年里，几乎每个科技公司都在谈AI、投AI、推AI产品。但一个关键问题始终悬而未决：真正在写代码、做设计、定策略的技术工作者，他们到底怎么看待这股浪潮？他们是在兴奋地拥抱，还是默默焦虑，又或者已经疲惫到不再关心？

Noam Segal连续第二年做了大规模调查，直接问科技从业者。结果很有意思，整体情绪从2025年的“谨慎乐观”变成了“务实且分化”。大部分人不再觉得AI会立刻取代他们的工作，但也不再幻想AI能神奇地解决所有问题。他们开始把AI当作一个需要管理的工具，而不是一个需要崇拜或恐惧的神。

一个特别具体的数字很能说明问题：当被问到“你每天使用AI的频率”时，超过一半的人说“每周几次”或更少。这意味着，尽管公司层面铺天盖地地推广，真正把AI嵌入日常工作流的人并没有想象中那么多。很多人试过、觉得有用、但没有形成习惯。这有点像几年前大家对待低代码平台的态度，听起来很美，但真正改变日常工作方式的，永远是那些能无缝融入现有流程的工具。

另一个值得注意的发现是，不同岗位的态度差异比想象中大。工程师相对更务实，他们关心的是代码质量、调试效率、以及AI生成的代码是否有安全隐患。产品经理则更焦虑，因为他们担心AI会让“需求分析”和“用户研究”这些核心技能变得不再稀缺。设计师的处境最微妙，他们既兴奋于AI能快速生成大量素材，又担心自己的工作被简化为“给AI写提示词”。

Segal在报告里还提到了一个转折点：2025年很多公司强制要求员工使用AI工具，结果引发了不小的反弹。到了2026年，管理者学聪明了，开始用“赋能”代替“要求”，用“实验预算”代替“培训考核”。这种管理方式的转变，反而让更多技术工作者愿意主动尝试。

读这份报告最让人踏实的一点是，它没有贩卖焦虑，也没有盲目唱多。它呈现了一个正在快速成熟、但也正在回归理性的行业图景。技术工作者们不再争论“AI会不会取代人类”这种宏大问题，而是开始讨论“这个模型在我的代码库里到底能帮我省多少时间”。这种从口号到实践的转变，可能才是2026年最值得关注的信号。如果你自己也在日常工作里接触AI，你会发现自己并不孤单，大家都是在边用边学，边学边调整预期。

The 5 Qualities of Site-Specific AI Chatbots

想象一下，你打开一个购物网站，想找一件适合户外徒步的防水夹克。你试着在搜索框里输入“防水夹克”，结果出来一堆商务风衣和雨伞。你又试了“徒步防水外套”，这次出现了滑雪服。你开始烦躁，心想这个网站的搜索怎么这么笨。其实不是搜索笨，而是它不知道你在这个网站里到底想要什么。这就是为什么越来越多的网站开始引入AI聊天机器人，而且不是那种通用型的ChatGPT，而是专门为这个网站定制的聊天机器人。

Nielsen Norman Group 最近发布了一篇文章，专门讨论了这类“网站专属AI聊天机器人”应该具备的五个品质。文章没有直接给答案，而是先从用户的实际体验出发。比如，用户来到一个网站，他可能对网站的内容结构完全不了解，但他知道自己想完成什么任务。一个好的网站专属聊天机器人，首先要理解这个网站里到底有什么。它不能像搜索引擎那样去全网找答案，它只能基于这个网站已有的信息来回答。这就要求机器人必须知道网站的产品目录、文章分类、常见问题等等。这听起来简单，但很多网站聊天机器人连这个都做不好，因为它们只是被塞进了一个通用模型，没有经过网站数据的微调。

第二个品质是能够理解上下文。比如用户问“这件衣服有蓝色的吗？”，机器人得知道“这件衣服”指的是用户刚才浏览的那件。如果用户说“我想退货”，机器人要能判断出用户是已经买了东西，还是只是问问退货政策。上下文不仅仅是一次对话内的，还包括用户的历史行为。比如一个用户之前经常看户外装备，那么他问“推荐一款背包”时，机器人应该优先推荐户外背包，而不是商务背包。这需要机器人能够和网站的追踪系统联动，但又不至于侵犯隐私。

第三个品质是能够提供准确的行动指引。很多聊天机器人只会给出文字答案，比如“您可以在订单页面申请退货”。但一个好的机器人应该能直接给出链接，甚至引导用户完成操作。比如用户问“怎么改地址？”，机器人可以回复“在账户设置里的‘配送地址’页面修改，需要我帮你打开吗？”然后直接提供一个按钮。这听起来像是一个小细节，但用户要的就是这种“一步到位”的感觉。

第四个品质是能够处理模糊问题。用户经常不会用精准的术语提问。比如有人问“我想去海边玩，有什么推荐？”，机器人得知道“海边”可能意味着泳装、沙滩鞋、防晒霜，或者旅行攻略。它需要主动追问，比如“您是想找海滩度假的服装，还是旅行目的地推荐？”这种追问能力非常关键，因为它能帮用户理清自己的需求，而不是让用户自己猜。

最后一个品质是能够保持品牌一致性和语气。每个网站都有自己的风格，比如苹果的客服语气简洁专业，而迪士尼的客服语气活泼可爱。如果聊天机器人用冷冰冰的机械语气回复，用户会觉得和网站的整体体验割裂。所以机器人需要被训练成符合品牌调性，甚至能模仿该网站最优秀客服人员的语气。

这五个品质听起来像是常识，但真正能做到的网站并不多。很多网站为了赶AI潮流，随便接一个API就上线了聊天机器人，结果用户问了三个问题就发现它答非所问，反而比没有机器人更糟糕。文章最后提醒，网站专属聊天机器人的核心不是“AI有多强”，而是“它有多懂这个网站”。如果它不懂网站的内容、不懂用户的上下文、不懂怎么引导操作、不懂怎么追问模糊问题、不懂怎么保持品牌一致，那它就是一个昂贵的摆设。

读完这篇文章，你可能会开始留意自己访问的网站里那些聊天机器人。下一次当你遇到一个机器人，能准确理解你的问题，甚至在你还没说完时就猜到了你要什么，你就会知道，那个网站一定在背后下了不少功夫。而那些让你反复说“不是这个”“你再想想”的机器人，很可能只是被随便扔上来的一个半成品。