4 Elements of an Effective Product Strategy

一家创业公司有十个功能想法想在下个季度做，但工程师只够做三个。团队开会讨论，每个人都觉得自己负责的功能最重要。最后老板说，那就都做，每个分配一点资源。结果呢？三个季度过去了，十个功能都只做了一半，用户一个都没用上。这是产品策略（product strategy）要解决的核心问题，不是决定做什么，而是决定不做什么。

Reforge 的文章把有效的产品策略拆成四个要素。第一个叫聚焦（focus）。听起来简单，做起来最难。聚焦意味着你要明确说出“我们在这个阶段只服务这一类用户，只解决这一个痛点”。比如 Airbnb 早期只服务参加大型会议的人，因为这些人有刚需，会议期间的酒店又贵又少。聚焦不是永久的，它只是当下最重要的选择。第二个要素是取舍（trade-offs）。取舍不是“我们既要又要还要”，而是说“为了做好A，我们愿意放弃B和C”。比如一个做在线文档的公司，决定优先让用户能快速打开和编辑，那就意味着暂时不能做复杂的表格、不能做强大的权限管理。

取舍让团队在做决定时不再纠结，因为事先已经说好了什么更重要。第三个要素是时间（time）。好的策略要能回答“我们现在应该做什么，三个月后做什么，一年后做什么”。没有时间维度的策略只是一张愿望清单。比如先做用户注册和基础体验，再做付费功能，最后做企业版。第四个要素是假设（assumptions）。策略本质上是一组关于用户、市场和产品的假设。比如“用户愿意为了省时间付费”“我们的竞争对手不会在半年内做出类似功能”。把这些假设写下来，然后设计实验去验证它们。如果假设错了，策略就要调整。

这四个要素组合在一起，就像一张地图。地图不告诉你每一步怎么走，但它告诉你方向在哪里、哪里是悬崖、哪里是捷径。没有策略的团队就像没有地图的探险队，每天都很忙，但可能一直在原地打转。而有了策略之后，每次做决定时都可以问：这个决定符合我们的聚焦吗？这是我们在取舍中选出来的吗？现在做这件事合适吗？我们的假设还成立吗？如果答案是否定的，那就勇敢地说不。

最终，有效的产品策略不是一份漂亮的文档，而是一套让团队持续做正确选择的习惯。它让每个人都知道什么是最重要的，也因此知道什么可以放一放。读完之后你会明白，真正厉害的产品经理不是点子最多的人，而是拒绝最干脆的人。

A look under the hood—how and why we built Dovetail MCP server

你正在用一款软件整理用户访谈记录，突然想把这些数据接入到人工智能助手（AI assistant）里，让它帮你自动分析。但问题来了：你的数据存在 Dovetail 里，人工智能助手在另一个系统里，它们之间不认识。过去要打通这种连接，你需要写代码、调接口（接口就是两个系统之间约定好的沟通方式）、处理各种技术细节，普通人根本做不了。

Dovetail 是一家做用户研究工具的公司，他们最近做了一个叫 MCP 服务器（Model Context Protocol server）的东西。这个服务器就像一个翻译官，坐在 Dovetail 和人工智能助手中间。你只需要在人工智能助手那里说一句“连接我的 Dovetail 账户”，翻译官就开始工作。它把 Dovetail 里的项目、笔记、标签、视频片段，都整理成人工智能助手能读懂的格式，然后人工智能助手就能直接回答你“最近用户抱怨最多的问题是什么”或者“把上周访谈里提到定价的片段找出来”。整个过程不需要你写一行代码。

为什么 Dovetail 要花力气做这个？因为他们发现用户真正需要的不是另一个独立工具，而是让现有工具之间能互相说话。用户研究数据通常散落在不同地方，访谈录像在 Zoom，笔记在 Notion，分析在 Dovetail。如果这些数据不能流动，人工智能就帮不上忙。MCP 服务器就像是给数据修了一条高速公路，让数据能快速到达需要它的地方。

具体来说，这个翻译官做了三件事。第一，它告诉人工智能助手 Dovetail 里有哪些东西，项目、文件夹、笔记、标签、视频片段。第二，它允许人工智能助手执行搜索，比如“找到所有关于登录流程的访谈片段”。第三，它让人工智能助手能直接读取具体内容，比如打开某个笔记或者播放某段视频。这些操作都通过一个标准协议（MCP）来完成，这个协议就像是不同系统之间通用的语言，只要大家都说这种语言，就能互相理解。

对于普通用户来说，这意味着什么呢？以前你要花半天时间整理资料才能让人工智能帮忙分析，现在只需要一句话。你可以对人工智能说“帮我总结上周五个用户访谈的共性痛点”，它就会自动去 Dovetail 里找到相关记录，读一遍，然后给你一份清晰的报告。这大大降低了使用人工智能的门槛，也让用户研究数据发挥了更大的价值。

读完之后你会感受到，未来软件的发展方向不再是功能越来越多，而是连接越来越顺畅。最好的工具不是功能最强的那个，而是最愿意打开门让数据自由流动的那个。Dovetail 的 MCP 服务器就是这样一个开门的人。

A Content-First Approach to Product Onboarding

想象一下，你刚下载了一个新的记账软件。打开后，屏幕上一个接一个弹出提示：“点击这里添加账户”“去设置里打开分类功能”“试试预算模块”。你手忙脚乱地点掉这些提示，但心里其实完全没搞懂这个软件到底能帮你做什么。这就是很多产品 onboarding（用户引导）的常见问题：它们像一份操作说明书，而不是一个友好的向导。Intercom 的这篇文章提出一个反直觉的思路：与其让用户先学功能，不如先让用户看到内容。

文章讲了一个具体的例子。一个项目管理工具，以前的新用户引导是展示功能列表：你可以建项目、分配任务、设截止日期。但用户进来后常常一脸茫然，不知道从哪儿开始。后来他们换了一种方式：用户注册后，直接看到一份已经填好的示例项目，里面有几个假任务、假负责人和假日期。用户不需要点任何教程，就能直接看到“哦，原来一个项目长这样”“原来任务可以分配给不同的人”。这种用内容代替指令的做法，让用户的理解速度明显加快。

为什么内容比功能列表更有效？文章解释了一个很简单的道理：人不是通过“学习规则”来理解新工具的，而是通过“观察别人怎么做”来理解的。就像你学做一道菜，看一遍别人做好的成品照片，比读一遍菜谱上的步骤更容易想象自己动手的样子。产品里的内容，比如示例数据、预填表单、真实场景的截图，就是那张成品照片。它让用户在动手之前，先在心里形成一个“这个工具用起来会是什么感觉”的画面。

文章还提醒了一个容易忽略的细节：内容要贴近用户的实际场景。如果示例项目里用的是“市场部活动策划”这种内容，而你的用户是程序员，他们可能仍然觉得和自己没关系。好的 onboarding 内容应该让用户觉得“这说的就是我”。比如一个面向设计师的工具，示例里就应该有设计稿、色板、字体；一个面向销售的 CRM（客户关系管理）系统，示例里就应该有客户名单和跟进记录。

读完后你会带走一个很实用的判断：下次设计用户引导时，别急着教用户怎么操作，先给他们看一个“已经用好了”的例子。让内容本身成为最好的老师。

The Benefits Of Cognitive Inclusion In UX Research

你有没有遇到过这种情况：打开一个手机应用，发现按钮太小，点不准；或者一个网站上的文字颜色太浅，读起来很费劲；又或者一个购票流程步骤太多，填到一半就放弃了。这些体验上的“卡壳”，往往不是因为用户笨，而是产品设计时没有考虑到不同人的认知能力。认知能力（cognitive ability）这个词听起来有点学术，其实就是我们每个人处理信息、记住步骤、做出决策的能力。它和视力、听力这些身体能力一样，人与人之间差异很大，而且会随着情绪、疲劳、年龄等因素波动。比如一个刚加完班的程序员，可能和一位轻度认知障碍的老年人在同一时刻的认知资源是差不多的，都剩得不多了。

这篇文章讨论的正是如何把“认知包容性（cognitive inclusion）”引入用户研究（UX research）。用户研究就是产品团队通过观察、访谈、测试等方式，了解真实用户如何使用产品，从而改进设计。传统的研究方法往往默认参与者都是“典型用户”：注意力集中、记忆力好、能清晰表达想法。但现实是，很多用户可能因为焦虑而说不出真实感受，或者因为记不住刚才的操作而无法完成测试任务。文章举了一个例子：一位患有轻度认知障碍的用户在测试一个银行应用时，因为界面上的图标含义不明确，反复点错，最终感到沮丧并放弃了测试。如果研究人员没有意识到这是认知障碍导致的，就可能会错误地认为这个用户“不擅长用手机”，而不是发现设计本身的问题。

那么如何做到认知包容呢？文章给出了一些具体做法。比如在招募测试参与者时，不要只找“方便的人”，通常是年轻、健康、熟悉技术的用户，而要主动邀请不同认知水平的人，包括老年人、有学习障碍的人、或者当时压力大的用户。在测试过程中，要给参与者足够的时间，允许他们暂停或重复操作，而不是催促。研究人员自己也要调整提问方式，避免用“你为什么点错了？”这种带责备意味的问题，而改用“能告诉我你刚才在想什么吗？”来鼓励用户自然表达。文章还提到，分析研究结果时，要区分“用户不会用”和“设计不好用”这两种情况。如果多个不同背景的用户都在同一个步骤上卡住，那几乎可以肯定是设计的问题，而不是个别用户的能力问题。

把认知包容性做好的产品，受益的不仅仅是少数特殊人群。比如一个简化了步骤的购票流程，对所有人来说都更快；一个对比度更高的文字，在阳光下也更容易看清。文章把这种现象叫做“ curb-cut effect”，就像人行道边缘的斜坡，最初是为轮椅使用者设计的，但推婴儿车的父母、拉行李箱的旅客也同样受益。所以，在产品设计早期就引入认知包容的用户研究，不是增加负担，而是让产品对每个人都更友好。读完之后你会明白，好的用户体验不是让用户变得更聪明，而是让设计变得更体贴。

How we redesigned Slack for the iPad

你大概用过Slack，就是那个上班时用来跟同事聊天的软件，里面有各种频道、私信、文件分享。但你有没有想过，在手机或平板上用Slack，跟坐在电脑前用，其实是两种完全不同的体验。屏幕小了，手指代替了鼠标，你不可能像在电脑上那样同时开着好几个面板。这篇文章讲的就是Slack的设计团队怎么重新思考iPad上的Slack，不是简单地把电脑版缩小，而是从零开始想：一个人拿着平板，在沙发上、在会议室、在通勤路上，他到底要用Slack做什么？

设计团队发现了一个核心矛盾：iPad的屏幕比手机大很多，但又不像电脑那样可以同时显示多个窗口。用户经常需要一边看频道里的消息，一边回复另一条私信，或者一边查看文件一边写消息。在电脑上，你可以把窗口拖来拖去；在手机上，你只能来回切换。iPad正好卡在中间，设计团队决定利用这个“中间态”，创造一种新的分屏模式。他们不是简单地把两个面板并排放，而是让主频道占据大部分屏幕，同时让一个浮动的、可以随时拖到旁边的小窗口显示私信或文件。这样，用户不用离开当前频道就能处理其他事情，感觉就像在桌面上多了一个辅助屏幕。

