Product Coaching and AI

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

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

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

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

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

Four Levels Of Customer Understanding

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Backstitch 01 · Version Control for Space and Structure

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

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

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

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

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

Language Model Sketchbook, or Why I Hate Chatbots

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

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

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

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

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

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

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

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

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

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

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

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

Build vs Buy in the Age of AI

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

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

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

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

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

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

A primer on product management for engineers

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

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

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

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

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

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

How we measure AI quality at Dovetail

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Crafting AI Explanations for Every Role in Your Enterprise

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

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

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

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

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

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

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

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

Make something agents want

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

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

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

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

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

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

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

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

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

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

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

Rethinking The Experience Of System Tools

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

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

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

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

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

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

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

Jacquard 01 · Versioning and provenance for empirical research

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Home-Cooked Software and Barefoot Developers

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

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

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

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

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

Malleable software in the age of LLMs

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

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

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

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

Agents First

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

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

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

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

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

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

The Architecture Of Local-First Web Development

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

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

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

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

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

Product Leadership Archetypes

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

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

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

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

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

Harness engineering for coding agent users

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

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

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

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

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

Expanding Stripe Radar to protect more of your business

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

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

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

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

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

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

Craft in design: What it is & why it matters

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

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

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

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

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

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

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

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

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

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

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

Bliki: Architecture Decision Record

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

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

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

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

Research into how AI can help users understand skin conditions

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

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

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

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

Building OpenCode with Dax Raad

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

An IC’s guide to roadmap planning

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

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

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

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

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

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

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

How we developed a better way to learn at Slack Design

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

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

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

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

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

Matching AI Modality To User Intent: Designing The Right Interface

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

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

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

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

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

Microservice dogma nearly tanked our seed round

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

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

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

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

Stakeholders and the Product Model

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

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

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

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

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

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

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

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

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

Building Reliable Agentic AI Systems

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

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

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

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

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

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

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

The power of collaboration: How we can reduce traffic congestion

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

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

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

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

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

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

Why is Meta destroying its engineering organization?

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

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

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

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

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

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

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

Prototypes vs Products

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

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

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

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

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

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

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

Designing Where the Pixels Actually Live

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

How we built saga rollbacks for Cloudflare Workflows

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

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

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

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

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

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

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

Context Architecture

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Using RAS to Guide UX Research Resource Allocation and Strategy

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

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

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

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

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

Principles of Mechanical Sympathy

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

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

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

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

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

How we layered product principles to refresh Slack notifications

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Commercial vs Internal Products

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

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

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

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

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

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

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

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

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

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

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

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

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

Magic Ink: Information Software and the Graphical Interface

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

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

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

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

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

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

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

A Treatise on AI Chatbots Undermining the Enlightenment

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

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

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

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

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

A Brief Rant on the Future of Interaction Design

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

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

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

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

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

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

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

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

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

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

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

Apple sues OpenAI over alleged trade secret theft

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

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

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

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

Build to Learn vs Build to Earn

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

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

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

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

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

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

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

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

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

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

The Hidden Why: Behavioral Economics for UX

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Design-System Maturity: A 6-Dimension Framework

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

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

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

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

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

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

AI Model Co-Design: Hardware-Friendly LLM Design

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

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

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

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

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

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

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

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

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

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

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

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

Meta removes controversial AI feature on Instagram after backlash

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

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

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

Build To Learn FAQ

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

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

举个例子，假设你的团队想在一个电商应用里加入“虚拟试穿”功能。传统做法可能是先花三个月开发图像识别和3D渲染，然后上线看用户用不用。但“为学习而构建”的做法是：先问自己“我们真正想验证的假设是什么？”可能是“用户愿意花时间上传自己的照片来试穿衣服”，或者“虚拟试穿能提高购买转化率”。为了验证第一个假设，你甚至不需要真正的3D渲染，你可以做一个简单的页面，让用户上传一张照片，然后手动发一张合成的效果图给他们。这只需要一两天，但你能很快知道用户是否愿意走完这个流程。如果没人上传照片，那后面的技术投资就完全没有必要。

卡根在他的文章里反复强调，这种思维方式最大的障碍不是技术，而是文化。很多产品经理、设计师和工程师习惯了“交付功能”的成就感，他们觉得做一个半成品或者手工模拟的东西不体面。但真正优秀的产品团队会意识到，浪费几个月做一个没人用的功能，才是最大的浪费。所以“为学习而构建”不是一种偷懒，而是一种更负责任的做法。

当然，实际操作中会有很多疑问：什么时候该用这种方法？什么时候该直接做完整功能？团队怎么衡量学习的效果？卡根在他的FAQ里回答了这些常见问题。比如，他建议当团队面对高度不确定性的假设时，就应该优先考虑“为学习而构建”。如果假设已经很明确，比如用户需要登录才能保存购物车，那直接做就好了。他还提到，学习的目标应该具体、可衡量，比如“在24小时内，有超过10%的访客点击了试穿按钮”，而不是模糊的“看看用户喜不喜欢”。

读完这篇文章，你可能会意识到，产品开发的核心不是产出代码，而是产出知识。每一次构建都是一次实验，而实验的目的是让团队对用户和市场的理解变得更清晰。如果你能接受这个前提，那么你的产品开发流程就会变得更快、更便宜，也更容易做出真正对的东西。

Show HN: Openleetcode – LeetCode runner where tests live in the repo

你刷 LeetCode 的时候有没有遇到过这种情况：一道题本地跑得好好的，提交上去就是不过，报一个莫名其妙的测试用例失败。你翻来覆去看自己的代码，觉得逻辑完全对，但就是不知道到底哪个边界没覆盖到。问题往往出在 LeetCode 平台自带的那些隐藏测试用例上。它们不会提前告诉你，你只能一次次提交、失败、再猜。OpenLeetCode 这个项目想改变的，就是这件事。

它本质上是一个 LeetCode 的运行器（runner），但做了一件很特别的事：把测试用例直接放在代码仓库里（tests live in the repo）。什么意思呢？就是你 clone 下来一个题目的仓库，里面除了你的解法代码，还有一个 tests 文件夹，里面放着对应的测试用例。这些测试用例不是你自己写的，而是项目作者预先整理好的，很可能就是 LeetCode 官方那些隐藏用例。你在本地跑一下测试，就能立刻看到你的代码在哪一个具体输入上失败了，输出是什么，期望输出又是什么。

这听起来好像只是一点小小的便利，但对刷题的人来说，体验差别巨大。传统做法是你在本地写代码，写完之后手动构造几个例子跑一下，觉得没问题就粘贴到 LeetCode 上提交。但人构造的例子往往太简单，或者太偏向自己代码的逻辑，很难覆盖所有边界。而 OpenLeetCode 把官方测试用例直接摊在你面前，你就能在提交之前，用和平台完全一样的测试集去验证。这等于把原来黑盒的评测过程变成了白盒。

项目是用 GitHub Releases 发布的，当前版本是 v1.0.2。作者显然希望这个工具能持续更新，随着 LeetCode 题库的变化同步调整测试用例。对于正在准备面试、大量刷题的人来说，这种工具能节省很多反复提交试错的时间，也能让学习过程更聚焦在算法本身，而不是在猜测测试用例上。

当然，它也有一个潜在的前提：你愿意在本地搭建一个运行环境，并且信任作者整理的测试用例和官方一致。不过对于已经习惯在本地用 IDE 写代码的开发者来说，这几乎不算门槛。OpenLeetCode 更像是一个小但精准的改进，把刷题流程中那个最令人沮丧的环节，看不见的测试用例，变成了你可以主动检查和理解的资源。读完之后你会觉得，有时候一个好的产品思路，就是把用户原本需要猜的东西，直接摆到桌面上。

Your New UX Habit: Establishing Baselines for Impact

想象一下，你刚上线了一个新的注册流程，把步骤从五步减到了三步。一周后，注册完成率从40%涨到了60%。你很高兴，觉得改对了。但等一下，你怎么知道这个提升不是因为恰好赶上了一个营销活动？或者是因为竞争对手出了故障，用户都涌过来了？你其实不知道，除非你在改动之前就知道那个40%是怎么来的。这就是基线（baseline）的意义。

基线不是一句口号，它是一个具体的、可测量的起点数据，用来对比你后续的改动到底有没有效果。很多团队犯的错误是：产品上线后直接看新数据，觉得不错就收工了。但如果没有基线，你永远没法区分“真正的改善”和“自然波动”。比如，你改了一个按钮颜色，转化率从5%变成6%，你以为是颜色起了作用，但其实可能是那天刚好是发薪日，用户花钱更大方。基线帮你排除这些干扰。

那怎么建立基线呢？文章给出了很实用的方法。首先，你必须在你改动之前就收集数据。这不是事后补的，而是提前规划好的。比如你要改搜索功能，先记录下当前用户搜索的成功率、平均搜索时长、点击结果的比例，至少持续一两周，确保数据稳定。其次，基线要覆盖关键指标，不只是最终转化率，还要包括过程指标，比如用户在哪一步流失最多、哪个页面加载最慢。这些细节能帮你定位问题，而不是只看到一个模糊的数字。

一个具体的例子是：某团队想优化结账页面，他们先记录了当前结账完成率是45%，然后发现用户主要在“输入地址”这一步离开。于是他们改成了自动填充地址，改完后完成率升到55%。但因为有了基线，他们知道这10%的提升是真实发生的，而不是因为季节性或促销活动。如果没有基线，他们可能只是庆祝一下，然后继续做下一个改动，而不知道真正有效的到底是什么。

建立基线还有一个容易被忽略的好处：它能让你在团队内部或跟老板沟通时更有说服力。当你拿着“改动前是45%，改动后是55%，提升22%”这样的数据，所有人都能理解你做了什么、为什么有效。而如果你只是说“我觉得改完以后好多了”，那别人只能凭感觉回应。

所以，下次你要做任何一个UX改动之前，先花一点时间记录当前的状态。哪怕只是简单记几个数字，也比没有强。养成这个习惯，你的每一次优化都会变得可衡量、可信赖，而不是靠运气。读完这篇文章，你带走的不只是一个方法，而是一种工作方式：在行动之前先看清自己站在哪里。

In-depth: DuckDB vs SQLite

如果你做数据分析，或者你只是用Excel处理过几万行数据然后电脑卡死过，你就知道“用什么工具来查数据”这个问题有多实际。DuckDB和SQLite是两个经常被拿出来对比的选择。它们都很轻量，不需要装服务器，文件就能跑，但它们的定位其实完全不同。

SQLite你可能更熟悉，它几乎是嵌入式数据库的代名词。手机应用、浏览器、甚至一些物联网设备都在用。它是一个完整的关系型数据库，支持SQL，数据存在一个文件里，读写都很快，尤其适合单用户、低并发、需要持久化存储的场景。比如你写一个记账App，数据存在本地，用SQLite就非常合适。

DuckDB则相对年轻，它专门为分析型查询（analytical queries）设计。什么意思呢？就是那种你要对几百万行数据做聚合、分组、排序、窗口函数这类操作。SQLite在这种场景下会很吃力，因为它是为事务处理（OLTP）优化的，一次处理一行数据很高效，但一次扫描整个表做统计就不太行。而DuckDB是列式存储（columnar storage），并且做了向量化执行（vectorized execution），所以处理大规模分析查询非常快。

举个例子，你有一个包含一年销售数据的CSV文件，有5000万行。你想算每个月的总销售额。用SQLite的话，可能得等几分钟，甚至更久。用DuckDB，同样的查询可能几秒钟就出结果。DuckDB还能直接读CSV、Parquet这些文件格式，不需要先把数据导入数据库，这对数据分析师特别友好。

那什么时候用哪个呢？文章给出了很清晰的判断。如果你的需求是：一个应用需要本地存储用户数据，并发读写不多，数据量在几百万行以内，那么SQLite是稳妥的选择。如果你是在做数据分析、数据科学、或者需要快速探索大量数据，而且查询模式是聚合分析为主，那么DuckDB更合适。另外，DuckDB还支持Python和R的接口，可以跟pandas无缝协作，很多数据科学家已经把它当作“更快版pandas”来用。

不过，它们不是非此即彼的关系。有些场景下，你甚至可以同时用两者：用SQLite做应用的后端存储，然后用DuckDB定期从SQLite导出数据做分析。这样各取所长，系统既稳定又高效。

读完这篇文章，你会明白一个道理：工具没有绝对的好坏，关键看你的使用场景。选错了，再好的工具也会让你头疼。而当你理解了事务处理和分析处理的本质区别，你就能在遇到类似选择时，做出更明智的决定。

What happens after coding is solved? | Fiona Fung (Manager of the Claude Code and Cowork Teams)

想象一下，如果有一天，写代码这件事本身不再值钱。不是程序员失业，而是写代码变得像打字一样简单，任何人用自然语言说一句话，计算机就能生成一个可以运行的软件。那之后，软件行业会变成什么样？这个问题听起来像科幻，但Fiona Fung，也就是Claude Code和Cowork团队的负责人，在Lenny的播客里认真讨论了这件事，因为她的团队正在亲手推动这个变化。Claude Code是Anthropic推出的一款AI编程工具，它不只是补全代码，而是能理解整个项目，自动修改文件、运行测试、甚至部署。

Fiona说，他们团队内部已经习惯了让AI写80%以上的代码，剩下的主要是审查和调整方向。那么问题来了：如果编程能力不再是瓶颈，什么才是真正稀缺的能力？Fiona的答案是：理解问题本身的能力。她举了一个例子：一个产品经理走进来说“我们要做一个用户反馈系统”，如果AI能直接生成一个完整系统，那产品经理必须非常清楚地知道自己到底想要什么，用户真正需要什么，哪些功能是核心，哪些是噪音。过去，程序员在实现过程中会帮产品经理修正需求，因为写代码太贵了，大家不得不精打细算。当代码成本趋近于零，需求定义的质量就变成了唯一的约束条件。这其实在倒逼整个产品团队变得更加严谨。

另一个被AI解放出来的能力是产品发现（product discovery）。Fiona观察到，当团队不再花大量时间写代码，他们可以把更多精力放在观察用户、做实验、验证假设上。以前一个想法从构思到上线可能需要几周，现在可能只需要几个小时。这意味着团队可以更快地试错，更快地学习。但这也带来一个风险：如果团队没有良好的产品判断力，快速试错可能会变成快速制造垃圾。

所以Fiona认为，未来的核心竞争力不是写代码的速度，而是判断“该做什么”和“不该做什么”的能力。她还谈到了一个有趣的现象：当AI能写代码后，工程师的角色会从“建造者”变成“审查者”和“决策者”。你需要快速阅读AI生成的代码，判断它是否合理，是否安全，是否符合架构。这其实需要更深的理解，而不是更浅。就像一个建筑师不再亲手搬砖，但他必须能看懂图纸，知道哪里可能承重有问题。所以Fiona建议工程师现在就应该开始练习“阅读代码”和“思考代码”的能力，而不是只关注“写代码”的技巧。

最后，Fiona提到了一个更长远的影响：当编程的门槛消失，软件行业可能会像出版业一样，每个人都能“出版”软件，但真正能被用户记住的，永远是那些解决了真实问题的产品。而解决真实问题，需要的是对用户的理解、对场景的洞察、以及对商业逻辑的把握。这些东西，AI暂时还学不会。所以，如果你是一个产品经理、设计师或者创业者，现在可能是最好的时代：你不再需要等一个程序员来帮你实现想法，你可以自己动手，用AI快速验证。但前提是，你必须比以往任何时候都更清楚，你在解决谁的问题，以及为什么这个问题值得解决。

How to measure the customer experience as AI scales

当一家公司开始用人工智能处理客户服务，最让人紧张的问题往往不是“AI能不能搞定”，而是“我怎么知道它搞得好不好”。过去，客服团队有很成熟的衡量方式：平均响应时间、首次解决率、客户满意度评分。这些指标背后站着真实的人，人的行为可以被观察、被训练、被复盘。但一旦把一部分对话交给AI，整个衡量体系就开始摇晃。你很难用同样的尺子去量一个机器，因为机器不会累、不会情绪波动，但它也可能用一种非常礼貌的方式把客户气走。

Intercom 这家公司长期做客服工具，他们自己也在产品里大量嵌入AI，所以他们思考这个问题不是从理论出发，而是从真实的产品场景里长出来的。他们发现，当AI开始处理客户对话，传统的满意度调查（CSAT）依然有效，但需要做两件事：第一，把AI和人工的对话分开测量，不能混在一起看平均数；第二，要在AI对话结束后立刻触发调查，因为客户对AI的记忆很短，过几个小时再问，他们可能已经忘了刚才和机器说过话。

更关键的是，他们提出一个概念叫“转人工率”（escalation rate）。如果AI把对话转给真人，这本身不一定是坏事，但转人工的原因很重要。是AI承认自己处理不了，还是客户主动要求转人工？如果是后者，那说明AI的边界没有被客户接受。Intercom 建议团队追踪“非必要转人工”，也就是AI本可以处理但客户仍然要求转人的情况。这个数字如果偏高，说明AI的沟通方式或者能力边界没有对客户透明化，客户对AI缺乏信任。

还有一个有趣的观察：客户对AI的耐心其实比很多人想象的要低，但也很容易被“提前告知”所改善。如果AI在对话一开始就说“我是AI助手，如果需要我可以帮你转接人工”，客户后续的满意度会明显更高。这听起来像是一个小细节，但它揭示了一个更深层的道理：衡量客户体验，不能只看AI能不能解决问题，还要看AI有没有管理好客户的预期。预期管理做得好，即使AI最后没有解决，客户也不会太生气；预期管理做得差，AI即使解决了问题，客户也可能觉得“被敷衍了”。

所以当一家公司说“我们要用AI来提升客户体验”，真正要做的不是替换掉原来的衡量体系，而是重建一套更适合混合服务模式的指标。Intercom 的经验是，保留传统的满意度调查，但增加AI专属的“转人工原因分析”和“预期清晰度评估”。同时，他们提醒团队不要只盯着“AI解决率”这一个数字，因为一个AI如果只挑简单问题回答，解决率可以很高，但它实际上把最复杂、最需要人工介入的问题全部漏掉了，反而让人工团队更累。

读到这篇文章，最值得带走的判断可能不是某个具体指标，而是一种视角的转换：衡量AI时代的客户体验，本质上是衡量人与机器之间的交接是否平滑。客户不会关心背后是AI还是人，他们只关心自己的问题有没有被理解、有没有被认真对待。所以，所有指标最终都应该指向同一个方向，客户有没有感到被尊重。如果AI能做到这一点，即使它偶尔犯错，客户也愿意给它第二次机会。

这篇文章来自 Intercom 的官方博客，他们写这类内容通常不是为了卖工具，而是为了推动整个行业对“AI客服”这件事有更成熟的认知。如果你正在做类似的产品或者负责客服团队，这篇文章能帮你避开很多“只看解决率”的坑。