但设计不只是布局问题。团队还注意到，iPad用户经常用Apple Pencil或外接键盘，而有些人纯粹用手指触控。他们必须让同一个界面同时适应这三种输入方式。比如，消息输入框在手指触控时应该更大，方便点按；而用键盘时则可以更紧凑，腾出空间给消息列表。他们甚至重新设计了消息的“长按”菜单，在电脑上你右键点击消息会出现一堆选项，但在平板上，长按之后弹出的菜单必须够大、够清晰，手指才不会误触。

这篇文章最值得看的部分，是他们怎么验证这些想法。设计团队做了很多原型，然后找人到实验室里试用，观察他们怎么拿平板、怎么切换任务、怎么在分屏模式下感到困惑或顺畅。其中一个细节是，他们发现用户经常不小心把浮动窗口滑走，于是增加了轻微的“吸附”效果，让窗口在靠近屏幕边缘时自动固定住。这些调整看起来很小，但正是这些细微之处，决定了你日常使用时是觉得顺手还是恼火。读完你会明白，设计一个“好用的”产品，不是画几张漂亮界面就行，而是要理解一个人在不同的姿势、不同的心情、不同的场景下，到底是怎么跟屏幕打交道的。

The Power of Textual Content in UX Design

一说起用户体验设计，很多人马上想到的是漂亮的颜色、流畅的动画、直观的图标。但有一件东西经常被忽视，那就是文字本身。这篇文章想提醒我们：界面上每一个字，不管是按钮上的标签、错误提示、还是引导文案，都在直接影响用户能不能顺利完成一件事。举个简单的例子：你填一个注册表单，填到一半点“提交”，结果页面弹出一句“错误代码E403”。你肯定懵了，不知道哪里错了，也不知道该怎么办。但如果它写的是“密码需要至少8个字符，且包含一个数字”，你马上就知道怎么改。这就是文字的力量。

文章里提到一个很常见的场景：用户在一个购物网站上准备结账，看到“继续”按钮就点了，结果页面刷新后什么都没发生。用户可能会以为自己已经完成了支付，或者以为网站坏了。实际上，这个按钮可能只是“继续浏览”，而不是“确认购买”。问题出在按钮上的文字没有说清楚它要做什么。设计团队往往花大量时间调整按钮的位置和颜色，却很少仔细推敲按钮上的几个字。但恰恰是那几个字，决定了用户下一步会怎么走。

另一个例子是关于错误提示的。很多网站的错误提示写得像给程序员看的，比如“请求超时，请重试”。用户看到后不知道是网络问题还是自己操作错了，也不知道重试后会不会又失败。更好的写法是：“我们暂时无法保存你的修改，可能是网络连接不稳定。请检查网络后，再试一次。”这样用户就知道原因，也知道该做什么。文章强调，好的文字内容不是事后补上的说明，而是设计的一部分。在画线框图的时候，就应该同时写出每个地方要说什么话，而不是等到开发完了再随便填几个字。

这篇文章还讨论了语气（tone）的重要性。同样是告诉用户操作失败，“糟糕，出错了”和“操作未完成”给人的感觉完全不同。前者更像一个人在跟你说话，后者像机器在报错。产品的语气应该跟品牌一致，但更重要的是，要让用户感到被理解、被帮助，而不是被指责。比如，当用户删除了一个重要文件，不要只说“文件已删除”，而可以加上“如果需要，你可以在30天内从回收站恢复”。这句话不仅告知了结果，还提供了解决方案。

读完这篇文章，你会开始留意平时那些不起眼的界面文字。你会发现，很多让你困惑或烦躁的时刻，其实都源于一句没写清楚的话。而好的文字设计，就像有一个耐心的朋友在旁边轻声提醒你每一步该怎么做。它不会让你觉得自己笨，而是让整个操作变得自然、顺畅。

How to Build and Scale Onboarding

想象你刚下载了一个新应用，注册之后看到的第一个画面是什么？很多产品会直接扔给你一张空白页面，或者一个功能列表，然后说“开始用吧”。但大多数人这时候根本不知道从哪里下手，于是关掉应用，再也没打开。这就是为什么一个叫 Superhuman 的邮件客户端，在硅谷被很多人称为“史上最好用的邮件工具”。它的创始人 Rahul Vohra 曾经花了很多时间研究一个问题：怎么让一个新用户，在第一次打开产品时就觉得“这东西太棒了”，而不是“这什么鬼”。

Superhuman 的团队发现，用户放弃一个产品，往往不是因为功能不够多，而是因为他们在最开始的那几分钟里没有体验到产品的核心价值。比如一个邮件客户端，核心价值是“快速处理邮件”，但如果用户第一次打开时连绑定邮箱都花了五分钟，那这个价值就根本感受不到。所以 Vohra 提出了一套非常具体的 onboarding 方法，也就是“用户引导”方法，不是教用户怎么用所有功能，而是帮用户在最短时间内完成一个“啊哈时刻”，也就是让用户突然觉得“这东西真的有用”的那个瞬间。

这套方法的核心是“只做一件事”。Superhuman 会先分析数据，找到新用户最应该完成的第一个关键动作。对邮件客户端来说，这个动作不是“写一封新邮件”，而是“快速回复一封邮件”。因为回复邮件才是用户每天做最多的事情，也是最能体现效率的地方。所以 Superhuman 的引导流程会直接教用户用快捷键回复第一封邮件，而不是先教他们怎么设置签名或者整理文件夹。一旦用户用快捷键秒回了一封邮件，他们就会立刻感受到“原来可以这么快”，这个体验就是那个“啊哈时刻”。

为了做到这一点，Superhuman 做了很多看似“反直觉”的设计。比如在引导过程中，他们会主动帮用户做一些事情，而不是让用户自己摸索。他们会直接帮用户绑定邮箱、导入联系人，甚至帮用户设置好常用的快捷键。这听起来好像很“重”，但 Vohra 认为，对于一款追求极致效率的产品，用户自己摸索的成本太高了。如果用户花了一个小时才设置好，他们可能早就放弃了。所以 Superhuman 选择在最初几分钟里“替用户做决定”，让用户直接体验到产品的核心快感。

另一个重要的原则是“分阶段引导”。很多产品会一次性把所有功能介绍给用户，结果用户被信息淹没，什么都记不住。Superhuman 的做法是，只在新用户完成当前步骤之后，才展示下一步。比如用户先学会了用快捷键回复邮件，然后系统才会提示“想不想试试用快捷键归档邮件？”每一步都只教一个动作，而且每个动作都直接关联到用户刚刚体验过的价值。这样用户不会觉得在学习，而是在“变得更快”。

Vohra 还特别强调，引导流程不能一成不变。他们会在用户使用产品几个月后，回头分析哪些用户留下来了，哪些用户流失了，然后找出这些留存用户在早期做了哪些不一样的动作。比如他们发现，留存用户通常在头三天内完成了至少五次“快速回复”，而流失用户一次都没有。于是他们就把“完成五次快速回复”设为引导流程中的一个里程碑，并在用户接近这个目标时给予鼓励。

最后，Superhuman 的引导流程还有一个很多人忽略的细节：他们会在用户完成引导后，主动问用户“感觉怎么样？”，然后根据反馈不断调整。因为用户引导不是一锤子买卖，而是一个持续优化的过程。你可能会觉得，一个邮件客户端至于搞这么复杂吗？但 Superhuman 的用户付费意愿非常高，年费高达 30 美元一个月，仍然有很多人愿意掏钱。因为他们从第一次打开产品的那一刻起，就感受到了“这工具能帮我省时间”。而这一切，都始于那精心设计的第一分钟。

A Concrete Definition of “Product Sense” (and How to Build It)

你有没有遇到过这样的同事：他们一看到一个新功能，就能立刻说出“这个功能用户不会喜欢”，或者“这个按钮应该放在这里而不是那里”。你可能会觉得他们“有产品直觉”，好像天生就知道什么设计对用户好。但“产品直觉”这个东西，真的是一种天生的能力吗？Nielsen Norman Group 的一篇文章给出了一个非常具体的定义，并且告诉你，这种能力其实是可以后天练出来的。

文章把“产品直觉”（product sense）拆解成了三个部分：用户同理心（understanding users）、商业敏感度（business acumen）和设计模式识别（pattern recognition）。简单来说，就是你要知道用户在想什么、公司想要什么、以及过去什么样的设计管用过。听起来好像很抽象，但文章用了一个非常具体的场景来解释：假设你正在设计一个网上购物应用，用户想退货。一个有产品直觉的人会怎么思考？

首先，用户同理心意味着你要站在用户的角度想：用户退货时最着急的是什么？是找不到退货入口，还是不知道退货要不要钱，还是担心退款太慢？如果你自己退过货，你就会知道用户最怕的是流程复杂、信息不透明。所以你会把退货入口放在用户最容易找到的地方，比如订单详情页的显眼位置，而不是藏在设置里。

其次，商业敏感度意味着你要考虑公司的利益：退货流程太简单会不会导致用户滥用？比如有人买了衣服穿一次就退，公司会亏钱。所以你可能需要设置一个合理的退货期限，或者要求用户承担部分运费。产品直觉不是一味讨好用户，而是在用户需求和商业目标之间找到平衡。

第三，设计模式识别意味着你要知道其他产品是怎么处理退货的。比如亚马逊的退货流程是什么样？淘宝的退货入口在哪里？这些模式已经被验证过是用户熟悉的，如果你做一个完全不同的设计，用户反而会困惑。所以有产品直觉的人会参考这些成熟模式，而不是从零开始发明。

那么，怎么培养这种能力呢？文章给出了几个非常具体的方法。第一个方法是“每天用产品，并且带着批判的眼光”。不是随便刷刷，而是刻意观察：这个按钮为什么放在这里？这个文案为什么这么说？如果是我，我会怎么改进？你可以选一个你常用的产品，每天花十分钟做这件事，坚持一个月。

第二个方法是“多和用户聊天”。不是做正式的用户调研，而是在日常中观察和倾听。比如你看到朋友在用一个 App 时皱眉头，你就可以问一句“刚才哪里让你觉得不爽？”这种真实的反馈，比任何数据报告都更能帮你理解用户。

第三个方法是“复盘失败的设计”。每个产品经理都有过失败的经历：你设计了一个功能，结果用户根本不买账。这时候不要急着甩锅，而是认真分析为什么失败。是因为你没有理解用户需求？还是因为商业目标冲突？还是因为你没有参考已有的设计模式？把失败当作学习素材，你的产品直觉就会越来越准。

最后，文章提醒说，产品直觉不是一劳永逸的。用户的需求在变，商业环境在变，设计趋势也在变。今天你觉得“这个设计一看就懂”，可能过两年就过时了。所以保持好奇心，持续学习，才是保持产品直觉的真正秘诀。下次你再看到那个“有产品直觉”的同事，你可以问问他们是怎么练出来的，他们很可能也在用这些方法。