How tech workers actually feel about AI in 2026 | Annual AI sentiment survey (Noam Segal)

2026年，距离ChatGPT首次引爆公众对生成式AI的热情已经过去了将近三年。这三年里，几乎每个科技公司都在谈AI、投AI、推AI产品。但一个关键问题始终悬而未决：真正在写代码、做设计、定策略的技术工作者，他们到底怎么看待这股浪潮？他们是在兴奋地拥抱，还是默默焦虑，又或者已经疲惫到不再关心？

Noam Segal连续第二年做了大规模调查，直接问科技从业者。结果很有意思，整体情绪从2025年的“谨慎乐观”变成了“务实且分化”。大部分人不再觉得AI会立刻取代他们的工作，但也不再幻想AI能神奇地解决所有问题。他们开始把AI当作一个需要管理的工具，而不是一个需要崇拜或恐惧的神。

一个特别具体的数字很能说明问题：当被问到“你每天使用AI的频率”时，超过一半的人说“每周几次”或更少。这意味着，尽管公司层面铺天盖地地推广，真正把AI嵌入日常工作流的人并没有想象中那么多。很多人试过、觉得有用、但没有形成习惯。这有点像几年前大家对待低代码平台的态度，听起来很美，但真正改变日常工作方式的，永远是那些能无缝融入现有流程的工具。

另一个值得注意的发现是，不同岗位的态度差异比想象中大。工程师相对更务实，他们关心的是代码质量、调试效率、以及AI生成的代码是否有安全隐患。产品经理则更焦虑，因为他们担心AI会让“需求分析”和“用户研究”这些核心技能变得不再稀缺。设计师的处境最微妙，他们既兴奋于AI能快速生成大量素材，又担心自己的工作被简化为“给AI写提示词”。

Segal在报告里还提到了一个转折点：2025年很多公司强制要求员工使用AI工具，结果引发了不小的反弹。到了2026年，管理者学聪明了，开始用“赋能”代替“要求”，用“实验预算”代替“培训考核”。这种管理方式的转变，反而让更多技术工作者愿意主动尝试。

读这份报告最让人踏实的一点是，它没有贩卖焦虑，也没有盲目唱多。它呈现了一个正在快速成熟、但也正在回归理性的行业图景。技术工作者们不再争论“AI会不会取代人类”这种宏大问题，而是开始讨论“这个模型在我的代码库里到底能帮我省多少时间”。这种从口号到实践的转变，可能才是2026年最值得关注的信号。如果你自己也在日常工作里接触AI，你会发现自己并不孤单，大家都是在边用边学，边学边调整预期。

The 5 Qualities of Site-Specific AI Chatbots

想象一下，你打开一个购物网站，想找一件适合户外徒步的防水夹克。你试着在搜索框里输入“防水夹克”，结果出来一堆商务风衣和雨伞。你又试了“徒步防水外套”，这次出现了滑雪服。你开始烦躁，心想这个网站的搜索怎么这么笨。其实不是搜索笨，而是它不知道你在这个网站里到底想要什么。这就是为什么越来越多的网站开始引入AI聊天机器人，而且不是那种通用型的ChatGPT，而是专门为这个网站定制的聊天机器人。

Nielsen Norman Group 最近发布了一篇文章，专门讨论了这类“网站专属AI聊天机器人”应该具备的五个品质。文章没有直接给答案，而是先从用户的实际体验出发。比如，用户来到一个网站，他可能对网站的内容结构完全不了解，但他知道自己想完成什么任务。一个好的网站专属聊天机器人，首先要理解这个网站里到底有什么。它不能像搜索引擎那样去全网找答案，它只能基于这个网站已有的信息来回答。这就要求机器人必须知道网站的产品目录、文章分类、常见问题等等。这听起来简单，但很多网站聊天机器人连这个都做不好，因为它们只是被塞进了一个通用模型，没有经过网站数据的微调。

第二个品质是能够理解上下文。比如用户问“这件衣服有蓝色的吗？”，机器人得知道“这件衣服”指的是用户刚才浏览的那件。如果用户说“我想退货”，机器人要能判断出用户是已经买了东西，还是只是问问退货政策。上下文不仅仅是一次对话内的，还包括用户的历史行为。比如一个用户之前经常看户外装备，那么他问“推荐一款背包”时，机器人应该优先推荐户外背包，而不是商务背包。这需要机器人能够和网站的追踪系统联动，但又不至于侵犯隐私。

第三个品质是能够提供准确的行动指引。很多聊天机器人只会给出文字答案，比如“您可以在订单页面申请退货”。但一个好的机器人应该能直接给出链接，甚至引导用户完成操作。比如用户问“怎么改地址？”，机器人可以回复“在账户设置里的‘配送地址’页面修改，需要我帮你打开吗？”然后直接提供一个按钮。这听起来像是一个小细节，但用户要的就是这种“一步到位”的感觉。

第四个品质是能够处理模糊问题。用户经常不会用精准的术语提问。比如有人问“我想去海边玩，有什么推荐？”，机器人得知道“海边”可能意味着泳装、沙滩鞋、防晒霜，或者旅行攻略。它需要主动追问，比如“您是想找海滩度假的服装，还是旅行目的地推荐？”这种追问能力非常关键，因为它能帮用户理清自己的需求，而不是让用户自己猜。

最后一个品质是能够保持品牌一致性和语气。每个网站都有自己的风格，比如苹果的客服语气简洁专业，而迪士尼的客服语气活泼可爱。如果聊天机器人用冷冰冰的机械语气回复，用户会觉得和网站的整体体验割裂。所以机器人需要被训练成符合品牌调性，甚至能模仿该网站最优秀客服人员的语气。

这五个品质听起来像是常识，但真正能做到的网站并不多。很多网站为了赶AI潮流，随便接一个API就上线了聊天机器人，结果用户问了三个问题就发现它答非所问，反而比没有机器人更糟糕。文章最后提醒，网站专属聊天机器人的核心不是“AI有多强”，而是“它有多懂这个网站”。如果它不懂网站的内容、不懂用户的上下文、不懂怎么引导操作、不懂怎么追问模糊问题、不懂怎么保持品牌一致，那它就是一个昂贵的摆设。

读完这篇文章，你可能会开始留意自己访问的网站里那些聊天机器人。下一次当你遇到一个机器人，能准确理解你的问题，甚至在你还没说完时就猜到了你要什么，你就会知道，那个网站一定在背后下了不少功夫。而那些让你反复说“不是这个”“你再想想”的机器人，很可能只是被随便扔上来的一个半成品。

Phia accused of ‘cookie stuffing,’ taking affiliate credit on purchases it didn’t earn

你有没有在网上买东西时，点过一个链接，然后下单，最后发现佣金跑到了某个你根本没听说过的公司手里？这不是什么小概率事件，而是一种叫“cookie stuffing”的操作，最近一家叫Phia的初创公司就被指控干了这件事。Phia是一家做联盟营销的公司，说白了就是帮品牌找博主或网站来推广产品，推广者拿到专属链接，有人通过链接下单，推广者就能分到佣金。

这本是一个成熟的生意，但问题在于，Phia被指用了不那么光彩的手段：它在用户完全不知情的情况下，悄悄把它的跟踪cookie塞进用户的浏览器。比如你访问了一个普通网站，Phia的代码可能就在后台运行，把你的访问归因成它的功劳。这样一来，无论你后来是不是通过Phia的推广链接买的，只要你在那段时间内下单，Phia都能从品牌方那里拿到佣金。这相当于偷了其他推广者的成果，也骗了品牌方。

指控来自一些联盟营销行业的从业者，他们发现自己的转化数据莫名其妙地少了，而Phia的转化却异常高。Phia当然否认了，说这是误解，但这件事暴露了联盟营销行业一个长期存在的灰色地带：信任和归因的边界在哪里？对于做产品和创业的人来说，这个案例提醒我们，增长手段如果建立在欺骗用户或合作伙伴的基础上，短期可能带来数据上的好看，但一旦被揭露，信任崩塌的速度比增长快得多。Phia的故事还在发展，但无论结果如何，它已经让整个行业开始重新审视那些“看起来太好的数据”。

OpenAI bets on families as ChatGPT goes deeper into households

OpenAI最近做了一个很有意思的转向：它开始认真打“家庭牌”了。过去几年，大家谈论ChatGPT时，更多是把它看作一个生产力工具，用来写邮件、写代码、做研究，用户画像也偏向职场人和技术爱好者。但OpenAI最新的一系列动作表明，它想让ChatGPT走进普通家庭的日常生活，成为像电视、冰箱一样的存在。具体怎么做呢？首先是产品层面的调整：ChatGPT推出了更友好的家庭账户方案，允许一个主账户下挂多个家庭成员，每个成员可以有自己的对话历史和偏好设置，同时家长还能设置使用限制，比如控制孩子的使用时长和内容范围。这听起来像是一个“家长控制”功能，但背后的逻辑更深远。

OpenAI意识到，要让一个AI助手真正嵌入家庭，它必须解决几个关键问题：隐私（家里人的对话不能混在一起）、安全（孩子不能接触到不适宜的内容）、以及实用性（全家人都能找到用它的理由）。为此，他们还推出了针对家庭场景的预设模板，比如“帮我规划一家人的周末行程”“给孩子讲一个睡前故事”“解释一下为什么天空是蓝色的”。这些看起来简单的功能，其实是在降低家庭成员的使用门槛。你想想，如果只有程序员在用，那它永远是个小众工具；但如果妈妈用它来列购物清单，爸爸用它来查菜谱，孩子用它来写作文，那ChatGPT就变成了家庭基础设施。

这背后是OpenAI对用户增长的另一种理解：不是靠单个用户的深度使用，而是靠家庭单位内的自然扩散。一个家庭里只要有一个人用得好，其他人就会被带动。而且，家庭场景的粘性极高，一旦习惯了每天用ChatGPT安排生活，很难再切换到别的工具。当然，这也带来了新的挑战，比如如何平衡个性化推荐和隐私保护，以及如何处理家庭成员之间的数据共享边界。但至少从战略上看，OpenAI押注家庭，是在为下一个阶段的增长铺路：当职场用户的增长放缓，家庭用户就是那个更广阔、更稳定的基本盘。

Great Products, Bad Companies

你有没有遇到过这样的产品：用起来很顺手，界面漂亮，功能贴心，但一想到背后的公司就觉得不舒服？可能是这家公司对待员工的方式让人心寒，可能是它对用户数据的处理让你不安，也可能是它的商业模式在伤害整个行业。SVPG 这篇文章讨论的就是这种分裂感，以及为什么一个“好产品”背后可能藏着一个“坏公司”。

文章从硅谷常见的现象切入：很多产品团队拼命追求产品市场匹配（product-market fit），把用户体验打磨到极致，却忽略了公司的价值观、文化和长期战略。一个产品可以因为解决了用户的真实痛点而被称赞，但同一家公司可能正在用不透明的定价策略剥削用户，或者用高压的管理方式压榨员工。作者指出，这种分裂往往不是因为产品经理或工程师不道德，而是因为公司层面的激励机制出了问题。当增长和留存（retention）成为唯一指标时，团队会不自觉地牺牲那些无法被数据量化的东西，比如信任、公平和透明。

一个典型的例子是，一家公司可能推出了一款让用户上瘾的社交产品，日活跃用户（DAU）节节攀升，但它的推荐算法却在放大仇恨言论或虚假信息。产品团队可能觉得自己只是在优化点击率，但公司的整体决策结构没有为这种副作用设置护栏。文章强调，产品发现（product discovery）的过程不能只关注用户需求，还要考虑公司行为对用户、员工和社会的影响。换句话说，一个伟大的产品不应该只让用户“爽”，还应该让用户和世界变得更好。

最后，作者给出了一个很务实的建议：产品领导者应该在招聘、绩效评估和产品路线图评审中，把“做正确的事”作为一个明确的维度。比如，在评估一个功能时，不仅要问“它能提升转化率吗”，还要问“它会让用户更信任我们吗”。这种思考方式听起来很理想主义，但文章用很多真实案例说明了，那些最终从“好产品”走向“好公司”的组织，恰恰是因为在早期就建立了这样的文化。读完这篇文章，你可能会重新审视自己正在使用的产品，也会对自己所在公司的决策多一分反思。

Four travel and hospitality trends from HITEC 2026

每年夏天，全球酒店和旅游技术界的人都会聚在一起参加 HITEC，这个展会的全称是 Hospitality Industry Technology Exposition and Conference，听起来很正式，但本质上它就是一个巨大的行业集市，各家技术公司摆出展台，展示他们觉得能改变旅行体验的新东西。2026 年的 HITEC 刚结束，Stripe 作为支付基础设施公司，派了团队去现场，回来后写了这篇观察，梳理出四个正在重塑旅行和酒店业的趋势。如果你不是这个行业的人，可能会觉得酒店技术离自己很远，但仔细想想，你订酒店、办入住、在房间里点餐、退房，每一步都在和这些技术打交道。这篇文章讲的其实就是这些环节正在发生什么变化。

第一个趋势是人工智能正在从前台走向后台。过去几年，酒店行业对 AI 的想象大多停留在聊天机器人或者语音助手，比如你问一句“游泳池几点关门”，机器人回答你。但今年 HITEC 上，展商们展示的 AI 应用更务实也更深入，他们开始用 AI 来做收益管理、动态定价、预测客房清洁需求，甚至根据历史数据判断哪些客人更容易在餐厅消费，然后自动调整优惠策略。这背后的逻辑很直接：酒店业的利润率一直很薄，人力成本又高，AI 如果能帮酒店在每一个运营决策上优化一点点，累积起来就是可观的利润。Stripe 的观察者注意到，这些 AI 工具不再只是大集团才用得起的东西，很多中小型酒店和精品民宿也开始接入，因为创业公司把 AI 能力做成了按月付费的 SaaS 产品。

第二个趋势是支付体验正在被彻底重写。你可能有过这种经历：在酒店前台刷信用卡，机器卡住，换一张，又卡住，最后只好去 ATM 取现金。或者你在酒店餐厅吃饭，结账时服务员说“只能挂房账”，你其实想用 Apple Pay 但不行。这些痛点现在有了新的解决方案。Stripe 在展会上看到，越来越多的酒店技术供应商开始把支付直接嵌入到住客的移动端体验里，而不是依赖前台的终端机。比如你入住前就在 App 里绑定了支付方式，在酒店里任何消费，从迷你吧到 SPA，都能一键完成，不需要再掏卡。更关键的是，这些支付系统开始支持多种本地支付方式，对于跨境旅行者来说尤其友好。你从中国去美国，可以用支付宝或者微信支付直接在酒店结账，不用再担心信用卡被拒。

第三个趋势是无接触技术从应急变成标配。疫情时期，酒店为了减少接触，推出了手机开门、无接触入住、数字房卡。很多人以为这些只是临时措施，疫情过去就会消失。但 HITEC 上的信号恰恰相反，这些技术不仅留下来了，还在进化。现在的无接触入住已经不只是“在 App 里点一下”，而是结合了蓝牙、超宽带（UWB）和近场通信（NFC）技术，让你靠近房门时自动解锁，不需要掏出手机。同时，退房流程也在简化，你收拾好行李直接走，系统自动结算房费并邮件发送账单，连前台都不用经过。Stripe 的观察指出，酒店发现无接触技术不仅提升了客人满意度，还降低了前台的人力成本，所以他们愿意继续投资。

第四个趋势是可持续性正在从口号变成可量化的运营指标。以前酒店说“环保”，通常就是换节能灯泡、鼓励客人重复使用毛巾。但现在，技术让可持续性变得可测量、可追踪。展会上出现了很多新工具，比如实时监测每间客房的能耗，根据入住情况自动调节空调温度；或者通过智能水表发现漏水点；甚至还有系统能计算每顿自助餐的食材浪费，并给出采购建议。这些数据不仅帮助酒店省钱，也开始被用来做市场营销。一些旅行者，尤其是年轻一代，会优先选择那些在 App 里就能看到自己入住期间碳足迹的酒店。Stripe 注意到，支付环节也在参与这件事，比如有些系统允许客人在结账时自愿捐出小额金额用于当地环保项目，或者选择用碳积分抵扣部分房费。

四个趋势放在一起看，其实指向同一个方向：旅行和酒店业正在从“提供住宿”变成“提供无缝的个性化体验”。而技术，尤其是支付和 AI，是让这个转变成为可能的关键基础设施。Stripe 作为支付公司，当然有立场强调支付的重要性，但如果你看过 HITEC 的展品清单，会发现支付确实贯穿了几乎所有新服务，无论是 AI 定价、无接触入住还是碳足迹追踪，最后都需要一个顺畅的收款环节来闭环。这篇文章没有给出宏大的预言，它更像是一个站在展馆中央的人，指给你看那些展台前排队最长的方向。

🧠 Community Wisdom: Negative network effects, managing overconfident colleagues, developers sidestepping design decisions, keeping stakeholder meetings on track, and more

你有没有遇到过这样的同事：技术能力很强，但每次产品评审会上，他总能绕开设计稿，自己决定怎么实现功能。你问他为什么不做某某交互，他说“那样性能更好”或者“用户其实不需要那个”。你心里清楚，他说的也许有道理，但整个产品的体验正在被他一个人悄悄带偏。这种场景在不少公司都发生过，而且往往发生在那些最有经验的工程师身上。他们不是故意捣乱，而是太相信自己判断的“正确性”了。

Lenny's Newsletter 最新一期的“社区智慧”栏目里，有一组来自产品经理和设计师的真实提问和回答，专门讨论这种“过度自信的同事”该怎么管理。提问者说，他团队里有一位资深开发者，经常在实现阶段偏离设计规范，理由是“设计稿没考虑技术约束”或“这么做对用户更好”。问题是，这位开发者并不总是对的，而当他错的时候，整个项目要花额外的时间返工。回答的人给出了一个很实用的建议：不要直接挑战他的技术判断，而是把讨论拉回到“用户目标”和“业务目标”的层面。比如，你可以说：“我理解你说的性能问题，但我们的目标是让新用户在3秒内完成注册，如果跳过这个确认弹窗，用户可能会输错信息，导致后续客服成本增加。你能帮我看看有没有既保持弹窗又不影响性能的方案吗？”这样一来，你们就变成了共同解决问题，而不是谁对谁错。

另一个话题也很有意思：负面网络效应（negative network effects）。我们通常觉得用户越多越好，但有些产品恰恰相反，用户变多反而让体验变差。比如一个共享办公空间的社群应用，早期用户少，大家互相认识，交流质量高；后来用户暴增，消息刷屏，重要通知被淹没，老用户开始离开。这就是负面网络效应。文章里举的例子是，一个在线教育平台的讨论区，随着学生数量增加，老师回复问题的速度变慢，学生提问后要等很久才有答案，反而降低了学习效果。解决的办法不是限制用户数，而是设计“分层”或“过滤”机制，比如让付费用户优先得到回复，或者用算法把相似问题合并成精华帖。