Don’t Serve Burnt Pizza: Lessons in Building Minimum Lovable Products

想象你开了一家披萨店，客人点了玛格丽特披萨。你心里想：先做一张最基础的饼皮，涂点番茄酱，烤熟就行。这叫最小可行产品（minimum viable product），意思是先做出能用的东西，再慢慢改进。但你有没有想过，客人拿到这张“能吃的”披萨会是什么反应？他们不会觉得“哇，这家店有潜力”，而是会觉得“这家店连披萨都做不好”。

文章用这个比喻来质问一个很流行的产品观念：是不是只要先做出一个能用但不怎么好的产品，就能在市场上快速学习、快速迭代？作者认为这条路在很多时候走不通，尤其是面向普通用户的产品。因为用户不是你的测试员，他们很忙，没有耐心帮你“完善”一个半成品。你给他们一个不好用的东西，他们转身就走了，不会给你第二次机会。

那应该怎么做？文章提出了一个概念叫最小可爱产品（minimum lovable product）。核心意思是，第一次见面就要让人有点喜欢上你。不必功能齐全，但那个核心体验必须让人觉得“有点意思”“有点用”甚至“有点感动”。比如一个记账软件，第一版可能只能记一笔支出，但它应该让用户在三秒内完成记录，并且界面让人舒服，而不是让用户先注册、填资料、选分类、再点保存。

怎么做到“可爱”？文章讲了一个很具体的做法：在动手写代码之前，先去做用户访谈（user interview）。不是问“你想要什么功能”，而是去观察用户现在怎么解决他们的问题。比如你想做一个帮人找健身伙伴的软件，不要直接问“你想要什么匹配条件”，而是去看那些已经找到健身伙伴的人是怎么认识的，他们为什么能坚持一起练。从这些真实行为里，你才能发现那个“让人喜欢”的切入点。

文章还举了一个例子：一个团队想做家庭理财工具，他们一开始以为用户需要的是复杂的预算分析和投资建议。但访谈后发现，很多家庭最大的痛苦是夫妻之间因为花钱方式吵架。他们需要的不是报表，而是一个能温和地让双方看到彼此消费习惯、减少争吵的工具。于是团队把产品方向从“帮你管钱”改成了“帮你们好好谈钱”。这个改动让产品从“能用”变成了“有温度”，用户愿意主动推荐给朋友。

所以，这篇文章给产品人的提醒是：不要把“最小可行”当作偷懒的借口。第一次亮相的质量，决定了用户愿不愿意给你第二次机会。与其端上一张烤焦的饼，不如花更多时间研究客人到底想吃什么，然后只做那一小块，但做得非常好吃。

Linear’s Path to Product-Market Fit

很多创业公司都死在一个最让人困惑的阶段：做出来的东西有人夸，但没人愿意掏钱，或者有人付了钱但很快就流失了。这个阶段被一个著名投资人马克·安德森（Marc Andreessen）叫做“产品市场匹配”（product-market fit），意思是你的产品刚好满足了一群人的真实需求，让他们离不开你。但到底怎么找到这个匹配点，很少有人能说清楚细节。

一家叫Linear的公司，做的是软件开发团队用的项目管理工具。这个市场已经挤满了巨头，比如Jira、Asana、Trello。按常理，新公司进去就是找死。但Linear不仅活下来了，还在几年内让很多顶级科技团队主动改用他们的产品。他们的创始人分享了一个非常具体的路径，里面没有玄学，全是实打实的动作。

Linear的起点不是先写代码，而是先找到一群“痛得最狠”的人。他们发现，那些做软件开发的工程师，尤其是小团队里的核心成员，对现有工具最大的抱怨是“慢”。Jira这类老牌工具功能多，但打开一个页面要等好几秒，操作起来像在泥里走路。工程师每天要打开几十次，每次几秒的等待累积起来，一天可能浪费十几分钟。看起来不多，但对追求效率的工程师来说，这种摩擦就像鞋里的一粒沙，每走一步都难受。Linear就抓住这个“慢”的痛点，把核心体验做到极致：打开应用几乎瞬间响应，操作流畅得像原生手机应用。

但他们没有一开始就做大而全的产品。他们只做了一个最简功能版本（minimum viable product），只解决“创建任务”和“查看列表”这两个最频繁的操作。然后他们找到那些抱怨“慢”的工程师，让他们试用。注意，这里的关键不是收集一堆“还不错”的评价，而是观察一个指标：用户会不会主动回来。如果用户试用完就忘了，说明痛点不够痛。Linear早期团队盯住的是“日活跃用户除以注册用户”这个比例，如果比例低，他们就回去改产品，而不是去拉更多新用户。

这个过程持续了几个月。他们不断和早期用户沟通，不是问“你想要什么功能”，而是观察用户在实际工作中怎么卡住。比如他们发现，用户创建任务时经常要填很多字段，导致懒得新建，干脆用口头交代。于是Linear把创建任务的流程压缩到一次键盘快捷键加几个字，让用户能在三秒内完成。这种对细节的执着，让早期用户逐渐从“试试看”变成“离不开”。

当这批核心用户开始自发向同事推荐，当用户流失率降到接近零，Linear才认为产品市场匹配初步达成。然后他们才开始做付费和规模化。这个顺序很重要：先让一小群人爱到骨子里，再考虑赚钱和扩大。很多创业公司反过来，先做很多功能想覆盖所有人，结果谁都不满意。

读完Linear的故事，你带走的判断可能是：产品市场匹配不是靠运气撞出来的，而是靠极度聚焦于一个具体痛点，用极致的体验让一小群人产生依赖，然后才慢慢扩展。这个过程需要耐心，也需要敢于拒绝大多数人的需求，只服务好那批“最痛的人”。

Why You Need a Data-Informed Product Strategy

假设你是一家做线上课程的公司，每天有几千人访问你的网站。你的团队想了很多主意：有人说要增加短视频功能，有人说要搞积分兑换，还有人说应该把课程打包成会员订阅。每个主意听起来都有道理，但资源有限，不可能全都做。你怎么决定先做哪个？

这就是产品策略要回答的问题。产品策略不是列出一堆要做的事，而是先搞清楚你的用户到底在为什么事发愁，然后选择一条最能解决这个问题的路。文章里提到一个例子：有一家音乐流媒体公司，他们的用户留存率（也就是用过一次之后还愿意继续用的人）一直上不去。团队一开始觉得是歌不够多，于是拼命买版权。但后来他们仔细看了用户行为数据，发现大部分用户根本不是来听冷门歌的，而是想在通勤路上随便放点什么。他们真正需要的不是歌多，而是能快速找到一首“听起来不错”的歌。于是团队把力气花在了做个性化推荐上，留存率很快就涨了。

从这个例子能看出，数据不是用来证明某个主意是对的，而是用来帮你看见用户实际在做什么、卡在哪里。很多团队容易犯一个错误：先拍脑袋想出一个方案，然后去找数据支持自己。正确做法是反过来，先看数据里有没有什么反常的现象，比如某个按钮点击率特别低，或者某个功能用了一次就再也没人碰。这些反常点往往就是用户真正的问题。

文章还强调，产品策略不是一成不变的。你定了一个方向，比如“帮用户更快找到想听的歌”，然后做了一版推荐功能。上线之后要继续看数据：用户听了推荐后有没有多听几首？有没有更频繁地打开应用？如果数据没变好，说明你的策略可能猜错了，需要调整。这个过程叫“假设驱动”，就是你先提出一个假设，“如果给用户更精准的推荐，他们就会多听”，然后用产品去验证它，再根据结果决定下一步。

对于没有产品背景的读者来说，可以这样理解：产品策略就像你开一家餐厅。你不能同时做川菜、粤菜、西餐和甜品，因为厨房只有那么大。你得先决定你的客人是谁，是附近上班的白领，还是周末带孩子的家庭，然后根据他们的口味决定菜单。数据就是你看他们点菜的记录：哪道菜剩得最多，哪道菜每次都被吃光。你根据这些信息调整菜单，而不是凭感觉换菜。

最终，好的产品策略会让整个团队知道：我们为什么做这个，不做那个。每个人做决定时都有同一个标尺，不会各做各的。文章里把这叫做“对齐”，意思是大家方向一致，力气往一处使。如果你在的公司里，产品经理、设计师、工程师常常争论先做哪个功能，那很可能就是缺了一个清晰的产品策略。

The day Customer Success stopped putting out fires and started building customer trust with Dovetail

想象你是一家软件公司的客服主管，每天一上班就被各种消息轰炸：某大客户说系统崩了，另一个客户抱怨某个功能没法用，还有客户威胁说再不出新功能就要换供应商。你的团队像救火队一样，从早到晚忙着处理这些突发问题。虽然问题都解决了，但客户还是不满意，总觉得你们反应慢、不靠谱。

这篇文章讲的就是一家叫Dovetail的公司如何帮客户成功团队（Customer Success，也就是专门负责让客户用得开心、愿意续费的那个部门）摆脱这种被动救火的局面。Dovetail本身是一个用户研究平台，简单说就是帮企业整理和分析用户反馈、访谈记录的地方。但文章的重点不是介绍Dovetail的产品，而是讲一个真实的故事：一家公司用了Dovetail之后，客户成功团队的工作方式发生了怎样的变化。

故事的主角是一家做B2B软件的公司，他们的客户成功团队原来也是每天忙着处理工单。每个客户遇到问题就发邮件或打电话，团队就赶紧去修。看起来很忙，但问题反复出现，团队也说不清哪些问题最普遍、哪些客户最危险。后来他们开始用Dovetail把所有客户反馈集中到一个地方，并且给每条反馈打上标签，比如“登录失败”“账单错误”“想要A功能”。积累了一段时间后，他们发现一个规律：70%的投诉其实都集中在同一个功能模块上。于是团队不是再一个个去修，而是直接去找产品经理，要求重做那个模块。模块改好后，相关投诉骤降，客户满意度明显提升。

这个故事的关键转折点在于：团队从“每个问题单独处理”变成了“先看整体模式”。以前他们只看见一棵棵着火的树，现在他们看见了整片森林的火势分布。这种转变需要两个条件：一是把分散的信息收集起来，二是用工具（比如Dovetail）把信息变成可以分析的标签和趋势。

对于没有背景的读者来说，可以这样想象：你开了一家旅馆，每天都有客人抱怨房间太吵。以前你只能一个个去道歉、换房间。但如果你把所有抱怨记录下来，发现80%的噪音都来自三楼靠近电梯的房间，你就会直接去给那几间房加隔音，而不是继续一个个道歉。这就是从“救火”到“防火”的转变。

文章最后想说的是，客户成功团队的价值不应该体现在处理了多少投诉，而应该体现在帮公司减少了多少投诉。当团队能主动发现并解决根本问题时，客户会觉得你懂他们、在乎他们，续费也就水到渠成了。而Dovetail这类工具，本质上就是帮团队从“听不见”变成“听得清”，从“忙乱”变成“有方向”。

Improve Your User Onboarding with Jobs-to-be-Done Insights