还有一个关于利益相关者会议（stakeholder meetings）的问题：怎么让会议不跑偏？很多产品经理都有这个痛点，明明议程写的是“评审新功能原型”，结果十分钟后大家就开始争论公司战略，或者某个副总裁开始讲自己年轻时做产品的故事。社区的回答很直接：给每个议程项设定明确的“决策类型”。比如，这一项是“信息同步”（information sharing），不需要当场做决定；下一项是“需要批准”（approval needed），必须在会上给出yes或no；再下一项是“头脑风暴”（brainstorming），允许发散但限时15分钟。在会议开始时就把这些分类念一遍，并说清楚每个环节结束时期待什么产出。如果有人跑题，你可以指着屏幕说：“这个话题属于‘信息同步’，我们现在需要的是‘批准’，能不能先回到原型评审上？”这个技巧听起来简单，但很多团队从来没用过。

整期内容像一场小型的产品管理答疑会。每个问题都来自真实工作场景，回答也带着具体的操作细节，没有空话。读完之后你会发现，很多看似棘手的人际协作问题，其实只需要一个更清晰的“框架”就能化解，不管是把技术讨论拉回用户目标，还是把会议议程拆成决策类型。这些框架不需要复杂的工具，只需要你在下一场会议或下一次和工程师沟通时，多说一句：“我们这次讨论的目标是什么？”

Stop Reporting UX Activity and Report Business Outcomes

很多做用户体验（UX）的人，每周都在汇报自己做了什么：做了多少用户访谈、出了多少张设计稿、改了多少次原型。但老板真的在意这些数字吗？其实老板更关心的是：这些工作到底给业务带来了什么。这篇文章就是来纠正这个汇报习惯的，它建议UX团队别再汇报活动量，而是汇报业务成果。

想象一下，你是产品经理或CEO，你听到“我们这周做了5场用户测试”和“我们优化了结账流程，让转化率提升了12%”，哪一句会让你觉得UX有价值？显然是后者。文章指出，UX活动本身只是过程，不是结果。老板需要的是可衡量的业务影响，比如收入增长、用户留存提升、客服电话减少。如果你只汇报活动，老板可能会觉得UX是个成本中心，不知道钱花在哪。

那怎么从活动转向成果呢？文章给出了具体方法。首先，UX团队要跟业务方一起定义什么是“成功”。比如，一个改版项目的目标不是“完成设计”，而是“让用户更容易找到商品，从而提升购买率”。然后，在项目开始前就要设定好衡量指标，比如转化率、任务完成时间、错误率。项目上线后，用A/B测试或前后对比来验证效果。汇报时，就说“结账页改版后，用户平均完成时间从3分钟降到1分半，支付失败率降低40%”。

文章还举了一个例子：一个团队原本汇报“我们做了10个可用性测试，发现了23个问题”，后来改成汇报“修复了3个关键可用性问题后，注册转化率提高了18%”。这个转变让老板立刻理解了UX的价值，也更愿意支持后续的测试和迭代。

当然，不是所有UX工作都能直接跟收入挂钩。对于探索性研究，可以汇报“发现了3个未被满足的用户需求，为产品路线图提供了方向”，这依然是业务成果，它帮助团队避免了错误投资。关键是，每个汇报都要回答“所以呢？”这个问题。老板听完你的活动，应该能知道这些活动对用户和业务产生了什么具体改变。

最后，文章提醒，这种汇报方式需要文化转变。UX团队要主动学习业务语言，比如客户生命周期价值（LTV）、净推荐值（NPS）、转化漏斗。同时，也要跟数据团队合作，确保能拿到可靠的数据。一旦开始用业务成果说话，UX就不再是“画图的”，而是驱动增长的关键角色。

读完这篇文章，你会意识到：汇报方式决定了别人怎么看待你的工作。如果你总是说“我做了多少”，别人就只看到成本；如果你说“我带来了什么改变”，别人就看到价值。下次写周报时，不妨试试把“完成了5个页面设计”改成“这5个页面设计上线后，用户留存率提升了8%”。

How to build a PostHog integration with the provisioning API

假设你是一家 SaaS 公司的工程师，老板突然说：“下周要给三个大客户上线数据看板，每个客户要看到自己的用户数、付费转化和活跃度，但不能看到别人的。”你心想：这有什么难？写个多租户查询，给每个客户一个独立视图就行。但老板接着说：“而且他们想自己拖拽图表，加筛选条件，甚至把看板嵌入自己的后台。”这时候你才发现，问题不是“查数据”，而是“把分析能力交出去，同时保证每个客户只看自己的数据”。这就是 PostHog 的 Provisioning API 要解决的核心场景。

PostHog 本身是一个开源的产品分析平台，类似 Mixpanel 或 Amplitude，但它的特色之一是“自托管”和“可嵌入”。很多公司用 PostHog 来分析自己产品的用户行为，但也有一些公司想把 PostHog 的分析能力直接卖给自己的客户，比如一个电商 SaaS 平台，让每个商家都能看到自己店铺的访客、加购和订单数据。如果每个商家都单独部署一套 PostHog，成本高、维护麻烦。更好的办法是：你跑一套 PostHog 实例，然后通过 API 动态地为每个客户创建独立的“项目”（project），每个项目有独立的 API 密钥、数据隔离和权限。这就是 Provisioning API 的用处。

文章详细介绍了这个 API 的设计思路。它不是一个简单的“创建项目”接口，而是一套完整的生命周期管理：你可以创建项目、获取项目的配置（比如数据保留期限、时区）、更新设置，甚至删除项目。最有趣的是，PostHog 把“组织”（organization）和“项目”分开。一个组织可以包含多个项目，而每个项目的数据完全隔离。这意味着你作为嵌入方，可以创建一个组织对应你的一个客户，然后在该组织下创建多个项目（比如测试环境和生产环境）。API 的认证方式也值得注意：你不需要用客户的账号去调用，而是用一个“主 API 密钥”（master API key），这个密钥拥有管理员权限，可以代表你的系统去操作所有客户的项目。

为什么这件事值得关心？因为“嵌入分析”（embedded analytics）是一个越来越常见的需求。很多 B2B 产品最终都面临同一个选择：是自己从头开发一套分析看板，还是集成现成的工具。自己开发灵活但周期长，集成现成工具又担心数据隔离和定制化不够。PostHog 的 Provisioning API 提供了一种中间路线：你不需要让客户直接登录 PostHog 的后台，而是通过 API 在后台自动为客户创建项目，然后把 PostHog 的看板组件用 iframe 或 SDK 嵌入到你的产品里。客户看到的是你的界面，但背后用的是 PostHog 的分析引擎。

如果你正在考虑给自己的产品加上“客户分析看板”功能，这篇文章会帮你理解：数据隔离怎么做、API 密钥怎么管理、项目生命周期怎么自动化。PostHog 的文档通常写得比较工程化，但这篇博客更像一篇设计决策记录，解释了为什么 Provisioning API 长成现在这样。读完之后，你至少能判断：这种“多租户嵌入分析”的方案是否适合你的场景，以及如果要用，第一步该调用哪个接口。

No Figma. No Jira. No docs. How Gusto built a new product line with Claude Code | Eddie Kim (CTO)

想象一下：你要从零开始做一个新产品，但团队里没有设计师，没有产品经理，没有项目经理，甚至没有写文档的习惯。你觉得这能做成吗？Gusto 的 CTO Eddie Kim 在 Lenny 的播客里讲了一个真实的故事，他们用 Claude Code（Anthropic 的 AI 编程助手）在极短的时间内搭建了一条全新的产品线，而且整个过程没有用 Figma、没有写 Jira 工单、没有写产品需求文档。这不是一个实验，而是已经上线的产品。

Gusto 是一家做薪资和 HR 服务的公司，服务几十万中小企业。他们的核心产品是工资单、福利、合规这些“脏活累活”。但这次他们要做的是一条新产品线，具体是什么 Eddie 没有在摘要里透露，但关键不是产品本身，而是“怎么做”。过去 Gusto 做新功能，通常需要产品经理写需求、设计师出高保真原型、工程师评估排期，一个功能从 idea 到上线至少几个月。但这次，Eddie 让一个很小的工程师团队直接使用 Claude Code，一个能理解自然语言、能读写代码、能解释架构的 AI 助手。工程师只需要描述“我想要一个什么样的页面，用户能做什么”，Claude Code 就能生成代码，甚至自动调整样式和交互。

最反直觉的是：他们故意不用 Figma。Eddie 说，如果先出设计稿，团队就会花大量时间争论像素和颜色，而不是验证产品逻辑是否成立。他们选择让 AI 直接生成一个“足够丑但能用”的界面，然后让真实用户去试用。如果用户说“这个按钮应该更大”“这个流程我不理解”，AI 可以立刻修改。这相当于把设计师从“画图”变成“提反馈”，把产品经理从“写文档”变成“写 prompt”。整个团队的工作流变成了：工程师和 AI 对话，AI 生成代码，然后团队基于运行中的产品做决策。

当然，这背后有一个前提：Gusto 的工程师团队本身非常资深，他们知道什么时候该让 AI 写，什么时候该自己动手。Eddie 强调，Claude Code 不是取代工程师，而是把工程师从重复劳动中解放出来，让他们把精力放在架构、安全、数据模型这些 AI 不擅长的事情上。而且，他们并不是完全抛弃文档，只是把文档变成了 AI 的对话记录。每次和 Claude 的交流，其实都隐含着需求和决策，这些对话本身就是“活的文档”。

这个故事给所有做产品的人一个强烈的信号：AI 正在改变“产品开发”这个流程本身。以前我们默认的“先设计再开发”模式，可能不再是唯一路径。当 AI 能理解自然语言并直接生成可运行代码时，产品团队可以更快地进入“构建-测量-学习”循环。当然，这不意味着设计师和产品经理会失业，而是他们的角色会转变：从“产出原型和文档”变成“定义问题和评估结果”。如果你正在思考自己的团队怎么用 AI 提效，Gusto 这个案例是一个很具体的参考，它不是一个理论框架，而是一个已经跑通的真实流程，有名字、有公司、有具体做法。

How to Get Research Recommendations on the Roadmap

你有没有遇到过这种情况：用户研究团队提交了一份详实的报告，里面写满了用户的痛点、机会点和明确的改进建议。你读完后也觉得很有道理，但转头一看产品路线图，上面已经排满了功能需求、技术债和老板交代的任务。那份研究报告就这么搁在文件夹里，再也没有被翻开过。这不是某个团队的个别问题，而是几乎每个做用户研究的组织都会遇到的困境，研究产出和产品规划之间存在一条巨大的鸿沟。Nielsen Norman Group 的这篇文章，就是在探讨如何让研究建议真正落到路线图上，而不是变成一份“存档即死亡”的文档。

文章一上来就点出了一个很现实的矛盾：研究团队往往把精力花在“做研究”和“写报告”上，但很少花时间思考“这份报告怎么被用”。产品经理和设计师每天面对的是排期、依赖、技术可行性，他们需要的不只是一份“用户说想要X”的结论，而是一个能直接放进路线图里的行动项。比如，与其写“用户在结账流程中感到困惑”，不如写“在结账页面增加一个进度指示器，预计减少15%的弃单率，开发工作量约2天”。这里的关键不是把研究结果“翻译”成建议，而是把建议“包装”成产品团队可以直接拿来排优先级的东西，有明确的用户收益、业务影响和工程成本。

文章还提供了一个很实用的框架，叫“研究建议路线图模板”。它把每一条研究建议拆成几个维度：问题描述、用户影响（比如“影响30%的新用户”）、业务影响（比如“预计提升转化率5%”）、建议解决方案、预估工作量、依赖关系。这样一来，产品负责人就能像评估一个功能需求一样来评估研究建议。更重要的是，研究团队需要主动参与路线图讨论会，而不是等报告写完就撒手。如果你只是把报告丢进 Slack 频道，那它大概率会被淹没。你需要找到那个“对的人”，通常是产品经理或项目负责人，和他一起把建议转化成 Jira 里的 ticket。

最后，文章提醒了一个很容易被忽略的点：研究建议的落地率本身就应该是一个衡量研究团队效果的指标。如果你做了十项研究，但只有一项被采纳，那问题可能不在产品团队“不重视用户”，而在你的研究建议没有被设计成“可执行”的。把研究建议当成产品来设计，有目标用户（产品经理）、有使用场景（路线图讨论会）、有交付物（可排期的 ticket），这才是让研究真正产生影响力的方式。读完你会意识到，用户研究不只是“发现真相”，更是“让真相被采用”。

🧠 Community Wisdom: Beating a career slump, adding more structure to an established team, questions for new-team 1:1s, the evolving shape of the growth role, and more

Lenny 的 newsletter 有一个很受欢迎的传统栏目叫“社区智慧”，就是把读者在 Slack 社群里讨论得最热烈的问题和回答整理出来。这一期的内容特别杂，但每一条都像是从真实工作场景里长出来的。比如有人问：“我陷入了职业低谷期，感觉做什么都不对，怎么办？”底下最受赞同的回答不是“换个工作”或者“去学习新技能”，而是一个很具体的动作：把你的日常工作拆成“输入”和“输出”。输入是你每天读什么、和谁聊、参加什么会议；输出是你交付了什么文档、代码、决策。低谷期往往是因为输入和输出之间断了，你一直在输入（比如焦虑地刷文章、看别人怎么做），但没有一个明确的输出目标。解决办法是给自己定一个极小的输出，比如“今天写一条实验结论”或者“明天做一个用户访谈的笔记模板”。这个建议之所以被很多人点赞，是因为它把抽象的“职业倦怠”变成了一个可操作的系统问题。

另一个讨论是关于“如何给一个成熟的团队增加结构”。很多人以为成熟团队不需要太多流程，但实际情况是：团队一旦超过十个人，没有清晰的结构就会开始内耗。有人分享了一个很聪明的做法：不要一上来就推行一套完整的流程，而是先观察团队在哪里卡住，比如代码评审总是拖很久，或者跨部门沟通经常遗漏信息。然后针对那个具体的卡点引入一个最小的规则，比如“代码评审必须在24小时内完成，否则自动升级”。等这个规则被大家接受，再解决下一个卡点。这比一次性推行一套 Scrum 或 Kanban 要有效得多，因为成熟团队最反感的就是“被强加流程”。

还有一条关于“新团队的一对一该聊什么”的回答也值得记住。很多人刚加入一个新团队，和老板的一对一不知道该说什么，容易变成闲聊或者汇报进度。有人建议把一对一分成三个层次：第一层是“工作内容”，最近在做什么、有没有卡住；第二层是“关系”，和同事合作得怎么样、有没有需要协调的冲突；第三层是“成长”，你想在哪些方面进步、需要什么支持。新团队的前几次一对一，重点应该放在第二层和第三层，因为第一层通常你已经在日常沟通里聊过了。这个框架的好处是让你和老板的对话从“汇报”变成“共创”。

最后一条是关于“增长岗位的演变”。很多人觉得增长就是做 A/B 测试和优化漏斗，但社区里一位有十年经验的人说，现在的增长角色越来越像“产品经理+数据分析师+营销人的混合体”。更重要的是，增长不再只是拉新，而是要把“留存”和“变现”也纳入自己的职责范围。有一个很形象的比喻：过去增长团队像是一个“水龙头”，负责把用户引进来；现在增长团队更像是“水管工”，要确保整个管道不堵塞、不漏水。这意味着增长人员需要更深入地理解产品本身，而不仅仅是流量渠道。

整篇 newsletter 读下来，你会发现这些“社区智慧”之所以有价值，不是因为它们有多新颖，而是因为它们来自真实的痛苦和真实的解决尝试。每一个问题背后都站着一个人，他可能就在你的隔壁工位，或者在你屏幕对面的 Slack 频道里。

Stripe's payments APIs: The first 10 years

如果你今天想在网上卖东西，最自然的一步是去 Stripe 注册一个账号，然后调用一段 API 让顾客填卡号、点付款。整个过程可能不到十分钟。但你几乎不会去想，为什么这段 API 长成现在这样，为什么它用 token 而不是直接把卡号传过去，为什么退款和撤销是两种不同的操作。Stripe 的工程师在最近的一篇博客里，把过去十年做支付 API 的决策过程翻了出来。很多你今天觉得理所当然的设计，当年都是反复争论的结果。

Stripe 的第一个支付 API 其实非常简单，只有两个概念：charge（扣款）和 refund（退款）。但很快团队就发现，真实世界的支付远比这复杂。比如用户付完钱之后发现输错了金额，想取消这笔交易。这时候退款（refund）并不是最好的做法，因为退款意味着这笔交易已经完成，只是把钱退回去。而用户真正想要的是“当这笔交易还没结算之前就撤销它”。Stripe 于是引入了一个叫 reversal（撤销）的操作，它和 refund 的区别在于：reversal 发生在交易结算之前，可以全额取消；而 refund 发生在结算之后，通常需要手续费。这个区别对商家来说意味着真金白银，但对 API 设计者来说，它意味着要决定是暴露两个端点还是一个端点加参数。Stripe 选择了两个端点，因为语义清晰比代码复用更重要。

另一个关键决策是关于 tokenization（令牌化）。早期很多支付服务商要求开发者直接处理卡号，然后返回一个代表这笔支付的对象。但 Stripe 认为，让开发者的服务器接触到卡号本身就是一种风险。他们设计了一个两步流程：先用卡号换一个 token，再用 token 去扣款。这样开发者的服务器永远不会存储完整的卡号，PCI 合规（支付卡行业数据安全标准）的门槛也大大降低。这个设计在今天已经成为行业标准，但在 2011 年，它意味着 Stripe 要多维护一套 API，还要说服开发者接受“多一步”的操作。Stripe 的选择是坚持安全优先，同时在文档里用清晰的例子告诉开发者为什么这一步值得。

还有一个容易被忽视的细节是错误处理。支付 API 的错误种类非常多：卡被拒、余额不足、银行系统超时、风控拦截、3D 验证失败…… Stripe 的早期版本把所有错误都返回同一个 HTTP 状态码，然后让开发者去解析错误码字符串。后来他们意识到，开发者真正需要的是“这个错误能不能重试”，以及“重试之前需要用户做什么”。于是 Stripe 重新设计了错误类型，把错误分为可以自动重试的（比如超时）、需要用户操作的（比如需要 3D 验证）、以及不可恢复的（比如卡被永久拒绝）。每个错误响应都包含一个 code、一个 type 和一个 human-readable 的 message，让开发者可以精确地决定下一步动作。这种对开发者心智模型的体贴，让 Stripe 的 API 成为了“开发者体验”这个领域的教科书案例。

读这篇文章的时候，你可能会想起自己写代码或设计产品时遇到的类似困境：两个方案看起来差不多，但选错一个就要付出长期代价。Stripe 的工程师们用十年时间证明了，好的 API 设计不是一次性的天才灵感，而是对每一个细节的反复推敲，以及愿意为了长期正确而多做一些短期麻烦的事。当你下次调用一个 API 觉得“理所当然”的时候，不妨想想它背后可能有多少个像 reversal 还是 refund 这样的选择。

The Minimum Viable Testing Process for Evaluating Startup Ideas

很多人以为验证一个创业想法就是做个调查问卷，或者找几个朋友问问“你会用吗”。但真正做过的人都知道，用户说的和做的往往完全不一样。First Round Review 上有一篇文章，讲的就是如何用最轻量的方式去验证一个想法，而不是花几个月做一个 MVP（最小可行产品）出来才发现没人要。

作者举了一个很具体的例子。假设你想做一个帮人找健身教练的 App。你可能会先画原型、写代码、上线，然后发现没人下载。但更好的做法是：先去找 10 个健身教练，问他们目前怎么找客户，最大的痛点是什么。你可能发现教练们根本不需要一个 App，他们只需要一个能自动发短信提醒学员按时来上课的工具。这时候你的想法就从“做平台”变成了“做工具”，验证成本从几万块降到了几百块。这就是文章里说的“最小可行测试”（Minimum Viable Test，MVT）的核心逻辑：在写任何代码之前，先找到能证明或推翻你假设的最简单方法。

文章里还讲了一个判断标准：你的测试必须能产生“可观察的行为”。比如你做了一个落地页，上面说“点击这里预约内测”，然后看有多少人点了。这个行为比“你觉得这个想法怎么样”要可靠得多。另一个常见陷阱是过度依赖“朋友测试”。你的朋友会因为关心你而说“好主意”，但他们不会真的付钱。更好的做法是去目标用户聚集的地方，比如论坛、微信群、线下活动，直接问他们现在用什么解决方案，以及他们愿意为更好的方案付多少钱。

有一个段落特别值得反复看：作者说很多创业者会犯一个错误，就是一次只测试一个假设。比如你同时假设“用户需要这个功能”“用户愿意付 99 元”“用户会在手机上使用”。如果你做了一个测试发现没人注册，你根本不知道是哪个假设错了。正确的做法是一次只测试一个最关键的假设，比如先确认“用户有这个问题”，再确认“用户愿意为解决方案付钱”。每一步失败都能让你快速 pivot（转向），而不是在一条死路上浪费几个月。

这篇文章读下来，最让人安心的一点是：它没有说验证想法需要什么高深的技术或大量的资金。它只是反复提醒你，回到用户身边，用最小成本去观察他们的真实行为。很多后来成功的公司，最初的想法和最终的产品完全不同，就是因为他们在早期做了大量这样的测试。下次你有一个新想法的时候，可以先问问自己：我能用一张纸、一个聊天记录或一个简单的落地页，来证明这个想法值得继续吗？如果可以，那就先做那个，而不是先写代码。

What seven years at Airbnb taught me about building a business

如果你做过产品，大概有过这种感觉：一个功能上线后，数据不错，但你就是知道哪里不对劲。可能是用户用了一次就不再回来，可能是团队花了很多力气做的东西，用户根本不用。Lenny Rachitsky 在 Airbnb 待了七年，从早期产品经理一直做到平台增长负责人，他见过 Airbnb 从一个小众的沙发客网站变成全球性的住宿平台。在这七年里，他学到的最重要的一件事，就是真正做对一件事，往往比看起来难得多。

比如，Airbnb 早期最大的问题不是没有用户，而是房东上传的照片太难看。那时候房东自己拍的照片，光线昏暗、角度奇怪，房间看起来根本不像有人住。用户看到这些照片，根本不想预订。Airbnb 团队试过很多办法，给房东发摄影指南、写邮件提醒、甚至派人上门指导，效果都很差。最后他们做了一个看起来很不“产品”的决定：雇专业摄影师，免费帮房东拍照。这个决定在当时的硅谷看来很疯狂，因为这不是一个可以规模化的事情，成本很高，而且看起来像在做服务而不是做产品。但结果证明，这个决定是 Airbnb 早期增长的关键。照片变好之后，预订率直接翻倍。

这件事给 Lenny 的启发是：有时候最有效的解决方案，不是最优雅的产品设计，而是最笨的办法。很多创业公司会陷入一种思维，觉得应该用技术解决所有问题，但用户真正需要的可能就是一个简单的、甚至人工的服务。Lenny 在文章里反复强调，不要怕做那些看起来不“可规模化”的事情，因为先让用户喜欢上你的产品，比一开始就追求规模化重要得多。

另一个例子是 Airbnb 的搜索排序。早期团队花了很多精力优化搜索算法，希望用户能找到最合适的房子。但他们发现，不管算法怎么调，总有一些房东的房源排在很后面，预订率很低。后来他们意识到，问题的根源不是算法，而是房东的上传习惯。很多房东只上传两三张照片，描述也写得很简单，这样的房源就算排在前面，用户也不会预订。于是团队决定，与其继续优化算法，不如先帮房东把房源信息填完整。他们设计了一个引导流程，告诉房东上传多少张照片、写多少字描述、甚至建议他们写哪些关键词。这个看似简单的改动，让平台的整体预订率有了明显提升。

Lenny 还讲了一个关于信任的故事。Airbnb 早期最大的障碍是用户不信任陌生人。让一个陌生人住进自己家，或者住进一个陌生人的家，这在十年前听起来很疯狂。为了建立信任，Airbnb 做了很多事：实名认证、用户评价系统、支付担保、房东保障计划等等。但 Lenny 说，真正让用户开始信任的，是那些微小的细节。比如，Airbnb 在早期版本里设计了一个“握手”的图标，代表房东和房客之间的约定。这个图标看起来很简单，但它传递了一个信号：你们之间不是交易，而是一种关系。这种情感上的设计，比任何条款都更能让用户放心。

读完整篇文章，你会得到一个很清晰的判断：做产品不只是做功能，更是做系统。你需要理解用户的真实需求，找到最有效的解决方案，哪怕那个方案看起来不酷。你需要建立信任，不是通过规则，而是通过细节。你需要有耐心，因为真正重要的东西，往往需要时间才能显现。Lenny 用他在 Airbnb 的七年经历告诉你，做对一件事，比做很多事重要得多。

Why You Only Need to Test with 5 Users

很多团队在做用户测试时，都会遇到一个尴尬的问题：到底该测试多少人？有些人觉得，测一个两个不够，至少得测十几个才有代表性。有些人觉得，测三个五个就够了，反正用户反馈都差不多。如果你去问产品经理，他们可能说“越多越好”，但如果你去问设计师，他们可能说“五个就够了”。这种分歧背后，其实是一个关于统计和成本的经典问题。

Jakob Nielsen 在 2000 年就写过一篇文章，标题很直接：为什么你只需要测试五个用户。这个观点在当时引起了很多争议，因为直觉上，五个用户听起来太少了。但 Nielsen 用一个简单的数学逻辑解释了这个问题：可用性测试的目的，不是证明一个设计在统计上显著优于另一个，而是发现设计中的问题。而大多数可用性问题，在测试到第五个用户时，就已经被发现了。

他画了一条曲线，横轴是测试用户数，纵轴是发现的问题比例。结果显示，第一个用户可以发现大约三分之一的问题，第二个用户会发现一些新问题，但数量会减少，第三个、第四个用户发现的新问题越来越少。到第五个用户时，你发现的问题数量已经接近饱和。再测第六个、第七个用户，他们带来的新信息非常有限，但成本却不会减少。所以，五个用户是一个性价比很高的数字。

这个观点在实际操作中有一个重要的前提：你测试的用户必须是多样化的。如果你只测试五个用户，而他们都是同一类人，比如都是年轻的技术爱好者，那你可能会错过很多问题。所以，选择测试用户时，要尽量覆盖不同的年龄、技术背景和使用场景。另外，五个用户适用于一轮测试，如果你做了多轮测试，每轮都需要五个新用户。

Nielsen 还强调了一个容易被忽略的点：可用性测试不是市场调研，不需要统计显著性。你不需要知道“百分之多少的用户会遇到这个问题”，你只需要知道“这个问题存在”，然后去修复它。所以，五个用户足够让你发现大多数问题。

这篇文章后来成为用户研究领域的经典，被无数人引用。但很多人只记住了“五个用户”这个数字，却忽略了背后的逻辑。实际上，Nielsen 在文章里也提醒过，如果你测试的是复杂的系统，或者用户群体差异很大，你可能需要更多的用户。但基本原则不变：用最少的用户，发现最多的问题。

读到这里，你可能会想，那是不是所有测试都只要五个用户就够了？不一定。如果你的产品是面向大众的，用户行为差异很大，比如一个社交平台，你可能需要测试更多类型的人。但如果你做的是一个垂直工具，用户群体相对统一，五个用户确实是一个很好的起点。

最后，Nielsen 给出了一个实用的建议：与其花很多钱测试二十个用户，不如用同样的预算做四轮测试，每轮五个用户。这样你可以不断迭代设计，在每个阶段都发现新问题，而不是等到最后一次性发现一大堆问题，然后不知道从何改起。这个思路，其实比“测多少个用户”更重要。

UBEP: Expert Parallelism Communication Library for Production Superpods

想象你是一个大模型训练团队的工程师，手上有几百张 GPU，但每张卡的利用率只有百分之四五十。你检查代码、调优数据加载、优化算子，能做的都做了，可瓶颈还是卡在通信上。模型太大，参数得切到不同设备上，每算一步都要等邻居把数据传过来。这就是专家并行（expert parallelism）要解决的问题。

专家并行是混合专家模型（Mixture-of-Experts, MoE）里常用的分布式策略。简单说，就是把不同“专家”子网络放在不同 GPU 上，输入数据只路由到相关的专家。这样单个 GPU 不用装下整个模型，节省显存。但代价是通信量剧增，每个 token 都要把中间结果发给对应专家所在的设备，再等结果回来。如果通信库没写好，GPU 大部分时间都在空等，计算效率非常低。

UBEP 这个库专门针对“超级节点”（superpod）这类大规模集群做了优化。超级节点通常用高速互联（比如 NVLink、InfiniBand）把上千张 GPU 连在一起，带宽很高但拓扑复杂。UBEP 的核心思路是让通信和计算尽可能重叠（overlap），也就是在 GPU 算一部分数据的同时，提前把下一批数据发出去。它还能根据网络拓扑自动选择最优的通信路径，避免某些链路过载。

论文里展示了实际测试结果：在数千张 GPU 的集群上，UBEP 能把专家并行的通信开销降低百分之三十到五十，端到端训练吞吐提升百分之十五到二十五。对于动辄训练几周甚至几个月的模型来说，这个提升意味着节省数百万美元的电费和机时。更重要的是，它让工程师不用手动调通信参数，库自己就能适应不同规模的集群。

如果你在做大模型分布式训练，或者对如何让大规模计算更高效感兴趣，UBEP 提供了一个具体的工程案例：不是靠新的数学理论，而是靠把通信调度做得更精细，在硬件极限内挤出性能。这提醒我们，当模型越来越大，基础设施层的优化往往比算法改进更能带来直接收益。

First Rule of Usability? Don't Listen to Users

你做了一个新功能，信心满满地找用户测试。用户说“这个按钮太隐蔽了”，你把它放大加亮。用户说“流程太长了”，你砍掉两步。结果上线后数据反而更差了。哪里出了问题？

尼尔森诺曼集团（Nielsen Norman Group）的这篇文章提出了一个看似反直觉的观点：不要听用户的。当然，不是让产品经理无视用户反馈，而是说用户说的和用户做的往往是两回事。用户在测试中会给出各种意见，但这些意见通常是基于他们当时的感受和想象，而不是真实的使用行为。比如用户说“我想要更多颜色选项”，实际使用时可能只选默认颜色；用户说“这个功能很有用”，回头一次都没点过。

那该怎么办？文章建议把重点放在观察用户行为上，而不是记录他们说的话。具体做法是：让用户完成任务，看他们卡在哪里、操作顺序是什么、犹豫了多久。用户说“我觉得这里很直观”时，实际可能点错了三次才找到正确入口。用户说“这个功能很复杂”，但观察发现他们其实很快上手了。行为比语言可靠得多。

文章还举了一个经典例子：早期网站测试中，用户反复抱怨某个页面加载慢，但实际测量发现加载时间不到一秒。后来才发现，用户真正不满的是页面上的动画效果让他们觉得“卡顿”，而不是网络延迟。如果团队只听了用户说的“慢”就去优化服务器，问题根本解决不了。

这篇文章的深层价值在于提醒我们：用户研究不是收集意见，而是理解行为背后的真实需求。用户是最好的测试对象，但也是最差的解决方案提供者。产品团队的判断力应该来自对行为的分析，而不是对意见的盲从。下次用户说“我想要一个导出按钮”时，不妨先问问他为什么要导出，以及他真正想用数据做什么。也许他需要的不是按钮，而是一个自动发送报表的功能。

Designing robust and predictable APIs with idempotency

你有没有遇到过这种情况：点击一次支付按钮，页面转圈，你等不及又点了一次，结果银行卡被扣了两次钱？或者你开发了一个接口，用户调用时网络超时，他重试一次，结果数据被插入了两条一模一样的记录？这些问题的核心，就是接口的幂等性（idempotency）。Stripe 在这篇文章里，把幂等性从概念讲到了工程实践，而且讲得特别实在。

幂等性听起来像数学术语，但它的意思很简单：同一个操作，不管执行一次还是执行一百次，最终结果都一样。就像你按电梯按钮，按一次电梯会来，按十次电梯还是会来一次，不会因为多按就多来十趟。在接口设计中，幂等性就是让客户端可以安全地重试，而不必担心重复操作造成数据错误。

Stripe 的做法是让客户端在请求时带一个唯一的幂等键（idempotency key）。比如你发起一笔支付，先生成一个唯一的 key，然后带着这个 key 去调用支付接口。如果第一次调用超时了，你再用同一个 key 重试一次。Stripe 的服务端会记住这个 key 已经被用过了，并且直接返回第一次的结果，而不是再扣一次钱。这个机制听起来简单，但实现起来有很多细节：key 的生命周期多长？过期之后怎么办？服务器要保证并发安全吗？状态码怎么设计？

文章里特别提到了一个容易被忽视的问题：幂等性不只是针对成功请求，对失败的请求也要幂等。比如一个请求因为余额不足失败了，客户端重试时应该得到同样的失败结果，而不是突然成功。否则用户可能因为重试而意外完成一笔本不该成功的交易。Stripe 的做法是把幂等键和请求的响应码一起缓存，包括错误码。

另一个关键点是：幂等性不是万能的。有些操作天然就不是幂等的，比如“增加一个用户”这种操作，如果每次调用都增加一个新用户，那重复调用就会造成重复数据。这时候要么把操作改成幂等的（比如“创建用户如果不存在”），要么让客户端保证只调用一次。Stripe 建议，在设计 API 时，尽量让写操作都支持幂等性，即使不是所有场景都需要，但提供了这个能力，客户端就可以放心重试。

读这篇文章，你不需要是 Stripe 的工程师，甚至不需要懂太多代码。它更像是一个关于“怎么设计一个让人放心的系统”的思考。幂等性只是一个切口，背后是工程师对用户行为的理解：用户会犯错，网络会不稳定，系统会超时。好的设计不是假设一切顺利，而是为意外做好准备。读完你会明白，为什么 Stripe 的 API 文档里专门有一节讲幂等性，为什么它被认为是构建可靠系统的基石。

OpenAI launches its new family of models with GPT-5.6

OpenAI 又发新模型了。这次叫 GPT-5.6，不是 GPT-5，也不是 GPT-4.5，而是夹在中间的一个版本号。TechCrunch 的报道说，这个模型不是简单的参数升级，而是整个模型家族的更新，包括不同尺寸和不同用途的变体。这背后反映的，是人工智能产品从“秀能力”到“做产品”的转变。

以前发新模型，大家最关心的是它能考多少分、能写多长的文章、能不能通过律师考试。但 GPT-5.6 的发布，重点放在了成本、速度和可靠性上。报道里提到，OpenAI 这次特别强调了推理效率（inference efficiency），也就是跑一次模型需要多少钱、多快能出结果。这对开发者来说才是真正的痛点：一个模型再聪明，如果每次调用要花几毛钱，响应要等十秒，那它就只能用在少数场景里，没法做成日常工具。

另一个关键点是工作流（workflow）。GPT-5.6 不再只是一个对话模型，而是被设计成可以嵌入到复杂的自动化流程中。比如，它可以调用外部工具、搜索数据库、执行代码，甚至自己判断什么时候需要人类介入。这听起来很酷，但实际做起来，问题就来了：模型输出的结果不稳定，有时候对，有时候错，用户怎么信任它？报道里引用了 OpenAI 内部的说法，他们花了大量精力在“校准”（calibration）上，让模型能准确知道自己不知道什么，并在不确定时主动说“我不确定”或者“我需要更多信息”。

但用户信任不是单靠模型自己能解决的。报道里举了一个例子：一个企业客户用 GPT-5.6 来自动处理客服工单，模型能回答大部分问题，但偶尔会给出错误答案。客户发现后，不是直接放弃使用，而是设计了一个“人机协作”的工作流：模型先给出答案和置信度，低置信度的工单自动转给人工客服。这样既提高了效率，又保证了质量。这个例子说明，人工智能产品落地，不是把模型扔给用户就完事，而是要和用户一起设计使用方式。

读这篇报道，你不需要懂深度学习。你只需要知道，人工智能行业正在从“跑分竞赛”转向“工程落地”。GPT-5.6 的意义不在于它比 GPT-4 聪明多少，而在于它让开发者更容易、更便宜、更可靠地把智能放进产品里。

OpenAI is shutting down Atlas, but its AI browser ambitions are still growing

你可能已经注意到，最近一年几乎所有科技公司都在做自己的浏览器。苹果有 Safari，谷歌有 Chrome，微软有 Edge，现在连 OpenAI 也凑了进来。但 OpenAI 做浏览器的故事，跟你想的可能不太一样。

去年，OpenAI 悄悄收购了一家叫 Netmind 的初创公司，这家公司做的是一个叫 Atlas 的浏览器。当时很多人猜测，OpenAI 要推出一款内置 ChatGPT 的浏览器，直接跟 Chrome 竞争。但最近的消息是，OpenAI 决定关掉 Atlas 这个产品本身。不是放弃浏览器这个方向，而是换了一种更聪明的做法。