想象你刚下载了一个新的记账应用，想试试看。你打开它，看到几个输入框，要填收入、支出、分类。你填了两笔，觉得有点麻烦，就关掉了。第二天你打开另一个应用，发现它直接连上你的银行卡，自动把消费记录分好类。你什么都没做，就看到了上个月的支出饼图。为什么一个应用你只用一次就放弃，另一个却愿意留下来？

Intercom 这篇关于用户引导（onboarding，指新用户第一次使用产品时学会核心功能的阶段）的文章，借用了“待办任务”（Jobs-to-be-Done，JTBD，指用户雇用产品来完成某个具体的生活任务）理论里的一个框架：四力模型。这个模型说，用户决定用还是不用一个产品，是由四种力量拉扯的结果。第一种叫“推力”，是当前处境里的不满，比如手动记账太麻烦，你烦了。第二种叫“拉力”，是新产品的吸引力，比如自动记账看起来真方便。但还有两种力量在阻止你行动：一种是“对旧方式的惯性”，你已经习惯了不管账，改变需要额外精力；另一种是“对新产品的焦虑”，你担心它不安全、学不会、或者坚持不下来。

很多产品在用户引导时只拼命放大“拉力”，做漂亮的引导页、炫酷的动画、热情的欢迎消息。但文章指出，真正让用户放弃的往往是“对旧方式的惯性”和“对新产品的焦虑”。比如一个项目管理工具，新用户注册后看到一长串教程，心里想的是“我现在用 Excel 虽然乱，但至少知道怎么用，这个新工具学起来太费时间了”。用户不是不想变好，而是改变的成本太高。

文章举了一个经典例子：Dropbox 早期让用户上传文件才能开始用，结果很多人注册后就走了。后来他们改成“先给你一个文件夹，你放文件进去，它就自动同步”。用户不用先做任何学习，只要像平时一样拖拽文件，就能立刻看到同步的效果。这个改动降低了“对新产品的焦虑”，你不需要先承诺“我要学会一个复杂系统”，你只需要做一个你已经会做的动作。

所以文章给的建议很具体：在用户引导里，不要只告诉用户产品多好，要主动移除那些让人犹豫的力量。比如，给一个极简的“快速胜利”，让用户在 30 秒内完成一个能带来价值的小动作。再比如，提前展示老用户的使用成果，减少“对旧方式的惯性”，让用户觉得“别人都换了，我也该换了”。

如果你正在设计一个产品的首次体验，或者只是好奇为什么自己总在下载后不久就删掉应用，这篇文章能帮你理解那些看不见的阻力。读完后你会明白，好的用户引导不是教用户怎么用，而是帮用户轻松跨过从“想试试”到“正在用”的那道坎。

Evolving the User Experience to Curb Digital Addiction

你有没有过这样的经历：打开手机只是想回一条消息，结果半小时后发现自己正刷着短视频，完全忘了最初要做什么。这不是你的意志力出了问题，而是手机里那些应用的设计师，从第一天起就在想办法让你多待一会儿。他们利用人的心理弱点，比如不确定的奖励（下拉刷新后不知道会看到什么）、社交压力（红点提醒）、自动播放下一集，把使用时间拉得越来越长。这种行为在行业里有个名字叫数字成瘾（digital addiction），它并不是医学上的成瘾，而是指一种难以自控的、过度使用数字产品的状态。

这篇文章讨论的是，设计师能不能反过来，用同样的设计技巧帮助用户减少使用，而不是增加使用。作者认为，过去十多年，用户体验（user experience）设计几乎完全站在商业一边：公司想要用户多停留、多点击、多消费，设计师就做各种让用户停不下来的功能。但现在，越来越多的用户开始反感这种被操控的感觉，一些公司也开始尝试另一种方向，叫做对抗式设计（antagonistic design）。对抗式设计不是让用户觉得难用，而是主动帮助用户意识到自己在做什么，并给出更容易离开的选择。比如，有的应用会在你连续刷了很长时间后弹出一句温和的提醒：“你已经看了很久，要不要休息一下？”这种提醒不是为了让你生气，而是让你有机会从无意识的滑动中醒过来。

文章里举了几个具体的做法。比如，把默认设置从“自动播放”改成“需要手动点击才播放下一集”，这个小小的改动就能让人在每集之间多一个停顿，从而更容易决定停下来。再比如，把社交媒体的信息流从无限滚动（infinite scroll，一直往下滑永远有新内容）改成有明确终点的分页（pagination，翻到最后一页就没了），这样用户就不会觉得“再看一条”是永远没有尽头的。还有一个例子是，有的应用会显示你这次使用的时间，并且用温和的语言而不是指责的语气告诉你这个时长意味着什么。这些做法背后有一个共同逻辑：把控制权交还给用户，而不是让系统替用户做决定。

当然，这样做对公司来说是有风险的。因为用户使用时间变短，广告收入可能会下降，用户参与度（engagement，用户和产品互动的频率和深度）的指标也会变差。但作者指出，从长远看，信任用户、尊重用户的产品更容易留住用户。如果用户觉得某个应用总是在算计自己，他们迟早会关掉通知、卸载应用，或者干脆换一个更“干净”的产品。所以，对抗式设计不是反商业的，而是一种更可持续的商业策略。它承认用户有自主权，并且愿意用设计来支持这种自主权。

读完这篇文章，你可能会重新审视自己常用的那些应用。下次当你被一个红点吸引点进去，或者不知不觉刷了很久时，不妨想一想：这个设计是在帮你，还是在利用你？而如果你自己也在做产品，或者有朋友在做产品，可以问问他们：愿不愿意把“让用户更容易离开”也当成一个设计目标？这不是一个非黑即白的选择，而是一种值得尝试的平衡。毕竟，好的用户体验不只是让用户用起来顺畅，也包括让用户用完后感觉良好，而不是被掏空。

The myth of the lightbulb moment: How to actually come up with ideas

很多人以为好点子来自灵光一现。比如你在洗澡的时候突然大叫一声“有了”，然后一个完美的产品创意就从天而降。但真正做过产品的人会告诉你，这种事情几乎从不发生。Slack 的设计团队写了一篇文章，专门拆穿这个“灵光一现”的神话，并且给出了他们实际用来产生想法的方法。

文章一开始就点出一个让人不舒服的事实：如果你只是坐在那里等灵感，你大概率什么都等不到。那些看起来像是突然冒出来的想法，其实都是长期浸泡在问题里、反复琢磨之后的结果。Slack 的设计师们发现，真正有用的想法不是靠“想”出来的，而是靠“做”出来的。他们会在白板上画满草图，会把一个简单的功能改几十个版本，会拿给同事看然后被骂“这什么鬼东西”，然后再改。这个过程一点都不浪漫，甚至有点狼狈。

那他们具体怎么做呢？一个关键方法是“约束自己”。听起来反直觉对吧？通常我们认为创意需要自由，但 Slack 团队发现，当限制变多的时候，想法反而更容易冒出来。比如他们给自己定一个规则：这个页面只能放三个按钮，不能再多了。或者这个提示必须在 10 个字以内。这种限制逼着你去想“怎么用最少的资源解决最大的问题”，而不是漫无边际地乱想。另一个方法是“从终点倒推”。他们会先想象一个完美的用户场景：某个人打开 Slack，看到了什么，做了什么，然后感觉很爽。接着他们再往回推，思考要到达那个场景，中间需要哪些步骤。这种倒推法比从“我们有什么技术”开始想要有效得多。

文章还讲了一个重要的心态转变：不要追求“原创”，要追求“有用”。很多新手设计师或者产品经理会陷入一种焦虑，觉得自己的点子不够新，别人已经做过了。但 Slack 的设计师说，大部分好想法其实都是把已有的东西重新组合，或者在一个新的场景里应用老办法。比如 Slack 里的消息回复功能，其实就是把论坛里的“引用回复”搬到了即时通讯里，但放在那个场景里就变得非常自然。所以与其纠结“这个点子是不是独一无二”，不如问“这个点子能不能帮用户解决一个具体问题”。

读完这篇文章，你会带走一个很踏实的信念：创意不是天才的专利，而是一套可以练习的技能。你不需要等闪电劈中你，你只需要开始动手，给自己设一些限制，从终点往回推，然后不断试错。下次当你卡在“想不出好点子”的时候，也许可以试试先画一张丑到不行的草图，然后问自己：如果只能改三次，我会改哪里？

Mental Models

你有没有遇到过这样的情况：一个网站或者 App 的界面看起来挺漂亮，但你点来点去就是找不到想要的功能，最后气得直接关掉了。问题很可能出在一个看不见的东西上，它和你的“心理模型”（mental model）不匹配。

Nielsen Norman Group 的这篇文章专门讲什么是心理模型，以及它为什么对设计如此重要。简单来说，心理模型就是每个人脑子里对某个东西“应该怎么运作”的预期。比如你第一次用一台新微波炉，你会下意识地觉得“转盘调时间，按钮启动”，因为大多数微波炉都这样。如果你碰到一台微波炉，它的启动键藏在背面，你一定会觉得它反人类。这就是心理模型在起作用：你的大脑根据过去的经验，提前画好了一张地图，如果现实和地图对不上，你就会感到困惑甚至恼怒。

文章里举了一个很经典的例子：很多人认为电脑里的“文件夹”就是一个真实的黄色纸文件夹，里面装着文件。所以当你把文件拖进文件夹，你预期它“消失”在里面。但如果这个文件夹其实是一个快捷方式，文件并没有真的被移进去，用户就会觉得“文件丢了”。设计师如果了解用户的这个心理模型，就不会把快捷方式设计成看起来像真实文件夹的样子，或者至少会加一个明显的提示。

对于产品经理和设计师来说，关键任务不是去“教育”用户，而是去“匹配”用户已有的心理模型。除非你在做一个全新品类的东西，否则强行改变用户的习惯会非常困难。比如微信的“摇一摇”功能，它利用了人们摇手机这个自然动作，匹配了“摇动带来随机结果”的心理模型，所以大家一学就会。反过来，如果一个 App 把“删除”操作藏在长按菜单里，而用户习惯的是滑动删除，那用户就会觉得这个 App 很难用。

文章还提醒我们，心理模型是会变的。十年前人们觉得“发短信要按键盘”，现在大家觉得“说话就能发消息”。所以设计师需要不断观察用户现在的习惯是什么，而不是假设自己知道。一个简单的方法就是做可用性测试（usability testing）：找几个真实用户，让他们用你的产品，然后看他们在哪里卡住。卡住的地方，往往就是你的设计和他们心理模型冲突的地方。

读完这篇文章，你会明白一件事：好的设计不是让用户觉得“哇好酷”，而是让用户觉得“嗯，就该是这样”。当用户不需要思考就能操作的时候，说明你的设计正好长在了他们的心理模型上。这种“隐形”的设计，才是真正高级的设计。

Startup = Growth

如果一个创业者跑来告诉你，他做了一家很棒的公司，你会先问什么？很多人会问“你们做什么产品”，或者“怎么赚钱”。但保罗·格雷厄姆（Paul Graham），硅谷最著名的创业孵化器 Y Combinator 的创始人，会先问另一个问题：“你们增长得有多快？”