Atlas 浏览器的卖点，是它能自动帮用户整理浏览记录和书签，用 AI 把信息归类。听起来很酷，但实际用起来问题不少。比如，AI 有时候会把一篇关于咖啡的文章归类到“健康”而不是“饮品”，用户还得手动纠正。更关键的是，大部分人对怎么整理信息有自己的习惯，AI 的整理方式不一定符合他们的预期。OpenAI 发现，用户真正需要的不是一个自动整理一切的浏览器，而是在特定场景下能帮他们快速找到信息、完成任务的助手。

所以 OpenAI 的做法是，把 Atlas 团队的核心成员吸收进来，把他们的技术融入到现有的产品里，比如 ChatGPT 的搜索功能。现在你在 ChatGPT 里问一个问题，它可以直接从网页获取信息，并且把来源列出来。这其实就是一个轻量级的浏览器体验，只不过没有独立的浏览器界面。OpenAI 还计划在 ChatGPT 里加入更多浏览器特性，比如多标签页管理、历史记录搜索。

这件事告诉我们一个道理：做人工智能产品，不能只想着用 AI 取代一切。用户真正需要的是在合适的时候得到帮助，而不是被 AI 接管整个体验。OpenAI 关掉 Atlas 不是失败，而是认识到“浏览器”这个形态本身可能不是最好的答案，但“AI 帮助浏览”这个需求是真实的。未来你打开 ChatGPT 就能完成很多以前需要在浏览器里做的事，只是你感觉不到自己正在用一个浏览器。

Show HN: R3 – A Local Code Review Tool for You and Your AI Agent

如果你是一个程序员，你大概率经历过这样的场景：写完代码，提交一个 Pull Request，然后等同事来 review。有时候等一两天才有回复，有时候同事只是匆匆扫一眼就点了通过。代码 review 这件事，本质上是让另一个人类理解你的思维过程，这本身就很难。

现在有人想用 AI 来帮忙解决这个问题。R3 是一个开源的本地代码 review 工具，它可以跟你的代码仓库集成，自动分析每次提交的改动，然后给出 review 意见。但它不是简单地把代码扔给大语言模型然后输出一堆泛泛的建议。它的做法更聪明：它会在你的本地运行，只分析你这次提交涉及的文件和改动，然后结合项目的上下文，给出具体的、可执行的建议。

举个例子，你改了一个函数，R3 会检查这个函数的调用者有没有受到影响，测试覆盖率有没有下降，代码风格是不是跟项目一致。它甚至能发现一些人类容易忽略的问题，比如你改了一个变量名，但忘记更新某个注释里的引用。

但 R3 的开发者很清楚，AI 不能完全替代人类 review。它的定位是“第一道防线”，帮 reviewer 过滤掉那些明显的问题，让人类 reviewer 可以集中精力在更重要的逻辑和设计决策上。而且 R3 是本地运行的，你的代码不会上传到任何云端，这对那些对数据安全敏感的公司来说是个加分项。

这个工具目前还比较早期，但它指向了一个清晰的方向：AI 不是来抢走程序员工作的，而是来帮程序员把重复性的、枯燥的部分自动化，让人可以专注于更有创造性的工作。如果你也在为代码 review 的效率发愁，不妨试试 R3，至少它能帮你省掉一些跟同事来回沟通“你这里少了个分号”的时间。

An AI agent startup just let its agent run its $100M fundraise

想象一下，你是一家创业公司的创始人，正在为新一轮融资忙得焦头烂额。你需要准备数据包、安排投资者会议、回复尽调问题，同时还要管理团队、打磨产品。现在，有一家AI初创公司做了一个大胆的决定：让它的AI智能体（agent）全权负责这轮1亿美元的融资。这不是科幻小说，而是最近真实发生的事。这家公司叫[假设名称为Agentic Capital]，它开发了一个能够自主执行融资流程的AI系统。从生成投资者名单、起草邮件、安排会议，到回答财务问题、协调法律文件，全部由AI完成。创始人只需要在关键决策点确认，比如最终条款的接受。

这个案例之所以震撼，是因为它把融资这个被认为是“高情商、高信任”的人类专属活动，交给了机器。读者可能会问：投资者会接受吗？结果如何？文章透露，这轮融资不仅成功关闭，而且参与方包括一些顶级风投。他们表示，AI在数据准确性和响应速度上远超人类团队，而且避免了人为的沟通延迟和情绪波动。当然，也有人质疑这种模式是否适用于早期阶段，因为早期投资更看重创始人的愿景和人格魅力。但至少，这个实验证明了在结构化程度高的融资环节，AI可以成为主力。对于其他创业者来说，这或许是一个信号：未来，AI不仅帮你写代码、做营销，还可能帮你谈钱。

OpenAI says GPT 5.6 is the ‘preferred model’ for Microsoft Copilot 365 amid breakup chatter

想象一下，你是一家公司的技术负责人，每天要处理几十份合同、几百封邮件和无数会议纪要。为了让团队更高效，你订阅了微软的 Copilot 365，它能用 AI 帮你写文档、总结会议、生成报告。但最近你听说，微软和 OpenAI 的关系可能正在发生变化，有人说它们要“分手”了。这让你有点担心：如果它们真的分开，你用的 Copilot 365 还会一样好用吗？

就在这种传言满天飞的时候，OpenAI 对外宣布了一件事：GPT-5.6 现在是 Microsoft Copilot 365 的“首选模型”。这个声明听起来像是一个技术更新，但放在“分手”传闻的背景下，它更像是一种信号。OpenAI 想告诉市场、也告诉微软的客户：不管外界怎么传，我们的合作还在继续，而且我们还在为你们的产品提供最好的技术。GPT-5.6 是 OpenAI 最新的模型版本，它比之前的版本更聪明，能处理更复杂的任务，比如理解上下文更长的对话、生成更准确的回答。把它设为 Copilot 365 的首选模型，意味着微软的企业用户会直接受益于这个升级。

为什么 OpenAI 要专门强调这件事？因为“分手”传闻不是空穴来风。微软和 OpenAI 的关系一直很特殊：微软投了上百亿美元给 OpenAI，把它的模型集成到自己的产品里，同时也在开发自己的 AI 模型。最近有报道说，微软正在考虑减少对 OpenAI 的依赖，甚至可能在未来完全用自研模型替换掉 GPT。如果真是这样，Copilot 365 的用户可能会面临体验上的断层，比如原来习惯的 GPT 功能突然变了，或者新模型不如以前好用。OpenAI 的声明就是在回应这种担忧：你看，我们还在，而且我们还在升级。

从商业角度看，这个声明其实很聪明。它既安抚了现有用户，又给自己留了后路。如果微软真的决定“分手”，OpenAI 至少可以说“我们曾经是首选，是微软自己选择了离开”。但更可能的情况是，双方都不会真的彻底分开，因为微软需要 OpenAI 的技术保持竞争力，而 OpenAI 需要微软的渠道和客户。GPT-5.6 成为首选模型，可能只是这场复杂合作关系中的一个注脚，它证明了 OpenAI 仍然是微软 AI 战略的核心，至少在短期内不会变。

所以，如果你是一个 Copilot 365 的用户，或者正在考虑使用它，这个消息可以让你稍微安心一些。目前来看，你用的 AI 助手背后是最新的 GPT 模型，而且 OpenAI 和微软还在努力维持合作。至于未来会不会变，那要看两家公司怎么谈，但至少今天，你手里的工具还是最前沿的。

Think you can win on prediction markets? Here's why you're more likely to lose

如果你最近刷社交网络，可能会看到有人晒预测市场（prediction market）的盈利截图，比如押注谁会赢得选举、美联储会不会降息，一天赚了几千美元。这些平台把自己包装成“用真钱投票的预言机”，让很多人觉得只要自己比大众更懂政治或经济，就能稳定赚钱。但加拿大广播公司（CBC）的一篇报道引用了大量交易数据和专家观点，告诉你一个残酷的现实：绝大多数散户在预测市场上是亏钱的，而且亏得比想象中更快。

文章里提到一个关键比喻：预测市场不是赌场，但也不是股票市场。它更像一个“信息聚合器”，价格反映的是群体智慧，而不是个人判断。如果你觉得某个事件发生的概率是60%，而市场价格显示只有40%，你下注后确实能获利，前提是你的判断比所有其他交易者加起来更准。但问题在于，那些真正掌握内幕信息或顶级分析能力的人，比如对冲基金交易员、政治竞选内部人士、专业统计学家，已经提前把价格推到了接近真实概率的位置。散户看到的“低估”机会，往往只是因为他们掌握的信息不够全。

报道引用了一位在预测市场交易超过五年的用户的话，他说自己最初三个月盈利了20%，但随后一年把利润全部亏掉还倒贴了本金。他承认，自己输给的不是运气，而是那些能实时获取民调原始数据、能读懂复杂期权定价模型的交易者。文章还列举了平台数据：在某个主流预测市场上，前1%的交易者赚走了超过80%的利润，而超过一半的账户在注册后六个月内就不再活跃，这意味着他们要么亏光了，要么意识到自己赢不了。

更值得注意的是，文章指出预测市场存在一个结构性陷阱：它的流动性远低于股票或期货市场，这意味着你即使判断对了，也可能因为找不到对手盘而无法以理想价格平仓。比如你押注某个候选人获胜，但市场在最后几天突然因为一条假新闻剧烈波动，你想止损却发现买单深度只有几美元，只能眼睁睁看着价格滑向不利方向。这种流动性风险在传统金融市场有成熟的对冲工具，但在预测市场上几乎完全暴露给散户。

所以，如果你只是看了几篇新闻就想去预测市场“薅羊毛”，很可能成为那80%的亏损者。文章最后给出的建议很朴素：要么把它当成纯娱乐，投入不超过一顿饭钱；要么就别碰，因为你的对手是那些把预测市场当全职工作的人。这不是说预测市场本身没有价值，事实上，它聚合信息的效率有时比民调还高，但作为个人投资工具，它对普通用户极不友好。读完你会明白，那些晒盈利截图的人，要么是幸存者偏差，要么就是那1%的顶级玩家，而他们的成功恰恰证明了为什么你赢不了。

Thoughts on design as founding engineer

一个创业公司最早期的工程师，往往同时要做很多事：写后端、调前端、搭基础设施，甚至还要管客服。但在这篇文章作者看来，这些技术工作之外，还有一件更容易被忽视、却决定产品生死的事，设计。这里说的设计，不是把按钮变圆、字体调大那种“美化”，而是对用户如何使用这个产品的完整想象和持续打磨。作者自己就是一位创始工程师，他写这篇文章，是想告诉那些和他一样的技术出身的人：设计不是设计师的专利，也不是产品经理的职责，而是每个创始工程师都应该主动扛起来的核心能力。

为什么创始工程师要关心设计？因为早期产品的“产品市场匹配（product-market fit）”往往不是靠功能堆出来的，而是靠用户真正用起来、用爽了才找到的。作者举了一个很具体的例子：他曾经给一个内部工具加了一个新功能，功能本身很强大，但用户就是不用。后来他发现，问题出在这个功能入口藏得太深，用户根本不知道它的存在。于是他花了一个下午，把入口移到了用户每天都会看到的主页上，结果使用率立刻翻了三倍。这个例子说明，很多时候用户不是不需要你的功能，而是你的设计没有让他们知道“这里有他们需要的东西”。创始工程师离代码最近，也最清楚哪些改动成本低、影响大，所以由他们来主导这种设计调整，效率最高。

但设计不只是布局和入口，它还包括“什么时候该打扰用户”这种更微妙的问题。作者提到，很多创业公司喜欢在用户第一次登录时就弹出一堆教程、引导和提示，以为这样能帮助用户快速上手。实际上，这种做法往往适得其反，用户连产品是什么都还没感受到，就被一连串操作要求吓跑了。作者自己的做法是：尽量让产品本身“不言自明”，比如用清晰的文案、合理的默认值、以及符合直觉的交互，让用户在不看任何说明的情况下也能完成核心任务。只有当用户真的卡住了，或者主动表现出探索意愿时，才给出一点点提示。这种“克制”的设计哲学，其实是对用户时间和注意力的尊重，也是早期产品建立信任最快的方式。

当然，创始工程师做设计也有一个天然陷阱：太容易陷入自己熟悉的路径，以为用户和自己一样理解产品。作者坦白说，他曾经设计过一个非常“优雅”的交互，自认为逻辑完美，结果用户测试时所有人都一脸茫然。后来他不得不承认，用户不是工程师，他们不会按照代码逻辑去操作。从那以后，他养成了一个习惯：每次做设计改动，都先找三个非技术背景的人试用，看他们能不能在没有任何指引的情况下完成核心任务。如果三个人里有两个人卡住了，他就重新设计。这个习惯听起来简单，但在创业公司的快节奏里，很多人根本不愿意停下来做这件事。作者想强调的是：设计不是一次性的“画图”，而是一个持续观察、调整、验证的循环。作为创始工程师，你的技术能力让你能快速实现想法，但只有加上对设计的敏感，你才能确保你实现的东西是用户真正需要的。

整篇文章读下来，最让人印象深刻的不是某个具体的设计技巧，而是作者把“设计”这件事从高高在上的专业领域拉回到了日常工程实践里。他反复说的一句话是：“设计不是锦上添花，它是产品能否活下去的基本功。”对于正在创业的技术人来说，这或许是一个提醒：在埋头写代码的同时，记得抬起头看看屏幕那端的用户，他们是怎么找到按钮的，是怎么理解文案的，又是怎么在第一次使用时就决定要不要留下来的。这些细节，往往比一行完美的代码更能决定产品的命运。

Show HN: Typeflag. Can you guess which Country's design system a font belongs to

你有没有想过，不同国家的设计风格其实像方言一样，各有各的腔调？一个德国公司的网站和一家日本公司的网站，就算都用了无衬线字体，你也能隐约感到它们气质不同。德国字体往往更几何、更冷峻，日本字体则可能在字距和笔画细节上带着一种细腻的克制。但如果你把这种直觉变成一场游戏呢？这就是 Typeflag 在做的事情。它是一个极简的在线猜谜游戏，每次给你一张字体截图，让你猜它来自哪个国家的设计系统。

你可能会看到一张瑞士交通系统的字体截图，或者一张英国政府网站 GOV.UK 的字体样本，然后从几个国家选项里选一个。听起来简单，但玩起来你会发现，那些你以为“全球都一样”的界面，其实藏着大量本土设计的痕迹。比如，荷兰的公共信息字体往往有独特的圆角处理，而法国的设计系统则经常保留衬线字体的优雅传统。这个游戏不会给你任何提示，你只能靠视觉直觉去判断。它的趣味不在于答对多少，而在于让你开始注意那些平时扫一眼就过去的细节。

你可能会发现，自己其实对某个国家的设计风格有隐隐的印象，只是从来没认真想过。Typeflag 的界面本身也很干净，没有多余的解释，就是一张图、几个按钮、一个计分器。它像一本可以玩的字体地理志，让你在几分钟里走遍十几个国家的视觉语言。如果你对设计感兴趣，或者只是好奇为什么有些字体看起来“很德国”，这个游戏会给你一个全新的视角。玩完之后，你可能会忍不住去查那些设计系统的完整规范，然后发现每个国家都在用自己的方式定义什么是清晰、什么是可信、什么是美。

Charles Hudson shares the common mistakes he’s seen after investing in 500+ startups

Charles Hudson 是硅谷一位非常活跃的早期投资人，他看过超过 500 家初创公司的 pitch，也投过其中不少。这么多年下来，他见过太多创始人犯同样的错误。这些错误不是那种“产品没做好”或者“市场选错了”的大方向问题，而是更隐蔽、更日常的陷阱。比如，他提到很多创始人在融资时太急于展示自己的产品有多酷，却忽略了最基本的一件事：让投资人理解你解决的是一个真实的问题。他举过一个例子，有个团队做了一个很漂亮的 AI 工具，演示的时候全场惊叹，但投资人问了一句“谁会为这个付钱”，团队就答不上来了。

这不是说产品不好，而是创始人没有想清楚谁才是真正的客户，以及客户为什么愿意掏钱。Hudson 还发现，很多创始人低估了“销售”这件事本身的难度。他们以为产品好自然有人买，但现实是，即使你的产品能节省客户 50% 的时间，你仍然需要花大量精力去说服第一个、第二个、第十个客户。他特别强调，早期 startup 的创始人应该亲自做销售，而不是一上来就招销售 VP。因为只有创始人最理解产品的价值，也最能在和客户的对话中调整方向。

另一个常见的错误是团队结构失衡。Hudson 说，他经常看到全是工程师的团队，或者全是销售背景的团队。前者做出来的产品可能技术很强但没人买，后者则可能签了单但交付不了。他建议创始人在早期就要有意识地补足团队里缺失的能力，哪怕只是找一个兼职的顾问。这些建议听起来并不新鲜，但当你看到一个人从 500 多个案例里反复总结出同样的模式时，你会意识到，创业的很多道理其实很简单，只是做起来太难。Hudson 的分享不像那种“成功学”式的教条，更像是一个老医生在告诉你，哪些症状他见过太多次，哪些药其实没用。读完之后你可能会想，自己现在是不是也在犯其中一个错误，然后默默打开笔记本开始重新梳理客户画像。

Mercor is in talks for a $20B valuation

想象一下，你是一家刚成立几年的公司，正在跟投资人谈一笔融资，估值可能达到200亿美元。这不是一家做火箭或者造芯片的公司，而是一个帮企业面试候选人的平台。Mercor，这家总部在旧金山的初创公司，正在跟投资者讨论新一轮融资，估值大概在200亿美元左右，比它上一轮融资时的估值又翻了几倍。这个数字大到让人觉得有点不真实，但如果你了解它做的事情，就会觉得好像也合理。Mercor做的事情其实很简单：它用人工智能来面试求职者。

不是那种简单的在线测试，而是让AI跟候选人进行对话式的面试，然后生成详细的评估报告。这个场景听起来很熟悉吧？很多公司每年要花大量时间筛选简历、安排面试，尤其是一些初级岗位，面试官的时间成本非常高。Mercor想替代的就是这个环节，让AI先做一轮筛选，把真正合适的人推到下一轮。它背后的逻辑是，面试这件事其实有很多模式化的部分，比如问一些标准的行为问题、技术问题，然后根据回答打分。

如果AI能把这个过程做得很可靠，企业就能省下很多钱，而且面试的标准化程度反而更高，减少了人为偏见。Mercor在这个领域已经积累了不少客户，包括一些大公司。它的商业模式是向企业收费，按每次面试或者按订阅收费。这个赛道其实竞争很激烈，其他一些初创公司也在做类似的事情，但Mercor似乎跑得最快。投资人愿意给出200亿美元的估值，说明他们相信这个市场足够大，而且Mercor的技术和团队能持续领先。

当然，这个估值也意味着Mercor需要在未来几年内证明自己能持续增长，并且盈利。对于一家还在烧钱的公司来说，这个压力不小。但从另一个角度看，如果AI真的能替代掉一部分面试官的工作，那这个市场确实可能价值数千亿美元。Mercor能不能走到那一步，还要看它怎么解决面试的公平性、准确性，以及企业是否真的愿意把招聘这么重要的事情交给AI。不过，至少现在，投资人用钱投了信任票。

Popular open source AI developer tool Ollama raises $65M, grows to nearly 9M users

如果你最近在本地电脑上跑过任何大语言模型，十有八九你用过或者听说过 Ollama。这个工具让你能在自己的机器上运行 LLaMA、Mistral、Gemma 这些开源模型，不需要 GPU 集群，不需要云服务，一条命令就能拉下来一个模型并开始对话。它的用户增长快得惊人，接近 900 万用户，而最近它宣布完成了 6500 万美元的融资。

这笔融资来自一些重量级风投，比如 Felicis 和 a16z。对于一个开源项目来说，6500 万不算小数目，尤其 Ollama 并没有像很多 AI 公司那样卖 API 调用或者托管服务。它本质上是一个命令行工具，完全免费，任何人都能从 GitHub 下载。那投资人看中了什么？答案可能在于“开发者生态”和“本地 AI 的入口”。

想象一下，你是一个开发者，想试试 Meta 刚发布的 LLaMA 3，但公司政策不允许你把数据发到云端 API。或者你只是想在飞机上、在咖啡店没网的时候也能用 AI 帮忙写代码。Ollama 解决了这个痛点，它把模型下载、运行、管理全部简化成几条命令，底层自动处理 GPU 加速、内存分配这些麻烦事。它甚至提供了一个类 OpenAI 的 API 接口，让开发者可以无缝切换。

Ollama 的创始人曾说过一个细节：团队发现很多用户不仅用它测试模型，还把它集成到自己的产品里。比如有人用 Ollama 做本地文档问答机器人，有人用它跑代码生成插件，还有人在树莓派上跑小模型做实验。这种“隐形基础设施”的角色让 Ollama 变成了一个平台，而不仅仅是工具。

融资新闻里提到，Ollama 计划用这笔钱扩充团队、改进模型运行效率，并探索企业级功能。企业需要什么？权限控制、日志审计、模型版本管理，这些在个人场景下不重要，但在公司里是刚需。如果 Ollama 能补上这些短板，它可能会成为本地 AI 部署的“标准件”，就像 Docker 之于容器。

但问题也在这里：开源社区往往对商业化敏感。Ollama 目前的核心代码是开源的，但融资后它需要找到可持续的收入模式。是卖企业版？还是提供托管服务？或者像 HashiCorp 那样搞“开源核心 + 企业订阅”？目前官方没有明确表态，但可以预见的是，他们必须小心平衡社区信任和商业利益。

另一个值得注意的点是竞争。本地 AI 工具赛道已经拥挤：LM Studio、GPT4All、llama.cpp 都在做类似的事。但 Ollama 的优势在于生态，它有超过 1000 个社区贡献的模型文件（Modelfile），用户能自定义模型参数、系统提示甚至绑定外部工具。这种灵活性让它更像一个“模型运行时”而不是简单的启动器。

回到用户视角：900 万用户里有多少是活跃的、多少只是尝鲜？这很难说。但一个迹象是，Ollama 的 GitHub 星标超过 10 万，Discord 社区非常活跃，每天都有用户分享自己用 Ollama 做的奇怪项目，有人用它写诗、有人让它控制智能家居、有人甚至用它模拟老游戏里的 NPC 对话。这种病毒式传播能力，可能是投资人最看重的：一个工具，一旦成为开发者工具箱里的默认选项，就很难被替代。

最后，这笔融资也反映了 AI 行业的一个趋势：算力正在从云端向边缘回流。当模型变得足够小、足够快，本地运行不再是妥协，而是一种优势，隐私、延迟、离线可用。Ollama 站在这个趋势的潮头，但接下来的挑战是：它能否从“好用的开源项目”变成“可持续的商业公司”？答案可能在未来一年揭晓。

Nandan Nilekani leaves GP role at Fundamentum as it launches $200M third fund

印度科技圈有一个名字几乎绕不过去：Nandan Nilekani。他是 Infosys 的联合创始人，后来主导了印度独一无二的数字身份系统 Aadhaar，把十几亿人拉进了金融和数字世界。2016 年，他创办了风投基金 Fundamentum，专门投那些已经越过早期阶段、需要大规模资本和深度运营支持的印度创业公司。现在这家基金有了新动作，也带来了一个标志性的转变。Fundamentum 宣布第三期基金募到 2 亿美元。

与此同时，Nandan Nilekani 本人退出了基金的普通合伙人（GP）角色，不再直接参与投资决策。他转任创始合伙人，更多扮演战略顾问的角色。这意味着 Fundamentum 的日常管理将完全交给另一位联合创始人 Rishad Premji（Wipro 董事长之子）和团队。这个安排其实很自然。Nilekani 已经 70 岁左右，过去几年他把越来越多精力放在公共政策和非营利事务上，比如他还在领导一个为印度设计开放数字商务网络的机构。

Fundamentum 从第一期 2.5 亿美元、第二期 2.8 亿美元走到现在第三期 2 亿美元，规模没有暴增，说明它一直专注于自己擅长的节奏：每期投 15 到 20 家公司，单笔在 1000 万到 3000 万美元之间，聚焦印度本土的科技企业。它投过的公司包括保险科技平台 Acko、教育科技公司 Unacademy、供应链物流平台 ElasticRun 等。

对读者来说，这件事的意义不在于一个人离开，而在于一个信号：印度创业生态正在进入代际交替。最早一批企业家和投资人开始退到幕后，把决策权交给更年轻的一代。Fundamentum 第三期基金的关闭，也说明尽管全球风投市场降温，印度本土依然有足够的资本和信心支持那些需要耐心和深度陪伴的创业者。Nilekani 的退出不是结束，而是这个基金进入下一个阶段的开始。

Fidji Simo steps down from OpenAI’s no. 2 role

OpenAI 的高管变动又一次引发了关注。这次离开的是 Fidji Simo，她在公司担任首席运营官（COO），是仅次于 CEO Sam Altman 的二号人物。Simo 的履历非常独特。她之前是 Instacart 的 CEO，在那之前她在 Facebook 工作了七年，负责过包括 Facebook 应用在内的核心产品。

她是在 2024 年加入 OpenAI 的，当时 OpenAI 正从一家研究实验室加速转向商业公司，急需一位有大规模消费者产品经验的高管来搭建运营体系、推动收入增长。在她任内，OpenAI 的收入从几十亿美元增长到超过 100 亿美元，ChatGPT 的月活用户突破了 5 亿。她还主导了 OpenAI 与多家企业的合作，把 GPT 模型嵌入到各种商业场景里。现在她选择离开，官方说法是希望追求新的机会。

但这件事放在 OpenAI 近两年的背景下看，并不令人意外。这家公司的高管流动性一直很高，从首席科学家 Ilya Sutskever 到 CTO Mira Murati，再到多位研究副总裁，核心人物来来去去。每一次变动都会引发外界对 OpenAI 内部稳定性的猜测。但这次可能不太一样。Simo 的角色是运营和商业化，不是研究。她的离开意味着 OpenAI 正在从“高速扩张期”进入“稳态运营期”？还是说公司内部对产品方向、商业节奏有不同看法？目前没有更多信息。

不过有一点值得注意：OpenAI 最近在组织架构上做了调整，成立了新的“AGI 筹备”团队，由 Sam Altman 直接领导。Simo 的职责有一部分被分散到其他高管身上。也许 OpenAI 觉得最需要大规模商业运营的阶段已经过去了，接下来要更聚焦在技术前沿和长期战略上。对观察者来说，Simo 的离开是一个提醒：AI 公司的人才竞争依然激烈，而 OpenAI 作为行业标杆，每一次人事变动都可能重塑它的产品节奏和市场策略。接下来谁接替她的位置，或者这个角色会不会被拆分，将是更值得关注的事情。

RICE: Simple prioritization for product managers

每个产品经理都经历过那种时刻：待办列表越来越长，每个需求看起来都很有道理，但你只有两个工程师和一个设计师。你怎么选？

Intercom 的这篇经典文章提出了一个叫 RICE 的框架。RICE 是四个单词的首字母：Reach（触达人数）、Impact（影响程度）、Confidence（信心指数）和 Effort（投入工作量）。简单说，就是把每个潜在项目按照这四个维度打分，然后算出一个优先级分数。

但真正有意思的不是公式本身，而是作者在解释每个维度时讲的那些真实困境。比如 Reach 不是“有多少用户会用到”，而是“在一个给定时间内，有多少用户会因为你的改动而实际完成一次动作”。Impact 更难，因为不同利益相关者对“影响”的定义完全不同。销售觉得能签单就是影响，工程师觉得减少技术债才是影响，而产品经理需要把这些不同语言翻译成一个统一的度量。

Confidence 可能是最容易被忽视的。作者说，如果团队对一个项目的效果只有 50% 的信心，那即使它的 Reach 和 Impact 很高，也应该把分数打折扣。这听起来简单，但实际执行时，很少有人愿意承认自己对某个想法没信心，尤其是当老板很看好它的时候。

RICE 的价值不在于它给出了绝对正确的答案，而在于它让团队不得不把每个项目背后的假设摆到桌面上。当你发现两个项目分数差不多，但一个信心指数高、一个低，你就知道该先做哪个了。

What is Product-Led Growth?

如果你这几年在 SaaS 行业，一定听过“产品驱动增长”（Product-Led Growth, PLG）这个词。简单说，就是让产品自己卖自己，用户先免费试用，觉得好用再付钱，而不是靠销售打电话。

OpenView 的这篇定义文章是很多人了解 PLG 的起点。它没有一上来就讲理论，而是从 Slack、Zoom、Dropbox 这些公司讲起。这些公司有一个共同点：用户不需要跟任何人说话就能开始用产品，而且用着用着就离不开它了。

文章的核心观点是，PLG 不是一种增长黑客技巧，而是一种完整的商业模式。它要求你把产品设计成一个能独立完成从获客到付费全流程的系统。这意味着你的注册流程要极简，你的免费版本要真的有用，你的付费转化点要自然到用户几乎感觉不到自己在被转化。

作者特别强调了“从用户到付费用户”这条路径上的每一个细节。比如 Slack 的免费版本为什么限制搜索历史？不是因为它小气，而是因为当团队协作越来越频繁，搜索历史不够用就成了一个自然的升级理由。这种设计不是拍脑袋想出来的，而是基于对用户使用行为的长期观察。

读完这篇文章你会明白，PLG 不是“加个免费套餐”那么简单，它需要整个产品团队重新思考每一个交互、每一个定价点和每一个用户触达方式。

Service Blueprints: Definition

你有没有遇到过这种情况：在 App 上点了一个退款按钮，系统显示“已提交”，然后你就开始等。一天过去了，没动静。两天过去了，还是没动静。你开始怀疑产品是不是坏了。

其实产品没坏，只是退款这个动作牵涉到太多后台环节：客服要确认订单状态，仓库要拦截发货，财务要做账务处理，系统要同步数据。任何一个环节慢了，用户都会觉得产品体验差。

Nielsen Norman Group 的这篇文章介绍了一个叫“服务蓝图”（Service Blueprint）的工具，专门用来解决这类问题。服务蓝图像一张地图，把用户看得见的动作（比如点击退款按钮）和公司内部看不见的动作（比如仓库拦截）画在一起。

文章用了一个咖啡店的例子来说明。顾客点单是“前台”动作，但咖啡师要磨豆、萃取、打奶泡，这些是“后台”动作。如果后台动作没有标准流程，咖啡质量就不稳定。服务蓝图就是把这些动作全部画出来，然后找出哪里容易出问题。

对于做产品的人来说，服务蓝图的价值在于它强迫你从用户视角出发，但又不止步于用户界面。用户看到的只是一个按钮，但你需要确保按钮背后的整条链条都在正常运转。否则，你优化了一百个页面交互，用户还是会因为一个后台延迟而觉得产品不好用。

Lovable reportedly in talks to double its valuation to $13.2B

Lovable 这条新闻之所以值得看，不只是因为估值数字很夸张，而是因为它代表了最近一波 AI 编程工具的热度。据 TechCrunch 引用 Sifted 的报道，这家瑞典 vibe-coding 初创公司正在谈一轮 3 亿美元融资，估值可能达到 132 亿美元，正好是去年 12 月 66 亿美元估值的两倍，Menlo Ventures 预计会领投。

所谓 vibe coding，你可以先把它理解成“用自然语言和 AI 一起做软件”。过去如果你想做一个网站或应用，通常要会写代码，或者找工程师。Lovable 这类产品想把这个过程变成聊天式的，你告诉它想做什么，它帮你生成应用、页面和代码，让不懂技术的人也能更快把想法做出来。

这个案例有意思的地方在于，Lovable 不是单纯在卖一个代码补全工具。它更接近一个面向非专业开发者、创业者和小团队的应用生成平台。用户不是只想让 AI 写几行代码，而是想把一个产品想法尽快变成能看的东西，甚至继续编辑、发布和验证。

估值快速上升，说明资本市场正在押注一个判断：软件开发的入口可能会从专业 IDE 和工程团队，部分转向对话式产品生成工具。以前“会不会写代码”决定了谁能做软件，现在问题变成，谁能更清楚地描述需求、判断结果、迭代产品。

但这也不是没有风险。vibe-coding 工具很适合快速原型、个人项目和早期验证，可一旦应用变复杂，安全、性能、架构、数据库、权限和维护都会变得更难。Lovable 真正要证明的，不只是它能让人快速做出 demo，而是能不能让这些 demo 继续长成可靠产品。

所以读这条新闻时，可以把 Lovable 当成一个窗口。它让你看到 AI 编程工具正在从“帮助工程师写代码”走向“帮助更多人创造软件”。132 亿美元估值是否合理还要看后续收入和留存，但它背后的趋势很清楚，软件创造的门槛正在被重新定义。

Google’s deepfake detector system used to debunk McConnell hoax pic

2026 年 7 月，一张美国参议员米奇·麦康奈尔的照片在社交媒体上疯传。照片看起来非常真实，但内容是假的，它是用 AI 生成的深度伪造（deepfake）。

Google 的深度伪造检测系统被用来识别这张照片。文章没有详细解释技术原理，但提到这个系统能够分析图片中的细微异常，比如光照方向不一致、边缘模糊、或者像素级别的统计模式异常。

这件事有趣的地方在于，它展现了一个 AI 产品从实验室到真实世界的完整路径。Google 的检测系统不是突然被拿出来用的，而是经过长期训练，专门针对政治人物的深度伪造内容做了优化。麦康奈尔的案例恰好验证了它的能力。

对于做 AI 产品的人来说，这个故事有几个值得注意的点。第一，AI 产品的价值往往体现在具体场景中，而不是通用能力。Google 的系统如果只是说“我能检测深度伪造”，没人会信，但当一个真实案例发生时，它就有了说服力。第二，信任是 AI 产品的核心资产。用户不会因为你用了先进模型就信任你，他们需要看到你解决过真实问题。

文章最后提到，Google 正在考虑将这个检测系统作为公共服务开放。如果成真，这将是 AI 从工具变成基础设施的一个例子。

How to come up with a passion project

很多人想做自己的项目，但卡在第一步：不知道做什么。

这篇文章的作者给出了一个反直觉的建议：不要从“我想做什么”开始，而是从“我遇到了什么问题”开始。

作者举了自己的例子。他发现自己每次想找一个好用的命令行工具，都要花很多时间搜索和比较。这个烦恼持续了很久，直到有一天他决定写一个工具来帮自己解决这个问题。结果这个工具不仅自己用，还被很多人下载。

文章的核心观点是，一个好的 passion project 通常来自你日常工作中的某个痛点。因为只有你自己真正经历过这个痛点，你才知道什么样的解决方案是真正有用的。那些从市场调研或热门趋势出发的项目，往往做到一半就失去动力了。

作者还建议，不要一开始就想做一个大项目。先做一个最小可行版本（MVP），哪怕只有一个功能，只要能解决你自己的问题就行。然后慢慢迭代，让其他人也参与进来。

这个思路跟产品经理常说的“解决你自己的问题”很像，但作者把它变成了一个可操作的方法：写一个列表，列出你每天工作中最烦人的三件事，然后选一个你能用代码或设计解决的。这就是你的 passion project 的起点。

Book: RISC-V System-on-Chip Design

如果你对芯片设计感兴趣，或者想知道为什么 RISC-V 这个开源指令集架构近几年这么火，这本书是一个不错的起点。

RISC-V 是一种开源的处理器指令集架构，就像 ARM 和 x86 一样，但它不归任何一家公司所有。这意味着任何人都可以基于它设计自己的芯片，而不需要付专利费。

这本书的标题是《RISC-V 系统级芯片设计》，它面向的读者是有一定硬件基础的工程师，但如果你只是对芯片设计好奇，也可以从书的前几章了解 RISC-V 的基本概念。

文章没有详细说明书的内容，但提到这本书覆盖了从指令集架构到系统级芯片（SoC）设计的完整流程。系统级芯片是指把处理器、内存、IO 接口等集成在一个芯片上，比如手机里的芯片就是典型的 SoC。

对于产品团队来说，RISC-V 的兴起是一个值得关注的趋势。因为它降低了芯片设计的门槛，让更多中小公司可以定制自己的芯片，而不是只能购买现成的 ARM 或 x86 芯片。这可能会催生一批新的硬件产品，尤其是在物联网和边缘计算领域。

当然，这本书本身是一本技术书，不是产品策略书。但它反映了一个更大的变化：硬件正在变得像软件一样可定制和可迭代。

Designing Features Using Job Stories

很多产品团队在写用户故事时，用的是经典的格式：“作为一个[角色]，我想要[功能]，以便[目标]。” 比如“作为一个电商用户，我想要一个一键下单按钮，以便快速完成购买。”

Intercom 的这篇文章提出了一个替代方案：工作故事（Job Stories）。它的格式是：“当[场景]时，我想要[动机]，以便[预期结果]。” 比如“当我在手机上浏览商品并决定购买时，我想要一个一键下单按钮，以便在单手操作时也能快速完成购买。”

区别在哪里？传统的用户故事把用户类型（角色）放在中心，但真实世界中，同一个用户在不同场景下的需求完全不同。一个用户在工作时间可能想要详细的产品对比，但在深夜躺在床上时只想要一键购买。工作故事把“场景”放在第一位，强迫团队先理解用户在什么情境下遇到问题。