这篇文章的核心观点非常直接：一家真正的创业公司，本质上就是一个被设计成能快速增长的生意。这不是说所有小公司都叫创业公司。街角新开的面包店、你朋友开的设计工作室，它们可能很赚钱、很稳定，但格雷厄姆认为它们不是“创业公司”，因为它们的增长方式不一样。面包店要扩张，需要开新店、雇更多面包师，每多一家店收入就多一份，但这是线性增长。而创业公司追求的是指数级增长，用户数量或收入能翻倍、再翻倍，而且这种翻倍不是靠单纯堆人力和店面，而是靠产品本身能大规模复制，比如一个软件服务，新增一个用户的成本几乎为零。

那么问题来了：什么样的生意才能实现这种快速增长？格雷厄姆给出的答案很直接，你必须做一个“大市场”里的产品。如果你的目标用户只有几千人，那就算所有人都买了，增长也很快会碰到天花板。真正能实现指数级增长的公司，往往是在一个足够大的市场里，找到了一群有强烈共同需求的人，然后用一个产品去满足他们。Facebook 最早只服务哈佛学生，但那个市场是“所有大学生”，足够大；Airbnb 最早服务的是参加大型会议订不到酒店的人，市场是“所有旅行者”。

但光有市场还不够。格雷厄姆特别强调了一个反常识的点：创业公司早期的增长，往往来自“不完美”的产品。很多外行以为，要快速增长，产品必须完美无缺。但实际恰好相反。一家创业公司早期最重要的任务不是把产品打磨到无可挑剔，而是快速发布一个“足够好”的版本，然后观察用户是否真的在用、是否愿意推荐给别人。如果用户用了之后不回来，那就说明产品没有解决他们真正在乎的问题，这时候再继续打磨细节也没用。格雷厄姆把这种早期用户的行为叫做“口口相传”（word of mouth），如果产品真的好到让用户主动告诉朋友，增长就会自然发生。

最后，格雷厄姆给出了一个非常实用的判断标准：如果你在创业，你应该能用一个简单的数字来衡量你的增长。比如每周活跃用户增长多少百分比。如果你连这个数字都说不出来，或者你不敢面对这个数字，那很可能你的公司还没有找到真正的增长引擎。这篇文章写于2005年，但到今天，几乎所有成功的科技公司，从 Uber 到 Stripe 到 Notion，都遵循了同样的逻辑：先找到一个足够大的市场，用不完美的产品快速验证，然后盯着一个增长数字不断迭代。读完这篇文章，你带走的不只是一个定义，而是一面镜子：你可以用它来照一照任何一个你听说过的“创业公司”，看看它到底是在真的增长，还是只是一个普通的小生意。

Binti’s Path to Product-Market Fit: Lessons in Immersive User Research

想象一下，你是一家刚起步的软件公司的创始人，你的产品是帮助美国的寄养机构（foster care agencies）管理收养流程的。你的用户不是普通的消费者，而是每天要处理大量纸质表格、被政府规定压得喘不过气来的社工。你坐在旧金山的办公室里，喝着精品咖啡，对着电脑屏幕设计功能。你觉得自己的产品逻辑很清晰，界面也很漂亮。但你的用户根本不买账。他们要么不回复你的邮件，要么试用几天就放弃了。问题出在哪里？

这篇文章讲的就是一家叫 Binti 的公司如何走出这个困境。Binti 做的是一款帮助寄养机构管理收养申请的软件。听起来很垂直、很窄，但创始人 Felicity Curvelo 发现了一个巨大的痛点：美国很多州的收养流程还停留在传真和纸质表格时代。一个家庭要收养孩子，可能要填几十页表格，社工要手动核对信息，整个过程慢得让人崩溃。Curvelo 和她的团队一开始犯了一个很典型的错误：他们按照自己对“好软件”的理解去设计产品，比如简洁的界面、自动化的流程。但他们没有意识到，对于社工来说，最大的障碍不是界面好不好看，而是他们根本不敢用新软件，因为一旦出错，可能会影响一个孩子的安置，后果很严重。

Binti 的转折点来自于一种被称为“沉浸式用户研究”（immersive user research）的方法。简单说，就是创始人不再坐在办公室里猜测用户想要什么，而是直接跑到用户的工作环境里去，亲眼看着他们工作。Curvelo 和团队成员去了好几家寄养机构，坐在社工旁边，看他们怎么接电话、怎么填表、怎么在多个系统之间来回切换。她们发现了一个之前完全没注意到的问题：社工在审核收养申请时，经常需要在不同纸张和屏幕之间来回核对信息，而她们设计的软件把信息藏在了深层菜单里，社工找不到。更关键的是，社工们普遍对新技术有恐惧感，害怕系统崩溃导致数据丢失。

于是 Binti 做了一个非常反直觉的决定：她们没有去开发更高级的功能，而是先确保产品在“最笨”的情况下也能用。比如，她们允许社工把整个申请表格打印出来，用手写填完再扫描上传，这听起来一点也不“高科技”，但恰恰解决了社工的信任问题。她们还专门设计了一个“安全网”功能：每次社工保存信息时，系统都会自动备份，并明确显示“已保存”的提示。这些改动看似简单，但每一个都来自对用户实际工作场景的观察。

这篇文章最有价值的部分，不是告诉你“要做用户研究”这个道理，而是展示了具体怎么做。比如，Binti 团队在观察社工时，会记录下每一个让用户停顿、皱眉、叹气的小动作。这些细节往往比用户直接说出来的需求更真实。用户可能会告诉你“我想要一个更快的系统”，但如果你观察她，你会发现她其实在同时打开五个窗口，因为系统之间不互通，她真正需要的不是速度，而是不用来回切换。

最终，Binti 找到了产品与市场的匹配（product-market fit）。这个听起来很学术的词，在 Binti 的故事里变成了一个很具体的信号：社工们开始主动给 Binti 团队发邮件，说“你们的产品让我每天省下了两个小时，我可以早点回家陪孩子了。”当用户因为产品而发自内心地感激你，而不是仅仅“觉得还行”，你就知道自己走对了路。这篇文章给所有做产品的人一个很朴素的提醒：不要假设自己理解用户，除非你亲眼看过他们怎么工作。那些让你觉得“不优雅”的解决方案，往往才是用户真正需要的。

Product Strategy Is Really About Offense vs. Defense

你有没有遇到过这种情况：团队每天都在加班，功能一个接一个上线，但用户好像没什么感觉，竞争对手却越来越强。问题可能出在，你们做的所有事情都是在“防守”，而不是在“进攻”。

Reforge 的这篇文章提出了一个非常直观的框架：产品策略（product strategy）本质上就是回答一个问题，你现在是在进攻还是防守？进攻的意思是，你在做那些能让你赢得新用户、打开新市场、建立独特优势的事情。防守的意思是，你在做那些防止用户流失、保持现有收入、不被竞争对手超越的事情。两者都重要，但绝大多数团队把大部分精力花在了防守上，却以为自己是在进攻。

举个例子。如果你的产品是一款在线文档工具，进攻策略可能是做一个 AI 助手，让用户写文档的速度快十倍，这个功能会让那些还在用传统文档工具的人觉得“我得试试这个”。防守策略可能是修复一个 bug，让文档保存不再偶尔失败，这个功能不会吸引新用户，但能阻止现有用户因为崩溃而离开。问题在于，防守型工作通常更紧急、更明确、更容易被老板和工程师理解。“这个 bug 影响了 500 个付费用户，必须立刻修”，这种话没人能反驳。而进攻型工作往往是模糊的、有风险的、需要长期投入的。“我们做一个 AI 助手，但不确定用户是否真的会用”，这种话很难在周会上获得支持。

文章的核心洞察是，大多数产品团队在无意识中变成了防守型团队。他们用“用户反馈”和“数据驱动”来证明防守工作的合理性，因为防守工作的效果是可以衡量的，修复一个 bug 后，崩溃率下降了多少，很清晰。但进攻工作的效果很难短期衡量，一个新功能上线后，用户需要时间适应，市场需要时间反应，数据可能一开始是平的。于是团队越来越倾向于做那些能立刻看到数据改善的事情，而这些东西往往是防守型的。

那怎么判断自己是在进攻还是防守？文章给出了一个很实用的测试：问自己一个问题，“如果这个功能做成了，竞争对手会感到害怕吗？”如果答案是“不会”，那你大概率是在防守。防守工作做得好，竞争对手不会害怕，他们只会觉得“哦，他们终于把那个 bug 修了”。进攻工作做得好，竞争对手会感到压力，因为他们知道你在抢他们的用户，或者你在定义一个新的游戏规则。

另一个判断方式是看你的产品路线图（product roadmap，即未来一段时间的功能计划）。如果路线图上大部分是“优化”“改进”“修复”“提升性能”这类词，那基本就是防守路线图。进攻路线图上应该出现“全新体验”“新市场”“新用户群体”“颠覆性功能”这类词。当然，这并不意味着防守不重要。没有防守，产品会崩溃，用户会流失，公司会死。但问题在于，大多数团队的防守太多了，进攻太少了。

文章建议，你应该有意识地把产品策略分成两个篮子：进攻篮子和防守篮子。每个季度，明确地分配资源。比如 70% 的资源给防守，30% 给进攻。或者 50% 对 50%，取决于你的市场位置。关键是你要有意识地做这个分配，而不是让紧急的事情自动决定一切。并且，进攻工作应该由最资深的产品经理和工程师来做，因为这些工作更难、风险更大、回报也更大。防守工作可以交给更 junior 的成员，或者用更标准化的流程来处理。

读完之后你会意识到，很多公司之所以增长停滞，并不是因为他们不够努力，而是因为他们把所有努力都放在了“不让用户离开”上，却忘了“让新用户进来”。进攻和防守不是二选一，但你必须知道你现在在做什么，以及为什么这么做。

Product Strategy Overview

说到产品策略（product strategy），很多人第一反应是“画一张很漂亮的图，写上几个大方向，然后告诉团队照着做”。但 Silicon Valley Product Group 的这篇文章告诉你，产品策略不是一张图，而是一套决策逻辑。它回答的是“我们为什么认为这样做能赢”这个问题。

文章一开始就点出了一个很常见的困境：很多产品团队有大量的用户反馈、数据报表、竞争对手分析，但他们不知道该信谁。用户说 A，数据说 B，老板说 C，工程师说 D。产品策略的作用就是告诉你，当这些信息冲突的时候，你应该优先听谁的。换句话说，产品策略是你的“筛选器”，帮你决定做什么和不做什么。

那一个好的产品策略长什么样？文章给出了几个关键要素。首先，它必须基于一个清晰的“产品愿景（product vision，即产品在未来三到五年想成为的样子）”。愿景是终点，策略是路线图。没有愿景，策略就没有方向；没有策略，愿景就只是一个口号。比如你的愿景是“让每个人都能用 AI 写作文档”，那你的策略可能就是“先服务好重度写作者，再扩展到普通用户”。