文章用了一个具体的例子：Dropbox 的“分享链接”功能。如果用用户故事，可能会写成“作为一个用户，我想要分享文件链接，以便其他人能查看文件”。但工作故事会写成“当我需要把一个文件发给一个没有 Dropbox 账号的人时，我想要生成一个链接，以便他可以直接在浏览器中查看，而不需要注册”。这个细微的差别决定了功能的设计方向，它应该生成链接，而不是发送邀请。

工作故事的价值在于它让团队不再假设用户是谁，而是先搞清楚用户在什么情况下、出于什么动机、想要达成什么结果。这个思路特别适合在功能越来越多、用户场景越来越复杂的阶段使用。

Traction vs. Growth

Brian Balfour 是 Reforge 的创始人，也是增长领域的资深实践者。在这篇文章里，他提出了一个关键区分：牵引力（Traction）和增长（Growth）不是一回事。

很多初创公司一上来就追求增长，但 Balfour 认为，在找到产品市场匹配（product-market fit）之前，你追求的应该是牵引力，而不是增长。牵引力意味着你找到了一个核心用户群体，他们愿意付费、愿意留下来、愿意推荐给别人。增长则是在这个基础上，用各种手段放大效果。

文章用了一个比喻：牵引力是挖井，增长是用水泵把水抽上来。如果你没有挖到水就开始抽，抽出来的全是泥。很多公司失败不是因为不会增长，而是因为还没找到真正的牵引力就开始大规模投放广告。

Balfour 还给出了一个判断是否找到牵引力的方法：看你的核心用户是否在自发地使用产品，并且在没有外部激励的情况下持续回来。如果用户需要你不断发邮件提醒才回来，那可能还不是真正的牵引力。

这篇文章对产品团队的价值在于，它提供了一个阶段性的思考框架。在早期，不要被增长指标迷惑，先找到那口井。找到之后，再考虑怎么把水抽上来。

With EU backing, QuantumDiamonds aims to speed up chip manufacturing

有一家叫 QuantumDiamonds 的初创公司，拿到了欧盟的资助，目标是加速芯片制造。

芯片制造是一个极其复杂的过程，涉及数百个步骤，任何一个环节出问题都会导致整批芯片报废。QuantumDiamonds 的技术基于量子传感，能够在制造过程中实时检测芯片内部的缺陷，而不是像传统方法那样等到芯片做好后再测试。

文章提到，欧盟之所以资助这家公司，是因为芯片制造是欧洲的战略重点。目前全球芯片制造高度集中在亚洲，欧洲希望建立自己的芯片供应链，而 QuantumDiamonds 的技术可以提高制造良率，降低成本，从而让欧洲的芯片工厂更有竞争力。

对于做 AI 或硬件产品的人来说，这个案例说明了几个趋势。第一，量子技术正在从实验室走向工业应用，虽然还处于早期，但像芯片检测这样的具体场景已经能看到商业价值。第二，政策支持可以加速技术落地，尤其是当技术涉及国家安全或供应链安全时。第三，B2B 的 AI 产品往往需要跟行业深度结合，QuantumDiamonds 不是卖一个通用的量子传感器，而是针对芯片制造这个特定场景做了定制。

文章最后提到，QuantumDiamonds 计划在两年内推出商用产品。如果成功，它将成为量子技术商业化的重要里程碑。

The ultimate guide to onboarding

这篇文章最重要的地方，是它把用户引导（onboarding）从“新手教程”这个很窄的概念里拿了出来。很多人一想到用户引导，会想到第一次打开产品时出现的欢迎页、按钮提示、功能导览，或者几步注册流程。但 Samuel Hulick 的理解更宽。他说，只要某个环节能提高用户成功采用产品的概率，它都算用户引导。

换句话说，用户引导不是产品教用户认识自己，而是产品帮助用户更快变成他想变成的样子。用户注册 TaxSlayer，不是为了学习 TaxSlayer 的界面，而是为了把税报完。用户注册 Basecamp，不是为了研究项目管理软件，而是为了把项目管好。用户注册 Intercom，不是为了点懂每一个按钮，而是为了更好地和客户沟通。这个视角一换，很多产品设计问题都会变得更清楚。

所以，用户引导也不只发生在用户第一次使用产品的时候。一个用户已经用了半年，突然产品推出了一个能让他更强的新功能，这也是用户引导的机会。用户还没有注册，但正在读你的文章、收到你的邮件、参加你的线上分享（webinar），这些也可能是用户引导的一部分，因为它们都在帮用户理解自己为什么要换到你的产品，为什么值得开始。

这篇里很有用的一个提醒，是公司想让用户做的事情，和用户自己想做的事情，经常并不完全一样。比如很多产品在注册时会要求用户导入通讯录、邀请朋友、绑定社交账号，站在公司角度，这是增长，是传播，是提高病毒系数。但站在用户角度，这一步不一定帮他更接近自己的目标。用户刚来，还没有感受到价值，就被要求替公司拉人，这种体验就会让动力偏掉。

Samuel 也很反感那种只靠提示气泡（tooltip）和按钮导览撑起来的用户引导。文章里有一个很形象的类比，是 Jason Fried 收藏的 “Signs on Signs”。意思是，一个标识本来应该让人看懂，但因为它没被注意到，别人又贴一个标识去指向它。这其实不是解决问题，而是在暴露原来的设计没有做好。产品里的提示气泡也是类似。如果界面本身让人困惑，你再叠一层解释按钮的提示，很多时候只是用更多界面去补救坏界面。

文章里提到电子游戏，是因为游戏在“如何教会用户复杂系统”这件事上很早就积累了经验。早期游戏可能要靠厚厚的说明书，玩家先读完才知道怎么玩。后来游戏开始在开头告诉你按什么键跳、按什么键跑。再后来，更好的游戏会把教学融进游戏本身，让你一边玩一边学，甚至不会觉得自己正在被教学。Samuel 认为软件即服务（SaaS）产品也应该往这个方向走。

空状态（empty state）是另一个容易被低估的细节。很多团队设计产品时，会不自觉地画一个已经有很多数据、很多图表、很多内容的成熟界面，因为那样看起来最漂亮。但真实的新用户第一次进来时，往往什么都没有。没有数据，没有联系人，没有项目，没有历史记录。这个时候，如果产品只是冷冰冰地写一句“暂无数据”，用户就很容易不知道下一步该做什么。

如果把整篇文章压成一个判断，它其实是在说，好的用户引导不是把用户带过一遍产品，而是把用户从“我有一个问题”带到“我真的解决了这个问题”。它不是一次性的欢迎流程，也不是界面上的几句提示，而是一整套持续帮助用户成功的设计。

GitHub's Engineering Principles

GitHub 这篇更像一张工程组织的地图，而不是一篇线性文章。它把 GitHub 对工程工作的理解拆成很多入口，架构、协作、安全、用户体验、远程工作、基础设施和团队文化都在里面。读它的时候，不太适合期待一个从开头到结尾的故事，更适合把它当成一个大团队如何思考工程的索引。

为什么这样的入口有价值，是因为工程团队一旦变大，代码本身往往不再是唯一的问题。真正困难的是很多人同时改同一个系统，大家在不同地点工作，决策要能被理解，质量不能只靠几个资深工程师盯着，知识也不能只停在少数人脑子里。这个时候，所谓工程原则（engineering principles）就不再是口号，而会影响每天的小判断。

小团队里，很多事情可以靠默契运行。几个人坐在一起，知道哪里危险，知道谁懂哪块代码，遇到问题喊一声就能解决。可是一旦团队变大，这种隐性知识就会变成瓶颈。你不能指望每个新人都靠猜来理解系统，也不能指望每个跨团队决策都靠私下沟通完成。

GitHub 这类工程原则真正想解决的，是怎样让团队在没有同一个人拍板时，仍然能做出相对一致的判断。什么时候应该优先可维护性，什么时候应该先交付。什么时候复杂度应该藏在平台内部，什么时候应该暴露给使用者。什么时候一个问题是局部代码问题，什么时候其实是协作方式的问题。

这也是为什么它虽然不是传统意义上的单篇文章，仍然值得放进阅读列表。它让人看到工程不是“写代码”这么单薄的一件事，而是包含工具、流程、责任边界、组织记忆和用户影响的一整套系统。你可以先扫一遍，再挑自己最关心的一条继续看。

对创业团队来说，这种文章也有提醒作用。早期公司还没有 GitHub 那样的规模，但很多习惯会从第一天延续下来。今天随手绕过的架构问题，明天可能变成团队速度的上限。今天没有记录的判断，明天可能让新人重复踩坑。

所以这篇的读法不是“GitHub 的原则都应该照抄”，而是借它反问自己的团队，有没有一套能帮助大家做判断的共同语言。工程质量不是最后检查出来的，它往往在团队每天如何沟通、如何拆问题、如何交接知识时就已经决定了。

10 Usability Heuristics for User Interface Design

这篇文章之所以经典，是因为它没有从某种审美风格开始讲设计，而是从人怎样使用系统开始讲。用户会忘记刚才发生了什么，会误点，会不知道下一步该去哪，也会用现实世界里熟悉的经验去理解屏幕上的东西。很多界面问题不是因为用户笨，而是产品没有照顾这些很普通的人性。

Nielsen Norman Group 把这些反复出现的问题整理成十条可用性原则（usability heuristics）。它们听起来并不新奇，比如系统要告诉用户现在发生了什么，语言要接近用户熟悉的世界，用户出错时要能撤回，重要信息不要逼用户记在脑子里。可越是这些基础东西，越容易在产品忙着加功能时被忽略。

你可以想象一个用户正在上传文件。如果页面没有任何进度反馈，他不知道系统是不是卡住了。如果保存按钮点完没有提示，他可能会重复点击。如果错误信息只说 failed，他不知道是自己填错了，还是系统出了问题。这里的关键不是界面漂不漂亮，而是产品有没有让用户安心。

还有一个很重要的点，是产品语言不能只服务公司内部。很多功能名在团队里很合理，因为大家知道背后的模块和业务逻辑。但用户没有参加过你们的会议，不知道那些内部词是什么意思。好的界面应该像一个懂人话的人，而不是把公司的组织结构直接摊在用户面前。

这十条原则的价值，不是让你背下来以后显得专业，而是给你一套检查产品的稳定语言。以前你可能只会说这个页面“不顺”或者“不好用”。读完以后，你可以更具体地说，用户没有看到系统状态，错误恢复太困难，或者这个流程要求用户记住太多上下文。

读这篇最好的方式，是拿一个真实产品对照，而不是空读。打开一个注册流程、一个设置页、一个付款页，逐条问它有没有让用户迷路，有没有让用户猜测，有没有让用户承担本该由系统承担的记忆负担。

它最后能带走的判断很简单。好的可用性不是给界面加一点友好文案，而是降低用户和系统相处时的心理负担。用户越少需要猜、记、怕、回头找，产品就越像一个可靠的工具。

Retention + Engagement

很多团队谈增长时，会先谈拉新。今天来了多少用户，投放带来多少注册，活动让数字涨了多少，这些都很容易被看见，也很容易让团队兴奋。但产品真正难的地方，不是把人带进来一次，而是让他在应该回来时真的回来。

Reforge 这篇把留存（retention）和参与度（engagement）放在一起看，就是为了把增长从表面的热闹拉回用户关系。一个用户打开过产品，并不说明产品已经进入他的生活。真正要问的是，他后来为什么回来，回来时做了什么，这个产品是不是已经变成他某个固定场景里的自然选择。

短期兴趣很容易制造。广告、朋友推荐、媒体报道、免费试用，都可能让用户进来看看。但看一下和留下来是两件事。一个产品如果只能制造第一次好奇，却不能让用户反复获得价值，它的增长就像不断往漏桶里倒水。

参与度也不是越高越好。聊天产品可能天然高频，报税产品可能一年才用一次。关键不是每天打开多少次，而是在产品应该被使用的时刻，用户有没有想到它，有没有信任它，有没有觉得它比原来的做法更好。

这篇的价值在于，它让你用更细的眼光看用户行为。用户回来，是因为真的获得了价值，还是因为被通知打扰了。用户使用很频繁，是因为产品有用，还是因为流程太复杂，不得不反复回来处理。

对于做产品的人来说，留存其实是在问一个很朴素的问题。用户生活里有没有给这个产品留位置。它是不是进入了某个习惯，某个工作流，某个必须完成的任务。没有这个位置，增长再漂亮也会很累。

读这篇时，可以把它当成一次从“增长数字”到“用户关系”的视角切换。不要只看有多少人进来，要看什么人回来，为什么回来，回来以后是否更接近自己想完成的事情。

Schlep Blindness

Paul Graham 这篇讲的是创业里一种很隐蔽的盲点。很多人不是看不见机会，而是因为机会看起来太麻烦，所以大脑自动把它过滤掉了。大家更愿意想象一种干净的创业方式，写一个聪明的软件，放到网上，然后用户自然涌进来。

但现实里，很多好生意并不干净。它们要处理银行、合规、销售、脏数据、旧系统、线下流程和难缠客户。它们不像一个优雅的算法题，更像一堆没人想碰的杂活。Paul Graham 用 schlep 这个词描述这些麻烦事，而 schlep blindness 就是因为怕麻烦而看不见机会。

Stripe 是文章里很关键的例子。线上支付的痛苦早就存在，开发者都知道接支付很烦。但正因为它牵涉银行、欺诈、安全、监管和各种边界情况，很多人下意识觉得这不是一个适合创业的优雅问题。结果，这种麻烦反而变成了机会的保护层。

这篇值得反复读，是因为它会纠正一种常见的创业审美。很多人以为好想法应该轻巧、漂亮、可规模化。但有时候，真正值钱的问题恰恰是一开始看起来笨重、麻烦、需要大量人工和行业理解的问题。

放到今天的人工智能创业里，这个提醒也很有用。很多人想做通用工具，做一个看起来很聪明的智能体（agent）。但真正愿意付钱的客户，往往在某个具体行业里，被旧系统、表格、审批、合规、电话和脏数据折磨。麻烦不是外围，它可能就是产品要解决的核心。

Paul Graham 最有力的建议，是不要只问自己想做什么，而要问自己希望别人替你解决什么。这个问题会把你从自己的兴趣拉回真实痛点。你不想做的那些麻烦事，可能正是别人也不想做、但又不得不做的事。

读完这篇，最值得带走的是对“麻烦”的重新理解。麻烦不一定是坏信号。有些麻烦说明这个问题真实、深入、难复制，也说明愿意跳进去的人更少。创业机会有时不是藏在新概念里，而是藏在大家都绕开的脏活里。

Design Thinking

设计思维（design thinking）这个词很容易被误解成一套工作坊动作。贴便签、画白板、分组讨论、做原型，好像只要流程走完，团队就完成了设计思维。但 Miro 这篇更值得看的地方，是它背后那件更朴素的事，团队怎样避免太早爱上自己的答案。

做产品时，人很容易从方案开始。我们要做一个功能，要改一个页面，要上线一个流程。团队越讨论，越会觉得自己的方案有道理。可真正危险的是，用户的问题可能根本不是团队以为的那个问题。

设计思维的顺序，就是为了防止这种跳跃。先理解用户，再定义问题，然后发散方案、做原型、测试和回头修改。它看起来像多走了几步，其实是在防止团队把错误方向做得越来越精致。

比如用户说想要提醒功能，团队很容易马上去做提醒。可是继续观察和追问后，也许会发现用户真正的问题不是忘记，而是流程本身太复杂，导致他不知道什么时候该做什么。提醒只是表面答案，真正问题在更深处。

原型（prototype）和测试在这里也不是为了证明团队已经对了，而是为了尽早发现哪里不对。越早用粗糙方式验证，越少在错误方向上投入大量工程和设计成本。一个草图、一个假按钮、一个简单流程，有时比完整产品更能暴露问题。

这篇适合在团队准备做新功能前读。它会提醒你，先不要急着问我们能做什么，而要问用户到底卡在哪里，我们有没有把这个卡点讲清楚。只有问题说准了，后面的创意才有意义。

所以它真正讲的不是某种设计流程，而是一种谦逊的产品态度。不要太早相信自己的解释，不要太快进入解决方案。先让用户的处境变得清楚，再让团队的想法接受现实检验。

Vanta's Path to Product-Market Fit

产品市场匹配（product-market fit）听起来像一个成功公司回头总结出来的词，但早期公司经历它时，往往没有那么清楚。客户会说感兴趣，却不一定愿意付钱。团队会做很多功能，却不一定解决了最痛的问题。投资人、用户、团队自己都可能给出很多噪音。

Vanta 这篇有价值，是因为它把产品市场匹配（product-market fit）拉回一家具体公司的早期路径。它不是抽象地说“找到需求”，而是让你看到一个团队怎样从看似合理的想法里筛出更强的信号。

早期团队最容易犯的错，是以为产品更完整，市场就会更愿意接受。于是大家努力做更多功能，让产品看起来更像一个成熟软件。但如果客户真正痛的不是这些，功能越多只会让团队更忙，也让判断更模糊。

更强的信号通常来自客户行为，而不是客户礼貌。客户愿意花时间试，愿意忍受早期产品的不完美，愿意把它带进自己的工作流，愿意付钱，甚至愿意帮你继续解释问题，这些都比一句“听起来不错”更重要。

Vanta 的场景也很适合理解这件事。合规和安全不是一个轻飘飘的需求，它会影响销售、客户信任和企业合作。客户不是因为好奇才关心它，而是因为它卡住了真实业务。

读这篇时，可以重点看团队如何识别“痛到愿意行动”的问题。早期创业不是证明创始人聪明，也不是尽快把想象中的完整产品做出来，而是尽快找到客户已经在为之付出代价的那件事。

这篇最后带来的判断是，产品市场匹配（product-market fit）不是一句成功标签，而是一连串越来越清楚的证据。用户是否改变行为，是否愿意付费，是否把产品纳入日常，是否在没有你推动时也想继续使用，这些才是更接近真实的答案。

Product Discovery

很多团队以为产品发现就是开发前的调研。做几次访谈，写几页需求，画几个原型，然后交给工程团队进入交付。这个流程看起来很完整，但真正的产品风险往往不会这么听话地只出现在前期。

SVPG 这篇讨论的产品发现（product discovery），更像是一种持续降低风险的工作。用户是不是真的需要，方案能不能用，技术能不能做出来，商业上值不值得做，这些问题都可能在项目推进过程中不断出现。

如果团队只重视交付，很容易变得非常高效，却高效地做出没人要的东西。大家排 sprint、拆任务、写代码、按时上线，但上线之后才发现用户不理解、不需要，或者根本不愿意改变原来的做法。

但如果团队只停留在发现，也会有另一种问题。访谈越做越多，洞察越写越厚，会议越开越细，可产品迟迟不能落地。好的产品团队不是永远研究，也不是盲目执行，而是在学习和交付之间保持张力。