其次，产品策略必须包含一个“目标用户群体（target customer segment，即你打算先服务哪一群人）”。很多产品失败的原因是他们想服务所有人，结果谁都没服务好。好的策略会明确说，“我们先不做企业级客户，先做个人创作者”。这个选择会决定你接下来所有的功能优先级、定价模式、市场渠道。

第三，产品策略要定义“核心价值主张（core value proposition，即用户为什么要用你而不是别人）”。这个价值主张必须非常具体。不是“更好用的文档工具”，而是“让写作者在十分钟内完成一篇初稿”。越具体，团队越容易判断一个功能是否在支持这个价值主张。

第四，产品策略要说明“如何实现可持续的竞争优势（sustainable competitive advantage，即为什么别人抄不走）”。这个可能是网络效应（network effect，用户越多产品越好用）、数据飞轮（data flywheel，使用越多数据越多、产品越智能）、或者独特的技术能力。如果别人花三个月就能复制你的功能，那你的策略就不够好。

文章还特别强调了产品策略和产品路线图（product roadmap，即功能计划）的区别。很多人把路线图当成策略，但路线图只是策略的执行计划。策略是“为什么”，路线图是“做什么”。一个好的策略可以支撑多个不同的路线图。如果市场变了，你可以调整路线图，但策略的核心不变。

最后，文章给出了一个很实用的建议：把你的产品策略写在一页纸上，然后拿去给一个完全不了解你产品的人看。如果他看完能说出“所以你们打算先服务谁，用什么独特的方式，为什么别人很难复制”，那你的策略就是清晰的。如果他看完只说“哦，你们打算做一个更好的产品”，那你的策略还需要打磨。

读完之后你会明白，产品策略不是一份文档，而是一种思考习惯。它让你在每天无数个“要不要做这个功能”的决策中，有一个始终一致的判断标准。没有这个标准，团队就会变成一盘散沙，每个人都在做自己认为对的事情，但方向完全不同。

Set “Non-Goals” and Build a Product Strategy Stack

想象你是一个新上任的产品负责人，手里拿着一份长长的待办清单，团队每天都很忙，但半年过去，你发现最重要的几个产品改进一个都没做成。问题出在哪？可能不是你不够努力，而是你从来没有认真说过“我们不做什么”。

这篇文章来自 First Round Review，讲的是一个叫“非目标”（non-goals）的概念。它听起来很简单，就是明确列出团队这几个月不打算做的事。但做起来很难，因为说“不”比说“是”更需要勇气。比如，你的产品是一款在线协作工具，用户一直要求增加聊天功能。团队里很多人也觉得该做，因为竞争对手有。但如果你这季度的目标是“提升文件共享速度”，那增加聊天功能就是一个非目标。你必须明确告诉团队：这三个月，我们不碰聊天。

文章提出了一个“产品策略堆栈”（Product Strategy Stack）的框架，帮助产品负责人把抽象的目标变成可执行的选择。这个堆栈分几层：最顶层是公司的使命（mission），比如“让每个人都能高效协作”；往下是产品愿景（vision），比如“成为团队文件协作的第一平台”；再往下是战略（strategy），也就是你选择做什么和不做什么；然后是年度目标（annual goals）；最后是季度目标（quarterly goals）和具体任务（tasks）。每一层都要对齐，而且每一层都要包含非目标。

为什么非目标这么重要？因为资源有限。一个团队如果什么都想做，最后什么都做不好。文章举了一个例子：一家公司决定专注于“提升现有用户的参与度”，而不是“获取新用户”。于是他们把“开发新用户引导流程”列为非目标。这个决定让团队能集中精力优化老用户的使用体验，比如改进搜索功能、加快加载速度。结果老用户的活跃度提升了30%，而新用户增长虽然暂时放缓，但老用户的口碑带来了更高质量的新用户。

文章还强调，非目标不是永远不做，而是当前不做。比如下个季度，你的非目标可能变成“不优化搜索”，因为重点变成了获取新用户。定期回顾和调整非目标，和定期回顾目标一样重要。

读完后你会带走一个判断：好的产品策略不是列一堆要做的事，而是勇敢地列一堆不打算做的事。非目标让团队少走弯路，也让每个人清楚什么才是真正重要的。

Practices for Building Linear

你有没有用过一款软件，觉得它特别顺手、反应快、界面干净，几乎不会出奇怪的 bug？比如你写代码时用的编辑器，或者记笔记的工具。这种“用起来舒服”的感觉不是偶然的，背后往往有一整套做事的方法。这篇 Linear 公司写的文章，讲的就是他们怎么做出这样一款产品。Linear 本身是一款给工程师团队用的项目管理工具，帮他们追踪任务、安排迭代。但文章的重点不是介绍这个工具怎么用，而是分享他们团队内部坚持的一些原则和习惯。这些习惯听起来可能有点“偏执”，但正是它们让产品保持高质量。

比如，他们非常在意“一次只做一件事”。听起来很简单，对吧？但实际工作中，我们很容易同时开好几个任务，这边回个消息，那边改个 bug，再构思一个新功能。Linear 团队认为，这种多任务切换会严重损害专注力和产出质量。所以他们要求每个人在任何一个时间段内，只专注于一个任务，直到完成或进入下一个明确的状态。为了做到这一点，他们会刻意减少干扰，比如不开不必要的会议，不随便打断别人，甚至把团队沟通工具的通知关掉。他们觉得，真正重要的事情应该通过文档或者异步消息来沟通，而不是随时弹出的聊天框。

另一个有意思的习惯是，他们对“完成”的定义非常严格。很多团队觉得“代码写完了”就算完成，但 Linear 认为，只有代码合并、测试通过、文档更新、并且真正部署上线了，才算“完成”。如果中间有任何一个环节没做，这个任务就还是“进行中”。这种严格的定义避免了大量“差不多完成了但其实还有尾巴”的情况。你可能遇到过这种情况：一个功能说做完了，但用的时候发现没有使用说明，或者一上线就报错。Linear 的做法就是为了杜绝这种体验。

他们还特别重视“小步快跑”和“频繁发布”。不是攒一大堆功能然后一次性发布一个大版本，而是每几天就发布一次小的改进。这样每次改动都很小，风险低，出了问题也容易定位。用户也能持续感受到产品在变好，而不是等很久才看到一次大更新。为了做到这一点，他们投入了大量精力在自动化测试和部署流程上，确保每次小改动都能安全上线。

文章里还提到一个细节：他们如何对待“技术债”。很多团队在赶进度时会写一些“暂时能用但不够优雅”的代码，想着以后再来优化。但 Linear 觉得，这种债一旦欠下，以后要花好几倍的时间来还。所以他们宁愿在写第一版时就多花一点时间，把代码写得干净、可维护。这听起来像是理想主义，但实际执行中，他们会把“重构代码”或者“改进架构”也当作正式任务来排期，而不是靠程序员在加班时偷偷做。

这些做法单独拿出来看都不算新奇，但难的是整个团队都认同并坚持执行。文章其实是在说：高质量的产品不是靠某个天才设计师或者超级程序员一个人做出来的，而是靠一整套严谨、甚至有点“死板”的工作习惯。如果你是一个普通用户，看完可能会理解为什么有些软件用起来就是比别人家的顺心；如果你是一个做产品的人，可能会反思自己团队是不是在太多地方妥协了。最后，这篇文章想传递的判断是：持续交付高质量产品，本质上是一种纪律，而不是天赋。

Product Discovery Basics: Everything You Need to Know

你有没有遇到过这种情况：团队花了好几个月做出一个功能，上线后用户根本不用。或者你觉得自己想了一个绝妙的主意，结果用户完全无感。这其实很常见，因为我们在做之前，并没有真正搞懂用户需要什么。这篇文章讲的就是怎么避免这种浪费，它介绍了一个叫“产品发现”（product discovery）的方法。

产品发现不是让你去问用户“你想要什么”，因为用户往往说不清楚。比如在汽车还没出现的时候，你问人们想要什么，他们可能会说“更快的马”。产品发现要做的是，通过和用户聊天、观察他们的行为，去发现他们真正的问题是什么。文章里提到一个关键点：产品发现的目标不是验证你的想法是对的，而是去发现你哪里想错了。这听起来有点反直觉，但如果你一开始就假设自己的方案可能有问题，反而更容易找到正确的方向。

具体怎么做呢？文章介绍了几个步骤。首先是“明确假设”（state your assumptions）。假设你想做一个新功能，比如让用户能一键导出报告。你需要先写下你的假设：用户需要导出报告，他们觉得手动操作太麻烦，一键导出能节省时间等等。然后你要去验证这些假设，而不是直接开始写代码。验证的方式通常是做用户访谈（user interviews）。访谈不是随便聊，而是要有结构。比如你可以问用户：“你最近一次做报告是什么时候？当时你遇到了什么困难？”而不是问：“如果有个一键导出功能，你会用吗？”因为后者是在让用户想象，而前者能让你了解真实场景。

接下来是“快速实验”（run quick experiments）。文章强调，不要等到功能做出来再测试，而是用最小成本去验证。比如画一个简单的界面草图，或者用纸板做个原型（prototype），拿给用户看，看他们能不能理解、愿不愿意用。这比写代码快得多，也便宜得多。如果用户看到草图后一脸茫然，那你就知道这个方向可能不对，可以及时调整，而不是浪费几个月开发。

文章还提到一个很实用的概念：“机会树”（opportunity solution tree）。这是一个工具，帮你把用户的问题和可能的解决方案组织起来。比如根节点是“用户想更高效地完成报告”，下面分出几个机会：用户需要更好的数据可视化、用户需要自动化的数据收集、用户需要更简单的分享方式。每个机会下面又可以列出几个解决方案。这样你就能看清楚，哪些机会值得优先探索，哪些方案可能根本解决不了用户的问题。

最后，文章反复强调，产品发现应该是一个持续的过程，而不是只在项目开始时做一次。因为用户的需求会变，市场会变，你的理解也会变。所以最好每周都留出时间去做用户访谈或测试。这听起来很费时间，但比起做出来没人用的功能，这点投入其实非常划算。读完这篇文章，你最大的收获可能是：下次再想到一个“好主意”时，先别急着动手，去找几个真实用户聊聊，看看他们是不是真的需要这个。

How To Make Your Design System AI-Ready

现在大家都在说人工智能，很多公司都想让自己的产品变得更“智能”。但如果你有一个设计系统（design system），就是一套统一的设计规范，比如按钮的颜色、字体的大小、页面的布局，你怎么让它和人工智能配合起来呢？这篇文章就讲了这个问题。

想象一下，你是一个设计师，你的设计系统里有很多组件，比如按钮、输入框、卡片。现在你想让人工智能来帮你生成界面，比如让AI根据一段文字描述自动生成一个页面。但AI不懂你的设计系统，它可能会生成一些很丑或者不符合规范的东西。比如它可能把按钮做成圆角的，但你的设计系统规定按钮是方角的。所以你需要让AI“学会”你的设计系统。

文章提到一个关键点：让你的设计系统变得“AI可读”（AI-ready）。这听起来很高大上，但其实核心就是一件事：把你的设计系统用机器能理解的方式表达出来。比如，不要只把设计规范写在PDF或网页上，而是用代码或数据的形式写出来。这样AI就能直接读取这些规则，知道按钮的宽度是多少、间距是多少、什么情况下用哪种字体。

具体怎么做呢？文章建议从几个方面入手。首先，给你的每个组件加上清晰的标识（metadata），比如组件的名字、用途、属性。就像给每个零件贴上标签，这样AI就知道这个零件是干什么的。其次，把组件的使用规则也写清楚。比如“这个按钮只能用在表单底部，不能用在顶部”。这些规则可以用一种叫“设计令牌”（design tokens）的东西来管理。设计令牌其实就是一些变量，比如“主色=蓝色”“间距=8像素”。AI读取这些令牌后，就能自动应用正确的样式。

文章还举了一个例子：一家公司把他们的设计系统做成了JSON格式的文件，里面包含了所有组件的定义和规则。然后他们用这个文件训练了一个AI模型，让AI能根据用户输入的描述，自动生成符合设计系统的界面。比如用户说“一个登录页面，有邮箱和密码输入框，还有一个蓝色按钮”，AI就能生成一个完全符合他们设计系统的页面。这样设计师就不用从零开始画图，大大提高了效率。

当然，这里也有挑战。比如，你的设计系统可能很复杂，有很多特殊情况。AI能不能处理所有情况？文章提醒说，不要期待AI一开始就完美，而是要先从简单的部分开始，比如让AI生成一些基础的布局，然后设计师再手动调整。另外，你的设计系统本身也要足够清晰和一致，如果系统内部就有矛盾，AI就更难理解了。

读完这篇文章，你会明白：让AI帮你做设计，不是买一个工具那么简单，而是需要你先把自己的设计系统整理好，让它能被机器理解。这就像教一个人做菜，你首先要有一本清晰的菜谱，而不是一堆零散的食材。

How we launched AI within Slack in 6 months

想象一下，你每天上班打开电脑，第一件事就是登录一个叫 Slack 的聊天软件。这个软件里挤满了工作群，有公司全员群、项目群、设计群、技术群，还有一堆你根本不知道为什么要存在的群。你不停在群里看消息、回消息、翻找历史记录，每天有几个小时都泡在里面。Slack 自己也知道这一点，所以它一直想做一个更聪明的东西，能帮你从这些消息里省出时间。2023 年初，它决定把人工智能（AI）塞进产品里，而且只给自己六个月。

六个月听起来很短，尤其对于一个已经有上千万用户、每天产生海量消息的大公司来说。随便动一行代码，都可能让某个老用户突然崩溃。更麻烦的是，人工智能这个东西在当时还很新，很多人既期待又害怕。期待的是它能自动总结没看过的消息，害怕的是它会不会乱读自己的私密对话。Slack 的设计团队一开始就意识到，最大的难点不是技术，而是信任。用户必须相信这个 AI 不会偷看不该看的内容，不会把机密信息泄露给同事，更不会在总结时扭曲原意。

所以团队做的第一件事，不是写代码，而是建立一个叫“信任框架”（trust framework）的东西。听起来很抽象，但说白了就是一套明确的规则：AI 能看什么、不能看什么、看完之后怎么处理。比如，它只能读取你已经被拉进去的频道里的消息，不会偷偷扫描你的私信。而且所有处理都在 Slack 自己的服务器上完成，不会把数据发到外面的云端去训练别人的模型。为了让用户真的放心，他们把这些规则写成了简单易懂的说明，放在产品里最显眼的地方，而不是藏在某个法律条款的角落。

接下来才是产品怎么做的问题。Slack 的设计师们没有一上来就画一个巨大的 AI 助手界面，而是先想清楚用户最痛苦的那个动作是什么。他们发现很多人每天花大量时间“补课”，休假回来、开会错过、或者只是半天没看群，就得从头翻几百条消息。于是他们决定先做一个叫“频道回顾”（channel recaps）的功能：每天早上，AI 自动给每个频道的未读消息生成一段简短总结，告诉你昨天发生了什么重要的事。这个功能看起来简单，但背后要解决很多细节。比如，AI 怎么判断哪条消息重要？它得学会区分“好的，我知道了”和“服务器要挂了，赶紧处理”。Slack 团队没有自己去训练一个全新的模型，而是用现成的语言模型，再针对自己的场景做微调。

为了确保总结准确，他们做了大量测试。设计师和工程师一起，拿着真实频道里的对话，一条一条地看 AI 输出的总结有没有漏掉关键信息、有没有歪曲原意。他们还专门找了不同行业的公司来试用，比如科技公司、金融公司、非营利组织，因为每个行业的聊天习惯不一样。金融公司的人说话很简短，非营利组织的人则喜欢长篇大论。AI 必须适应这些差异。

六个月后，这个功能上线了。用户打开 Slack，会看到每个频道顶部有一个小小的按钮，点一下就能看到 AI 生成的摘要。很多人第一次用的时候很惊讶：它真的知道哪些事重要。但也有用户抱怨说，有时候摘要太长，还不如自己翻。Slack 团队听到反馈后，又加了一个选项，让用户可以调整摘要的详细程度，从“只列标题”到“带关键引文”。

这个案例告诉我们，在一个成熟产品里加入 AI，最关键的往往不是算法有多强，而是让用户觉得这个东西安全、可靠、有用。Slack 的设计师们花了大量时间在信任和细节上，而不是急着炫技。他们甚至没有把 AI 做成一个独立的机器人，而是把它藏在了用户本来就熟悉的界面里，你不需要学习新操作，只是多了一个按钮。这种克制，可能比技术本身更难做到。读完这篇文章，你大概会明白，为什么有些 AI 功能让人觉得贴心，而有些却让人觉得毛骨悚然，区别往往就在于设计者有没有真正站在用户的角度，把信任当作第一行代码来写。

UX Research Cheat Sheet

假设你是一家小公司的产品经理，你负责的 App 最近新增了一个功能，但是用户好像不怎么用。你想知道为什么，但你又没有钱请专业的调研公司。这时候你可能会想到自己做一点用户研究，但一打开搜索，看到的全是“可用性测试”“深度访谈”“卡片分类”这些词，每个看起来都像一门专业课程，你根本不知道从哪里下手。别担心，Nielsen Norman Group（NNG）这张速查表就是专门为你这样的人准备的。它不教你高深的理论，而是像一张地图，告诉你做用户研究到底有哪些方法、分别在什么阶段用、花多少时间、能得到什么结果。

这张表把研究方法分成了几个大类。比如，如果你想知道用户“说了什么”，可以用访谈（interviews）或者焦点小组（focus groups）。访谈就是一对一聊天，你问用户怎么用你的 App，哪里觉得麻烦。焦点小组是把五六个人叫到一起聊，大家互相启发，有时候能说出一个人想不到的观点。但要注意，用户说出来的不一定等于他们实际做的，所以还需要观察用户“做了什么”。这时候可以用可用性测试（usability testing），就是让用户实际操作你的 App，你在旁边看，看他会在哪里卡住、会点错哪里。这种测试非常直观，你甚至不需要很多用户，找五个人就能发现大部分问题。

还有一些方法是为了帮你发现“用户真正想要什么”，而不是他们嘴上说的。比如，情境访谈（contextual inquiry）就是跑到用户真实的工作环境里，看他怎么用你的产品。假如你的 App 是给仓库管理员用的，你就去仓库待一天，看他们怎么扫码、怎么记录、怎么抱怨。这种方法的优点是能发现用户自己都没意识到的需求。还有一种方法叫“日记研究”（diary study），让用户每天记下使用产品的感受，连续记一周或一个月，这样你能看到长期的使用模式，而不是一次测试里的偶然表现。

速查表里还特别提到，不同的产品阶段适合不同的方法。比如在产品还没做出来之前，你应该做探索性研究，比如访谈和观察，来理解用户的问题。等产品有了初步原型，可以用可用性测试来优化细节。等产品上线后，可以用分析工具（analytics）看用户点击数据，或者用调查问卷（surveys）收集大规模反馈。如果你在错误的时间用了错误的方法，比如在产品概念阶段就做可用性测试，那很可能是在测试一个没人需要的东西，白费力气。

这张表最实用的地方是它给出了每种方法需要的时间和人数。比如，一个简单的可用性测试，找五个人，每人测试一小时，加上准备和分析，总共可能只需要两天。而一个完整的深度访谈研究，可能要花两周。这对资源有限的团队特别有帮助，你可以根据手头的时间和预算，快速决定哪种方法最划算。

最后，速查表提醒你，用户研究不是一次性的活动，而应该是一个持续的过程。每次研究都会产生新的问题，然后你再选择合适的方法去回答这些问题。就像医生看病，不可能只做一次检查就永远治好，而是要根据病情变化不断调整。读完这张表，你至少能知道，下次当老板问你“用户为什么不用这个功能”时，你可以说：“让我先做五次可用性测试，一周后给你答案。”而不是一脸茫然地站在原地。

Why Retention Is the Silent Killer

很多做产品的人，每天都在盯着新用户数。今天来了多少人，明天能不能更多。这就像开了一家餐厅，每天在门口发传单拉客人进来，但从来不回头看客人吃完之后有没有再来。Reforge 的这篇文章想说的就是，一个产品真正致命的不是新用户来得慢，而是老用户留不住。而且这个杀手是无声的，因为它不会像服务器宕机那样立刻报警。

文章里举了一个很典型的例子。假设你的产品每个月新增 1000 个用户，但同时每个月也有 900 个用户离开。那么一年后，你大概会有 1200 个活跃用户。看起来好像还在增长，但如果你把流失率（churn rate，也就是每个月离开的用户比例）从 9% 降到 5%，同样新增 1000 个用户，一年后你的活跃用户会变成 6000 多个。差别是五倍。而这一切只是因为你每个月少流失了 40 个人。这就是所谓的“无声杀手”，它不会让公司立刻死掉，但会让所有增长的努力都像往漏水的桶里倒水。

那为什么很多团队不重视留存呢？文章认为，一个原因是留存的数据反应很慢。你今天改了一个功能，可能要过两三个月才能看到它对用户回访的影响。而新增用户数今天改了广告投放，明天就能看到数字变化。人的本能就是去关注那些马上能看到反馈的事情。另一个原因更隐蔽，就是留存问题往往被归咎于“产品不够好”，但这个说法太笼统了，没法指导行动。

文章给出了一个更具体的框架来理解留存。它把用户留存分为三个层次。第一个叫“习惯性留存”（habit retention），就是用户因为某种日常需要而自然回来用你的产品。比如一个人每天用微信聊天，不是因为微信提醒他，而是因为他想联系朋友。第二个叫“触发式留存”（triggered retention），就是用户因为外部提醒才回来。比如收到一封邮件说“你的报告已经生成好了”，或者手机弹出一个通知。第三个叫“主动式留存”（active retention），就是用户有意识地决定使用你的产品，比如打开一个健身 App 是因为今天想记录运动。