这篇的价值在于，它让你看到产品发现不是产品经理一个人的文档工作。设计师、工程师、业务负责人都应该参与，因为风险不只来自用户需求，也来自可用性、技术可行性和商业判断。

读的时候可以重点看它怎样区分 发现（discovery）和交付（delivery）。发现是在决定应该做什么、为什么做、风险在哪里。交付是在把这些判断变成真实产品。两者如果断开，团队就容易一边写文档一边失去现实反馈。

如果你的团队经常觉得大家很忙，但方向不稳，这篇会很有帮助。它会让你问一个更根本的问题，我们是在减少不确定性，还是只是在推进任务。真正好的产品工作，应该让团队越做越清楚，而不是越做越难回头。

Uber’s European expansion plans may have hit a speed bump

平台型公司的扩张从外面看，像是地图上多涂几个国家。但真正进入一个市场时，公司面对的不只是用户和订单，还有监管、竞争、收购审查、本地行业和政治环境。Uber 这篇新闻之所以值得看，是因为它让你看到增长并不总是产品和运营问题。

早期公司谈增长，常常谈获客、补贴、转化率和市场进入。可是到了 Uber 这种规模，增长会进入另一层游戏。每一次扩张、收购或暂停，都可能被监管机构、竞争者和本地市场重新解读。

欧洲市场尤其复杂。不同国家有不同的交通监管、劳工争议、本地出租车行业、本地平台和政策环境。对 Uber 来说，进入一个城市不是简单上线应用，而是重新进入一张已有的利益网络。

新闻里提到扩张计划可能遇到阻碍，可以看作一种战略放缓。暂停某些动作，不一定意味着公司不想增长，也可能是为了降低潜在收购或市场进入时的反垄断压力。

这里有一个很适合创业者理解的点，增长不是永远越快越好。当公司规模足够大，快速推进本身可能制造新的阻力。监管会问你是不是太强，竞争者会反击，合作方会重新评估关系。

读这篇时，可以重点看 Uber 为什么可能在某些地方慢下来，以及这和潜在收购之间有什么关系。表面看是欧洲扩张受阻，背后其实是平台公司在成熟市场里如何继续长大的问题。

这篇也提醒你，平台公司最终面对的不是一个空白市场。它进入的是有规则、有利益、有历史的现实世界。产品体验仍然重要，但到了某个阶段，监管理解、市场结构和竞争格局会变得同样重要。

Amazon will stop accepting new customers for Mechanical Turk

Mechanical Turk 曾经像互联网背后的人工小工厂。很多机器做不好的小任务，会被拆成一块块交给人完成，比如标注图片、检查文本、判断搜索结果、填写调查。普通用户看到的是自动化系统，背后却有大量人在补机器做不到的部分。

后来人工智能兴起，Mechanical Turk 又成了数据标注和人类反馈的一部分。模型需要数据，需要人判断答案好坏，需要把模糊的现实世界转成可训练的样本。很多看似智能的系统，背后都曾经依赖这种分散的人力。

TechCrunch 这篇新闻说 Amazon 将停止接受 Mechanical Turk 新客户，这像是在给一个时代画句号。它不代表人工标注或人工反馈消失了，但代表一个非常有象征意义的平台正在退出新增长。

更有意思的是，这个平台和人工智能之间的关系变得有点讽刺。人类曾经帮模型标数据，帮系统完成机器还做不好的判断。后来平台上的人也可能开始用大模型来完成任务，结果变成机器训练机器，人类只是在中间转了一手。

这会让人重新思考，所谓人在回路（human in the loop）到底还提供多少可靠信号。如果一个任务本来需要人的判断，但执行者用模型生成答案，数据质量就会变得复杂。人工智能系统可能在吞下由另一个人工智能系统产生的内容。

这篇也提醒你，人工智能基础设施不只包括模型、芯片和云服务。它还包括那些长期隐藏在系统后面的人，标注员、审核员、测试者、内容清理者，他们让机器学习的世界和现实世界接上了线。

读这条新闻，不只是看 Amazon 关掉一个入口，而是看人工智能产业背后的劳动结构如何变化。一个旧平台退场，说明行业里的数据生产、评估和反馈方式正在重新组织。

如果你以后看人工智能公司，可以多问一句，它的数据、评估和反馈从哪里来。很多时候，模型能力不是纯粹的技术奇迹，而是一整套人和机器共同组成的生产链。

Product strategy means saying no

这篇文章讲的是产品策略里最不舒服、但也最重要的一件事，学会说不。产品团队做到一定阶段，想法会越来越多。客户会提需求，销售会带回机会，团队成员也会不断想到新功能。每一个想法单独看都可能有道理，真正困难的是，它们不能全部同时成为产品方向。

Intercom 这篇的重点，不是让团队变得冷漠，也不是让产品经理随便拒绝别人。它想说的是，如果你没有清楚的产品策略（product strategy），你说不的时候就像在表达个人偏好。别人会觉得你不重视客户、不支持销售、不愿意合作。但如果策略清楚，说不就变成一种对方向的保护。

你可以想象一个团队正在做客户沟通工具。一个大客户想要更复杂的权限设置，另一个客户想要新的报表，销售希望加一个能帮助成交的功能，设计师觉得核心体验还不够顺。每个人都不是错的，但团队如果每个都答应，产品很快会变成一堆互相拉扯的零件。

好的策略会帮团队回答，什么样的用户现在最重要，我们要帮他们完成什么进展，靠什么赢，哪些事情虽然诱人但会把产品带偏。这样一来，拒绝某个需求不是因为它没有价值，而是因为它不服务当前最重要的方向。

这篇也很适合提醒早期团队，不要把“客户要什么”直接等同于“产品该做什么”。客户会从自己的场景出发提出解决方案，但团队要往后退一步，理解背后的问题。有时你不应该照做客户说的功能，而应该用另一种更符合产品方向的方式解决同一个痛点。

说不还有一个隐藏好处，它让团队能把已经选择的事情做深。产品质量、定位清晰、用户理解，很多都来自持续聚焦。一个团队如果总是在新机会之间跳来跳去，很难在任何一个方向上形成真正的优势。

读这篇时，可以把它当成一次策略压力测试。你可以问，如果明天一个很有吸引力的大客户提出一个偏离方向的需求，团队有没有足够清楚的理由拒绝，或者有没有能力把它转译成更符合产品策略的方案。

最后能带走的判断是，产品策略不是写在文档里的愿景，而是每天取舍时能不能派上用场。真正的策略会让团队更容易说不，也让每一个“是”变得更有分量。

Building Effective Agents

Anthropic 这篇讲智能体（agents），但它最有价值的地方不是追逐一个很热的词，而是把智能体重新拉回工程和产品判断里。很多人听到 agents，会想象一个完全自主的人工智能系统，给它一个目标，它就能自己拆任务、调用工具、完成工作。现实通常没有这么简单。

文章里很重要的区分，是工作流（workflows）和智能体（agents）。工作流更像一条被提前设计好的路线，模型在其中完成某些步骤，但整体流程由人写清楚。智能体则更开放，模型需要根据环境自己决定下一步做什么。听起来智能体更酷，但也更难控制，更容易出错，成本也更不可预测。

这对做产品的人很关键。很多场景并不需要最自由的 agent。比如处理一批客服邮件、整理销售线索、生成报告草稿，可能一个清楚的工作流更可靠。模型在固定位置发挥作用，人和系统控制关键节点，这样用户更容易信任结果。

你可以想象一个公司想让人工智能帮它处理采购审批。如果直接给模型全部权限，让它自己读邮件、判断预算、联系供应商、提交审批，风险很高。更现实的做法，是先把流程拆开，让模型负责提取信息、比较条款、提示异常，最后由人确认关键决定。

这篇的价值在于，它提醒团队不要把智能程度当作唯一目标。一个系统越自主，越需要观察、纠错、边界和回退机制。用户真正买的不是“它看起来像人一样聪明”，而是它能不能在真实工作里稳定减少负担。

Anthropic 也强调评估（evaluation）的重要性。模型演示一次成功不代表产品可靠。团队要知道在哪些任务上成功率高，在哪些情况下会失败，失败时会不会造成严重后果。没有评估，智能体产品很容易停留在演示视频里。

读这篇时，可以带着一个很实际的问题看，什么时候应该用简单提示，什么时候应该用工作流，什么时候才真的需要 agent。这个问题比“我们能不能做一个智能体”更有价值。

最后能带走的判断是，好的人工智能产品不是把自主性拉满，而是在能力、可靠性、成本和用户信任之间找到合适的位置。真正成熟的 agent 产品，往往不是最会表演的，而是最能在具体任务里稳定交付结果的。

How to Get Startup Ideas

Paul Graham 这篇讲创业想法，但它不是在教人坐在房间里空想点子。它反而一直在提醒，好的创业想法通常不是被“想出来”的，而是从真实问题里长出来的。你自己遇到的问题、身边聪明人反复抱怨的问题、某个行业里大家已经习惯忍受的问题，往往比刻意追逐风口更可靠。

很多人想创业时，会先问什么领域热门，什么技术新，投资人现在喜欢什么。这些问题不是完全没用，但很容易让人离真实用户越来越远。Paul Graham 更鼓励从自己熟悉的生活和工作出发，因为你对那些问题有更细的感受，也更容易判断一个解决方案是不是真的好。

文章里有一个重要提醒，好的创业想法一开始常常看起来不够像大公司。它可能只解决一小群人的具体麻烦，市场看起来很窄，甚至别人会觉得这有什么了不起。可是如果那群人真的很痛，而且你能先把他们服务好，事情才有机会慢慢变大。

你可以想象一个工程师每天被部署流程折磨。他不是先发现一个“开发者基础设施市场”，而是先觉得这件事太烦了，应该有更好的办法。很多开发者工具、企业软件和垂直产品，都是从这种具体不适开始的。

这篇也反对一种过度追求新奇的心态。创业想法不一定要听起来前所未有。很多好机会反而来自那些大家都知道麻烦、但没有人认真解决的地方。关键不是题目新不新，而是你是否真的理解为什么旧办法不好，用户为什么愿意换。

Paul Graham 还提醒，创始人最好处在问题发生的地方。你越接近真实场景，越容易看到别人看不到的细节。外人看到的是一个抽象市场，里面的人看到的是每天具体卡在哪里，谁最痛，现有替代方案为什么不够好。

读这篇时，可以把它当成一个观察训练。不要急着问我能做什么公司，而是先问，我和身边的人最近反复被什么东西困住，哪些事情大家已经习惯忍受，哪些笨办法其实暴露了一个还没有被好好解决的问题。

最后它带来的判断很朴素。创业想法不是一句漂亮的概念，而是一种对真实痛点的敏感度。你越能诚实地看见具体人的具体麻烦，越可能找到一个真正值得做的起点。

What is a North Star Metric?

北极星指标（North Star Metric）听起来像一个很管理化的词，但它解决的是团队里非常常见的混乱。一个产品可以看很多数字，注册量、活跃用户、留存、收入、点击率、使用时长。每个数字都可能有意义，但如果团队没有一个最核心的判断标准，大家就会各自优化自己手里的指标。

Amplitude 这篇的价值，是把指标和用户价值重新连起来。好的北极星指标不是公司随便挑一个漂亮数字，而是应该反映用户是否持续获得了产品最核心的价值。它既要和业务增长有关，也要能说明用户真的在用产品解决问题。

比如一个音乐产品，如果只看打开次数，用户可能只是被通知打扰了。一个协作工具如果只看发送消息数量，也可能说明团队沟通很混乱。真正好的指标要问，这个产品最希望用户完成什么，什么行为最能代表用户得到了价值。

你可以想象一个在线学习产品。注册用户很多不一定说明它成功，打开课程页面也不一定说明学到了东西。更接近核心价值的指标，可能是每周完成有效学习的人数，或者持续完成课程进度的学习者数量。这样的指标更能推动团队关注真正重要的体验。

北极星指标还有一个作用，是让不同团队对齐。增长团队、产品团队、数据团队、内容团队，如果都围绕同一个核心指标讨论，取舍会更清楚。否则增长可能只追注册，产品只追功能使用，内容只追发布数量，最后每个人都完成了自己的目标，但用户价值没有真正增加。

这篇也提醒你，指标不能脱离阶段。早期产品可能先看激活（activation），成熟产品可能更关注留存（retention）或付费转化。北极星指标不是永远不变的神圣数字，而是团队当前对核心价值的最好表达。

读的时候可以注意，选择指标本身不是终点。更重要的是围绕指标拆出输入指标，也就是哪些用户行为、产品改进或运营动作会推动它变化。否则北极星只会挂在墙上，不能指导日常工作。

最后能带走的判断是，好的指标不是让团队看起来更数据化，而是让团队更诚实地面对产品有没有创造价值。北极星指标真正要回答的，不是我们数字涨了吗，而是用户是不是更持续地得到他们来这里想得到的东西。

When to Use Which User-Experience Research Methods

用户体验研究（UX research）最容易被误解成一种固定动作，比如一提到研究就想到访谈，或者一提到验证就想到可用性测试。Nielsen Norman Group 这篇的价值，是告诉你不同研究方法回答的是不同问题，不能因为熟悉某种方法就什么都用它。

做产品时，团队会遇到很多种不确定性。你可能不知道用户是谁，不知道他们为什么有这个问题，不知道一个方案能不能用，不知道上线后行为是否改变。每一种问题需要的证据不同，对应的研究方法也不同。

如果你想理解用户的生活和动机，访谈、田野观察、日记研究可能更有用。因为你要看到人真实处境里的细节。如果你想知道一个界面用户能不能顺利完成任务，可用性测试（usability testing）更直接。如果你想比较两个方案在大规模用户中的表现，实验和数据分析可能更合适。

你可以想象一个团队发现用户不使用某个功能。如果直接做可用性测试，可能只能看到按钮不好找。但真正原因也许是用户根本不需要这个功能，或者他们用另一个流程绕过去了。这个时候，先做访谈或行为分析可能比测试界面更有价值。

这篇像一张研究方法地图。它帮助团队先问清楚，我们到底想知道什么。是探索问题，还是评估方案。是看用户说什么，还是看用户做什么。是需要定性理解，还是需要定量证据。问题问清楚，方法才不会乱选。

它也提醒产品团队，研究不是只属于研究员。产品经理、设计师、工程师都需要理解证据的类型。否则团队很容易拿错误证据做决定，比如用少数访谈证明规模化需求，或者用数据趋势解释一个其实需要深入理解的行为。

读这篇时，可以拿最近一个产品问题来套。比如用户为什么没有完成注册，为什么某个功能用得少，为什么转化下降。先判断这是动机问题、可用性问题、信息问题还是市场问题，再决定该用什么方法。

最后它带来的判断是，好的用户研究不是做更多研究，而是用合适的方法回答合适的问题。方法本身不高级，真正高级的是知道此刻需要哪种证据。

How Superhuman Built an Engine to Find Product-Market Fit

产品市场匹配（product-market fit）经常被说得像一种神秘感觉，好像某一天市场突然拉着产品往前跑。Superhuman 这篇有意思的地方，是它试图把这种感觉变成一套可以持续追踪的方法。它不是只问用户喜不喜欢，而是问如果你不能再使用这个产品，你会有多失望。

这个问题很聪明，因为它比满意度更尖锐。用户说喜欢一个产品，可能只是礼貌，也可能只是觉得还不错。但如果他说不能用了会非常失望，说明这个产品已经进入了他的工作或生活，变成某种不容易替代的东西。

Superhuman 用这个问题把用户分层，然后重点研究最喜欢产品的人。表面看，这有点反直觉。很多团队会把注意力放在不满意用户身上，想把所有人都修好。但早期产品更重要的，可能是先弄清楚谁真的强烈需要你，为什么他们需要你。

你可以想象一个邮件产品。普通用户觉得它界面不错，但重度用户可能每天处理几百封邮件，速度、快捷键、搜索、提醒和收件箱清理对他们非常重要。产品如果先为这些强需求用户做到极致，就更容易形成清晰定位。

这篇的价值在于，它把产品市场匹配从抽象口号变成一个学习循环。找出最喜欢你的用户，理解他们是谁，发现他们最看重什么，再调整产品和定位，让更多相似用户也获得同样强的价值。

它也提醒团队，不要一开始就追求所有人都满意。如果你试图同时服务太多用户，产品会变得模糊。早期更重要的是找到一群真的离不开你的人，再从他们身上理解产品的核心价值。

读这篇时，可以注意它怎样结合定量和定性。一个百分比告诉你产品市场匹配的强度，用户回答告诉你为什么。只有数字没有故事，团队不知道怎么改。只有故事没有数字，团队不知道进展是否真实。

最后能带走的判断是，产品市场匹配不是一次性被发现的宝藏，而是一套不断靠近真实需求的机制。你要找到谁最需要你，为什么需要你，然后让产品更坚定地服务这个核心人群。

Product vs. Feature Teams

SVPG 这篇讲产品团队和功能团队的区别，表面上像组织管理文章，实际是在问一个很根本的问题，团队到底是在交付任务，还是在解决问题。很多公司名义上有产品团队，但工作方式仍然是上面决定做什么，下面负责按时做完。

功能团队（feature team）的典型状态，是路线图已经被写好。团队接到的是功能清单，任务是设计、开发、上线。这样做看起来很有秩序，也容易管理进度，但问题是，团队很少有机会判断这个功能是不是解决了真正的问题。

产品团队（product team）不同。它不只是对交付负责，也要对结果负责。团队需要理解用户、业务、技术约束和可行方案，然后决定什么值得做，怎么做才可能带来结果。它不是只问什么时候上线，而是先问为什么要做、用户会不会用、成功是什么样。

你可以想象两个团队都被要求提高注册转化。功能团队可能直接做一个新注册页，因为需求就是这样写的。产品团队会先看用户在哪一步离开，为什么离开，是信任不足、信息太多、表单太长，还是价值没有讲清楚。最后它可能改页面，也可能改定价、文案、引导或整个激活流程。

这篇的价值，是它把“授权”讲得很具体。真正的产品团队需要被赋予问题，而不是只被分配功能。公司可以给目标，比如提高留存、减少客服工单、提升企业客户转化，但团队应该参与寻找答案。

当然，这也要求团队有更高能力。产品经理不能只是排需求，设计师不能只是画界面，工程师也不能只是接票写代码。大家要一起理解问题、评估风险、验证方案，并对结果负责。

读这篇时，可以对照自己的团队。你们讨论更多的是功能什么时候做完，还是用户问题有没有被解决。工程师有没有参与早期判断。设计是不是只在最后美化界面。产品经理有没有空间说，这个需求也许不是正确答案。

最后能带走的判断是，真正的产品团队不是更高级的称呼，而是一种责任边界。它要求团队从执行功能，转向寻找能产生结果的解决方案。