大多数产品的问题在于，它们停留在触发式留存，而没有进入习惯性留存。用户因为一封邮件点进来，但用完之后没有理由再次主动打开。文章建议团队去画一条“留存曲线”，也就是看用户注册后第 1 天、第 7 天、第 30 天、第 90 天还有多少人在用。如果曲线在头几周急速下降然后变平，那说明有一部分用户找到了长期价值，但更多人试了一下就走了。如果曲线一直缓慢下降，那说明产品没有真正让用户形成习惯。

文章还提到一个关键洞察：留存不是靠一个功能解决的，而是靠整个产品的核心价值循环。什么叫价值循环？就是用户做了一件事，产品立刻给了一个回报，这个回报又促使他做下一件事。比如在 Instagram 上，你拍一张照片，朋友点赞，你感到开心，于是再拍一张。这个循环越短、越频繁，用户就越离不开。如果循环太长，比如用户注册后要等三天才能看到第一个回报，那大部分人等不到那一天。

读这篇文章最该带走的一个判断是：别把留存当成一个后期优化的指标。它应该从一开始就是产品设计的核心问题。与其花大价钱拉新用户，不如先搞清楚已经来的用户为什么不再来了。有时候答案很简单，比如注册流程太长，或者核心功能藏得太深。找到并修复这些点，比任何增长技巧都管用。

Product Vision

很多做产品的人，每天忙的都是下周要上线什么功能，或者这个季度的指标怎么完成。但 Silicon Valley Product Group 的这篇文章想提醒一件事：如果你没有一个长远的产品愿景（product vision），你做的所有短期决策都可能把产品带偏。

文章开头讲了一个很形象的比喻。假设你是一个建筑项目的负责人，你的团队每天都在砌砖、拉电线、装窗户。但如果没有人知道这栋楼最终长什么样，那每个人可能都在按照自己的想法做事。有人觉得应该多开几扇窗，有人觉得应该加一层楼。最后出来的东西可能四不像，甚至根本不能住人。产品也是一样。愿景就是那张建筑蓝图，它不告诉你明天砌哪块砖，但它告诉你整栋楼应该是什么样子。

那产品愿景具体是什么呢？文章给了一个定义：它是对未来三到五年内，你的产品希望为用户创造什么样世界的描述。注意，这里说的是“世界”，而不是“功能列表”。比如一个在线教育产品的愿景，不应该是“我们要增加视频播放和习题功能”，而应该是“让每个人在任何地方都能像坐在最好的老师面前一样学习”。前者是功能，后者是体验和结果。

文章特别强调，愿景不是目标（goal），也不是路线图（roadmap）。目标是可量化的，比如“明年用户达到 100 万”。路线图是具体的执行计划，比如“下个季度做搜索功能”。愿景是更上层的方向，它回答的是“我们为什么要做这件事”以及“我们最终想成为什么”。它不需要精确，但需要激励人心。

那一个产品愿景应该怎么写呢？文章建议从几个角度思考。第一，它应该以用户为中心，描述用户在使用你的产品之后会有什么样的改变。第二，它应该足够具体，让人能想象出那个画面。比如“让每个人都能轻松学会编程”就比“成为最好的教育平台”更具体。第三，它应该能指导决策。当团队在纠结要不要做一个功能时，可以问自己：这个功能是否让我们更接近愿景？如果答案是否定的，那就不要做。

文章还举了一个实际例子。一个团队的产品愿景是“成为设计师的协作中心”。这个愿景听起来很简单，但它意味着团队不会去做设计师不需要的东西，比如项目管理或者代码托管。它也会让团队优先考虑哪些功能能让设计师更愿意在这里协作，而不是单独工作。

读这篇文章最该带走的一个判断是：愿景不是挂在墙上的标语，而是一个每天都可以用来做取舍的工具。没有愿景的团队，就像在没有地图的情况下开车，可能跑得很快，但方向是错的。产品经理最重要的工作之一，就是不断和团队沟通愿景，确保每个人都知道那栋楼最终长什么样。

Piecing It Together: How to Design Cohesive Onboarding

想象一下，你刚下载了一个新的记账软件，注册、填信息、绑银行卡，折腾了十分钟，结果打开首页，满屏都是图表和按钮，你根本不知道第一步该点哪里。很多人这时候就关掉了软件，再也没打开过。用户引导（onboarding）要解决的就是这个问题：让新用户从“下载了”到“真的会用”，并且愿意一直用下去。但很多公司把引导做成了一条固定的流水线，所有人都走一样的流程。Intercom 这家做客服软件的公司发现，这条路走不通了。因为他们的产品越来越复杂，不同客户的使用场景千差万别：一个小创业公司可能只需要一个聊天窗口，而一个大企业可能需要设置多部门协作、自动回复规则、数据报表。如果让所有人都走一遍完整的引导流程，小公司会觉得太啰嗦，大企业又觉得关键功能根本没教到。

于是 Intercom 的团队提出了一个思路：把引导拆成模块（modular onboarding）。就像拼乐高一样，每个模块负责教一个独立的功能或场景，比如“如何设置自动回复”是一个模块，“如何把客服对话分配给不同同事”是另一个模块。新用户注册后，系统会根据他们填写的公司规模、行业、使用目的，自动推荐几个最相关的模块，用户也可以自己选择想先学什么。这样一来，每个人看到的引导都是针对自己的，不是一套死板的教程。

但这里有一个更深的挑战：模块化之后，谁来保证整个引导体验是连贯的？如果每个模块各自为政，用户可能在“设置自动回复”模块里学会了怎么创建规则，但回到主界面后又不知道这个规则在哪里生效。Intercom 的设计师们发现，问题的核心不是把内容切碎，而是要在切碎之后，仍然让用户感觉自己在走一条完整的路。他们用了一个比喻：引导不应该像一本翻到哪页读哪页的百科全书，而应该像一场有向导的旅行，向导会根据你的兴趣带你去不同景点，但全程都告诉你现在在哪里、下一站去哪里。

具体怎么做到呢？Intercom 的做法是，在每一个模块的开头，先告诉用户“这个模块会花几分钟，学完之后你能做到什么”，然后在模块结束时，给出一个明确的下一步建议，比如“你已经学会了如何创建自动回复，接下来可以试试设置团队分配”。同时，整个引导流程有一个全局的进度条，显示用户已经完成了哪些模块，还有哪些是推荐的。这样，即使模块是独立的，用户也能感受到自己在一步步深入产品，而不是在碎片里打转。

这篇文章最有价值的地方，是它把“引导”这件事从“产品功能教学”提升到了“跨团队协作设计”的层面。因为模块化引导不是产品经理一个人能决定的，它需要设计团队、工程团队、数据团队、客服团队一起定义：哪些功能值得做成一个独立模块？不同用户群体的典型“第一周”应该包含哪些模块？怎么衡量一个模块是成功的？Intercom 的经验是，他们先通过客服聊天记录和用户调研，找出新用户最常问的问题、最常卡住的地方，然后把这些痛点对应到具体的产品功能上，再围绕这些功能设计模块。

读完这篇文章，你会带走一个判断：好的用户引导不是把说明书写得更清楚，而是让产品自己学会“看人下菜碟”。当你的产品越来越复杂，用户越来越多样时，与其强迫所有人走同一条路，不如把路拆成可以自由组合的片段，再给每个用户一张只属于他的地图。

Anthropic’s first technical PM on token maxing, the jagged edge, and living in the future | Dianne Penn

如果你用过 ChatGPT 或者 Claude，你大概感受过那种“它好像什么都能做，但又好像总差那么一点”的体验。有时候你问一个复杂问题，它回答得头头是道；有时候你只是让它改个标点，它却把整段话都重写了。这种不稳定的感觉，正是 Dianne Penn 在 Anthropic（开发 Claude 的那家公司）做第一位技术产品经理时，每天都在面对的核心问题。

Dianne 在 Lenny 的播客里聊了一个很形象的词：token maxing。Token 是 AI 模型处理信息的最小单位，一个 token 可以是一个词、一个字母或一个标点。Token maxing 的意思就是，用户总是想把一次对话里能用的 token 数量用到极限，恨不得让模型在一个回答里把所有事情都做完。比如你让 Claude 写一篇产品文档，它写完了，你又接着说“顺便把邮件草稿也写了”，然后又说“再检查一下语法”。结果模型越往后越吃力，因为它前面已经用了太多“脑力”去写文档，后面的任务可能就敷衍了事。Dianne 说，产品经理的工作之一，就是帮用户理解模型的“脑力”是有限的，不能无限叠加任务。

另一个关键概念是“锯齿边缘”（the jagged edge）。这是 Anthropic 内部用来描述 AI 能力边界的比喻。想象一张地图，中间是一片平坦的陆地，代表 AI 已经能做得很好的事情，比如翻译、总结、写简单代码。但陆地的边缘不是平滑的，而是像锯齿一样参差不齐。有些地方锯齿伸出去很远，意味着 AI 在某些特定任务上超乎预期地强；有些地方锯齿凹进去，意味着明明看起来类似的任务，AI 却做得很差。比如，Claude 可能能完美解释一个物理学概念，但面对“帮我算一下这个月的家庭开支总和”这种小学数学题却突然犯傻。产品经理的任务，就是不断探索这片锯齿边缘，搞清楚哪些地方可以放心交给 AI，哪些地方必须提醒用户“这里可能需要你自己检查一下”。

Dianne 还讲了一个很具体的例子，关于“活在未来”（living in the future）。她说，做 AI 产品的人，经常处于一种奇怪的状态：你手里已经有了一些还没发布的能力，你知道半年后这个产品会变成什么样，但你得假装现在只有这些功能。比如，团队内部可能已经测试了 Claude 的一个新版本，能准确理解用户的长篇对话历史，但当前版本还做不到。这时候用户来抱怨“为什么 Claude 记不住我十分钟前说了什么”，你不能说“别急，下个版本就好了”，只能想办法用当前的技术给用户一些临时方案。这种“知道未来但必须活在当下”的张力，是 AI 产品经理每天都要面对的。

如果你是零背景读者，可能会觉得这些概念离你很远。但其实你每天都在和“锯齿边缘”打交道：你用 AI 写邮件时，它帮你把措辞改得更好，但突然在某个细节上犯了一个离谱的错误，那就是锯齿边缘的凹槽。而“token maxing”也发生在你身上：你让 AI 同时做三件事，结果它最后一件做得一塌糊涂。Dianne 的分享让我们看到，AI 产品经理的工作不是让模型无所不能，而是帮普通人在这个能力参差不齐、资源有限的新工具面前，找到最安全、最有效的使用方式。

读完这篇文章，你会带走一个判断：AI 产品的好坏，不只看模型本身有多强，更看产品经理能不能画出那张锯齿边缘的地图，并告诉用户哪里可以放心走、哪里需要自己探路。而一个好的 AI 产品，会让你感觉它知道自己的局限，并且诚实地和你一起想办法绕过那些局限。

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的故事提醒我们：当外部环境剧变时，与其收缩防守，不如借机追问“用户真正想要的是什么”。有时候答案就藏在那些看似过时的业务里，只是需要换一个视角去看。