Ryo Lu - 设计Cursor的未来

我不希望这个工具变成，啊，我们为设计师打造了一个类似光标的东西。它只是一个光标。它就是同一个代理。光标可能会根据你的不同而改变它的体验。

I don't want the tool to be, ah, we built like a cursor for designers. It's just cursor. It's the same agent. Cursor might change how it feels depending on who you are.

作为一名设计师，当你以个性化为最终目标时，你在思考哪些类型的事情，来跨越这个鸿沟？

What types of things are you thinking about as a designer with personalization being the end goal that you're trying to cross that chasm?

对每个人来说，理想的界面都是不同的。我们作为设计师所设计的东西，只是上升了一个层次。你不再是精确地设计这一块UI的外观，而是在设计一个容器。

The ideal interface is different for every single person. The things we design as designers, they just kind of go up one level. Instead of you designing exactly how this piece of UI will look, you are actually designing a container.

现在，为每个用户动态地让AI使用合适的模块组合，可能比以往任何时候都更重要，尤其是在设计数字产品方面。

Coming up with the right set of blocks for AI to wield for each user dynamically probably is more important now than at any point ever in designing digital products.

我正在尝试探索这个东西是否有可能实现。因为我们是在编写软件，代码就是材料，你没有任何限制。你可以做任何事情。

I'm trying to poke at the boundaries of is this thing possible. Because we're building software and the code is the material, you have no limitations. You can do whatever.

欢迎来到Dive Club。我的名字是Rid，这里是设计师永不停止学习的地方。本周的节目嘉宾是Real Lu，你可能在早前的一期节目中听过他，当时我们讨论的是早期Notion和系统设计。但从那以后，Rio加入了Cursor并担任设计主管，Cursor无疑是当今科技界最有影响力的公司之一。因此，我们将深入了解Cursor的设计运作方式，包括Rio进行的所有疯狂的AI实验。

Welcome to Dive Club. My name is Rid, and this is where designers never stop learning. This week's episode is with Real Lu, who you might have heard on an earlier episode back when we were talking about early Notion and systems design. But since then, Rio has joined as the head of design at Cursor, which is easily one of the most influential companies in all of tech right now. So we're gonna get an inside look at how design operates at Cursor and including all of Rio's crazy AI experiments.

那么，话不多说，让我们开始吧。

So without further ado, let's dive in.

Cursor的人第一次联系我是在八月左右，那时代理功能还没出现。Cursor的产品发展路线，他们最初是从标签页开始的。那时它只是代码的自动补全功能，可以说是一个比GitHub Copilot更强大的工具。

So Cursor people first reached out, like, August. That was before the agent existed. The Cursor product trajectory, they started with the tab. It was, like, auto completion for code. It's, like, a much better GitHub Copilot.

然后我们在去年年初推出了聊天功能。在聊天中，你可以向Cursor询问关于代码库的问题，它会回答。但它不会为你做太多事情。到了7月，他们又加入了Composer功能。Composer有点像，现在聊天可以为你编写代码，然后你可以修改代码。

Then we did the the chat, like, early last year. And in the chat, you can, like, ask Cursor about the code base questions, and it'll answer. But it won't do much for you. And then in July, they added the composer. So the composer is kinda like, now the the chat can actually write code for you, and then you can modify code.

所以他们那时就联系了我。我们聊了一下。我当时觉得，哦，很酷。但我仍然认为，Cursor那时主要是一个面向开发者的工具。它现在仍然是，但自那以后已经发生了巨大的变化。

So they reached out to me back then. We talked a little bit. I thought, oh, cool. I still thought, like, Cursor back then was, like, a tool mostly for, like, coders. It is still, but it has changed so much since.

我当时想，哦，我还是继续做我的Notion项目吧，因为我想为每个人做出一些东西。然后去年11月左右，我们在Notion做规划，是关于一个我长期在做的多年期项目。当时的计划是，我们会在今年下半年推进这个项目。我当时非常生气，因为自从我加入Notion以来就一直想做这件事。当我第一次去开发v0版本时，我做了一个小原型。

I thought, oh, I'm just still gonna do my Notion thing, because I want to make something for everyone. And then last year, around November, we were doing planning at Notion, like, this, like, multiyear project that I was working on for a long time. And then the plan happened to be, like, we're gonna do this, like, for second half of this year. And I was so angry because I wanted to do it, like, maybe since I joined Notion. When I first went to v zero, I made a little prototype.

它有点像一个Next.js React、Tailwind CSS应用，代表了未来的Notion。我在里面玩了几轮，然后卡住了。我想做得更多，但无法继续下去，所以我干脆下载了这个应用。

It's like a Next. Js React, tailwind CSS app of, like, like, the future Notion. And then I played, like, couple rounds there, and I was, like, stuck. I want to do more, but then I can't. So I just downloaded the app.

我下载了Cursor，打开后使用了它的智能代理。花了好长时间才找到代理在哪里，然后我就上瘾了。我连续玩了三天，然后就做出了一个完整的原型，完全是我脑海里设想的未来Notion，就是我想要的那样。

I got Cursor. I opened it up. I used the agent. It took a lot of time to find where the agent is, and then I was hooked. I did that for, like, three days, and then I I built this whole prototype of, like, the future Notion, like, my head, exactly what I want.

我做了一个菜单，你可以打开或关闭每一个新功能。比如，有一个功能开关菜单，全都是开关选项，你可以看到整个应用随之变化。它有真实的数据，还有一些很酷的功能。

I built, like, a menu where you can, like, turn turn like, every single new feature. Like, there's, like, a feature flat menu. Off off off off off off, and then you can see the whole app change. It has, like, real data. It has, like, like, a cool thing.

比如，我做了一个三维地球视图，但核心想法是，在Notion中我们知道有看板、表格、画廊等视图，但你可以拥有自己的自定义视图。也许这些视图是人写的，也许是由AI生成的。它们使用相同的概念和数据模型。这彻底改变了我。

It's, like, I built, like, a three d globe view, but the idea is, like, in Notion, you know, we have, like, board, table, galleries, but you could have your own, like, custom views. Maybe they're written by humans. Maybe they're, you know, generated by AI. It uses the same concepts, same data model. That completely changed me.

以前开发软件是一个非常漫长的过程。你可能需要自己先开始，也许你可以做一些小工具之类的东西，这很有趣。但如果你想做出更大的东西，你必须先组建一个团队。

Making software before, it was, like, a really long process. You might need to kinda start, like, you know, by yourself. Maybe you can make some, like, little tools and stuff. It's fun. But in order for you to make something bigger, you need to first assemble a team.

在这个团队里，有很多不同的人在做不同的事情。你需要想办法把他们协调起来，你需要统一大家的思想，制定计划。而现在，我有了一个想法，我可以画一些草图，或者口头向代理描述这个想法。

And in this team, there's, like, so many different people doing different things. You need to figure out how to, like, tie them together. You need to align people, make plans, versus I have an idea. I'll draw some sketches. I'll maybe verbally describe it to the agent.

也许我会拍一张照片，是我随手画在餐巾纸上的菜单结构草图。那只是一个矩形框，线条、分隔线之类的。然后我会告诉代理我希望菜单中有哪些项目，然后‘砰’的一声，完成了。

Maybe I'll take a picture of like a nap napkin sketch of this, like, menu structure that I wanted. And then it'll be like just a rectangle box, line, line, lines, divided line, line, line. And then I'll tell the agent, like, the items that I want in the menu, and then boom. Done. That's it.

而且，几乎每一个小细节都可以这样完成。这意味着你可以以更快的速度不断推进，直到达到你想要的产品状态。在这个过程中，你不再依赖于一些其他文档或软件的表示形式。以前，人们必须写文档，比如PRD。他们必须在Linear里制定计划，创建任务。

And then it's that, but, like, for every single little thing. And that means you can just keep going at a much faster rate to where you want your thing to be. And as you do it, you're not acting on some other artifact or representations of the software. Before, people had to write docs like PRD. They had to make plans in linear, make some tasks.

他们必须在Figma里画一些像素图，试图用流程把所有东西拼接在一起。而现在，更像是在雕塑。你先做出一个东西，然后不断调整。也许去掉某些部分，也许重新整理某些部分。

They have to draw some pixels in Figment, try to stitch everything with, like, a process. Versus now, it's almost like sculpting. You get something, then you poke at it. Maybe get rid of certain parts. Maybe you rewrangle certain parts.

也许你会说，啊，再做一遍，一遍又一遍，做五次，选一个合适的。这样整个情况就完全改变了。是的。

Maybe you say, ah, do it again, again, and again. Do it five times. Pick the right one. It changes completely. Yeah.

然后Cursor的团队成员又再次联系了我。

And then the cursor people reached out again.

那时很多事情都已经发生了变化。

And a lot had changed at that point.

是的。就在我做了原型大约三天之后。然后我想，哦，天哪，我得过去和你们一起开发。我就在那里待了大概两天。

Yeah. Like, right after I made the prototype after, like, three days. And then I'm like, oh, shit. I need to go and jam with y'all. And I I stayed there for, like, two days.

然后，那基本上就是我在Cursor做的第一个项目。

And then that was, like, the first project I shipped at Cursor.

具体是指什么？

Was what exactly?

就是把Cursor所有的概念整合成一个统一的东西。之前，Cursor有标签命令k，这有点像一个内联编辑代理功能，还有聊天模式，这就像一个只和你对话但不做任何事情的代理。还有Composer，这是一个可以和你对话并编写代码的代理。另外还有Cursor Composer Agent，这是Composer的一种模式，基本上可以自动进行编辑。所以，Cursor之前有五个不同的概念，五个不同的功能。

It was, like, unifying all the Cursor concepts into one thing. So before, Cursor had the tab command k, which is like an inline editing agent thing, the chat, which is like an agent that only talks to you but doesn't do anything. The composer, which is an agent that talks to you with some code. And the cursor composer agent, which is a mode on the composer that basically, like, automates the edit. So the cursor had these five different concepts, five different things.

它们都是独立开发的，命名方式也不同，每个都有不同的快捷键。我只是提出，所有这些其实都是同一个东西，它们都是代理。

They're all built separately. They're all named differently. Each of them have different key bindings. And all I did was I said all of these things are the same thing. They're all agents.

然后我们把它们全部合并成一个统一的概念。现在我们默认所有人都使用代理。以前，人们被困住了，根本不知道我们有代理功能。所以我认为这可能是我们从二月开始迅速发展的主要原因。

Then we merge all of them into one concept. Now we are defaulting everyone to use the agent. Before, it was like people were stuck. People didn't know we had the agent. So that's why I think it's probably the biggest reason we took off since February.

我很高兴在我开始使用Cursor的时候你已经完成了这个改变。

Well, I'm glad that I started using Cursor then after you had already made that change.

你能找到它。

You you able to find it.

是的。我就像在回顾这段旅程，我看到三月份在使用的东西。

Yeah. I I'm, like, looking back at the journey, and I'm seeing what using in March.

我和很多人聊过。我说，Cursor 真是太棒了，太酷了。然后他们说，哦，我已经用 Cursor 一年、几个月了，但我没有这个功能。你是怎么做到的？

I talked to so many people. I'm like, cursor is so great. It's so cool. And then they're like, oh, I've been using cursor for, like, year like, months, and then I don't have this. How do you do it?

哇。

Wow.

特别是和一些资深工程师交流时。

For, like, senior engineers I talk to.

那我们再深入一点吧。因为今年早些时候我看到你发过一条推文，讲的是 Mhmm，基本上就是关于在 AI 时代设计工具的一些技巧。其中有一条就是强调要从系统的角度而不是功能的角度去思考。是的。那么我们先退一步，从更基础的原则层面来说，你能讲讲你在自己的头脑中到底是怎么思考这些问题的，才得出了这些看似很明显的改进，从而简化了 Cursor 背后的概念和心智模型？

Let's go a little bit deeper there then because I read a tweet that you had from earlier this year where you talked about Mhmm. Basically just, like, tips for designing tools in the age of AI. And one of the line items was the importance of thinking in systems, not features. Yeah. So back up for a second and maybe at more of a principle level, talk about what you were even doing in your own mind to arrive at some of those seemingly obvious changes that you made in order to simplify the concepts and mental models behind Cursor.

嗯。是的。我认为我的一般流程是，我需要理解整个系统。我需要尽可能了解每一个细节。我会从外部世界获取信息，比如说来自用户的信息，可能是 bug 报告或反馈，也可能是来自公司内部人员的意见，但同时也要了解代码中实际在发生什么。

Mhmm. Yeah. I think my general process is I need to understand the whole system. I need to know every bit of it as much as possible. I will consume information both from, say, the outside world, maybe it's from the users, maybe it's from, like, bug reports feedback, maybe it's internal people, but also what it does act like, in actuality in the code.

然后你可能会想出一些更好的做事模型。你可能会简化事情。你不会把某些东西去掉，而是将它们统一起来。意思是，人们之前在做的事情、在使用的东西仍然存在，但现在它们被重新组织成一个更简单的形式。比如说，原本有五个概念，现在只有一个。

Then you come up with maybe, like, better models of doing things. Maybe you simplify things. You don't get rid of things, but you kind of unify things. Meaning, like, the things that people were doing, things that people were using, they're still there, but now they're, say, reorganizing to something that's a little simpler. Instead of, like, five concepts, you have just one.

这几乎就像是你构建了同一事物的不同层次。对于大多数人来说，他们会使用 Cursor 的默认代理模式，不需要做任何更改。理想状态下，它会自动运行。但我们几乎想服务所有人，从那些经验最丰富的程序员——他们想要完全的手动控制，到那些更倾向于‘感觉’的人。

And it's almost like you built layers of the same thing. For most people, they will use the default agent mode on cursor. They don't have to change anything. It will just, you know, in the ideal state, just work. But it's almost like we want to serve everyone, like from the most experienced coders who want full manual control, to people who are more like Vibes.

他们让代理完成所有工作。中间还有很多不同的配置选项、模式和行为。你希望满足所有这些用户的需求，但你也希望给人们提供一个合适的位置，理想情况下，是在这个光谱上的正确位置。如果你判断错了，你就需要建立一些机制，让人们可以逐步向这边或那边调整。你不想突然就告诉所有人：‘从现在开始，代理模式就是默认设置。’

They just let the agent do everything. And then there's like almost like in between a lot of different little configurations and like patterns and behaviors. You want to serve all of them, but you want to give people, like, ideally, you know, in this spectrum, the the the right point. You might get it wrong, then you build, like, mechanisms for people to, say, move to this side or move to this side progressively. Like, you don't want to nudge people, like, completely say, ah, from now on, agent will be the default.

每个人都会开始使用那个，然后我不给你任何退出的方式。接着我把其他所有东西都去掉。然后你会说，哦，天哪，我之前用的那个东西去哪儿了？完全没有连续性可言。

Everyone will start using that, and then I don't give you a way out. And then I remove everything else. Then you're like, oh, shit. Well, where is the thing that I had? I have no, like, continuity.

我无法想象你是怎么从今天这个状态过渡到那个新地方的。我更倾向于这样理解：你不是做出五个独立的小东西，而是把整个圆圈做大。那不是一个东西，但人们仍然有办法去做那五个独立的事情。

I can't picture how you got, you know, from today to this new place. I can't. It's more like, instead of five discrete little things, you just make the circle big. That's not one thing. But then there are still ways for people to do the five discrete things.

但也许现状是，与其说是五个东西，现在变成了n个东西。

But maybe as it is, like, instead of just five things, now there's n things.

如今很多人说你必须成为一个设计工程师，但我并不这么认为，因为Paper给了你代码的很多优势，同时又不牺牲设计体验。你仍然可以随意地在界面中疯狂探索，这个界面感觉就像是一个简化版的Figma。但画布本身是用代码渲染的，而不是矢量图形。这意味着开发者只需右键点击，复制为React代码，然后就能准确地按照你的设计发布产品，不再有信息丢失的问题。很快，你甚至可以直接将代码组件导入到设计画布上，这样你就再也不用处理多个重复的真相来源了。

Nowadays, a lot of people are saying that you gotta become a design engineer, but I don't think that's true because paper is giving you a lot of the benefits of code without sacrificing the design experience. You could still make a mess and explore like crazy in an interface that feels like a streamlined version of Figma, but the canvas itself is rendered in code, not vector. That means developers can simply right click copy as React and then ship your designs exactly as you design them. No more lost in translation. And soon, you'll even be able to import code components directly onto the design canvas so you don't have to deal with duplicate sources of truth anymore.

这其实是一件大事，也是我为什么全力支持Paper成为下一个伟大的设计工具的原因之一。如果你想成为首批体验Paper的人之一，请前往dive.club/paper来抢占名额。我最喜欢的动画工具Jitter刚刚也发布了重大更新。现在你可以使用他们全新的钢笔工具绘制自己的形状，并通过流畅的形状过渡来实现动画效果。这对动态设计和Jitter来说都是一次巨大的突破，也是创建真正独一无二动画的好方法。

But it's a pretty big deal and just another reason why I'm all in on Paper as the next great design tool. So if you wanna be one of the first to access paper, head to dive.club/paper to claim your spot. My favorite animation tool, Jitter, just dropped a big time release. You can now draw your own shapes with their all new pen tool and animate them with fluid shape to shape transitions. But it's a huge unlock for motion design and jitter and a great way to create animations that are truly one of a kind.

所以如果你还在观望，是时候醒来了。现在就前往dive.club/jitter体验一下吧。是的，j-i-t-t-e-r。现在进入正题。从某种意义上来说，你正在使用一个工具，至少当你刚加入时，它的理想用户画像主要是开发者，而现在你正在创造一个理论上可以支持设计师和各种不同类型构建者的产品。

So if you're still sleeping, it's time to wake up. Just head to dive.club/jitter to try it out today. That's j I t t e r. Now on to the episode. So in a sense, you're kinda taking a tool that, at least when you joined, was, you know, pretty much the ICP was developers, and now you are creating something that, in theory, can support designers, all types of different builders.

是的。那么你的模型是否要求产品的默认版本必须是最简单的形式，以便适应这些类型的用户？还是你允许高级程序员横向转向更简单的方式？可以稍微谈谈这个。

Yes. Does your model then require the default version of the product to be the simplest form that it can take in order to allow for those types of people, or do you actually allow the vibe coder to move laterally towards simplicity? Okay. Talk about that a little bit then.

是的。我认为现在的想法是，当所有人进入Cursor的时候，他们看到的是三个按钮，很多人根本不知道它们是什么意思。比如，打开项目。你需要在文件系统中创建一个包含代码的文件夹。还有一个是克隆仓库。

Yeah. I think the idea is right now, everyone come into Cursor, they see three buttons, and a lot of people don't understand what they mean. There's, like, open project. You need to create, like, a folder on your file system with the code. There is a clone repo.

仓库是什么鬼？还有一个是打开SSH之类的。SSH又是什么？在编程这个小圈子之外，没人知道这些术语。但从概念上来说，这个工具本身，甚至软件开发的实践，比如围绕构建一个软件的所有人，你可能是个设计师，可能是个专业的产品经理，或者是个数据分析师，我们所做的一切，最终都只是写出来的代码而已。

What the fuck is a repo? There is open SSH or something. What's SSH? Like, no like, nobody knows outside the programming, like, little world. But, like, conceptually, the tool itself or or even, like, the the practice of making software, like, all the people around building, like, a piece of software, maybe you're a designer, maybe you're a pro like, a PM, maybe you're, like, a data person, everything we're doing, you know, at the end, they're just code that gets written.

我们其实都在影响着代码的编写。我们都是构建软件这个游戏的一部分。什么才是构建事物的正确形态？该如何构建？一旦这个AI能够帮助我们将这些想法转化为代码，它就更像是一种协作关系。

We're kinda influencing what code gets written. We're part of this game, like, you know, building software. What is the right shape of things to build? How to build? Then it's almost like, you know, once this AI is able to help us translate those into code, it's more like a collaborative thing.

这更像是人类与AI协作的事情。这是一个团队合作的事情。不仅仅是AI取代创作者，而是说，有些人会因此几乎像被AI覆盖了他们原本做不了或做得少的事情，甚至让他们能够完成远超以往能力的任务。比如，一个1倍效率的工程师可以变成10倍效率的工程师。

It's like a human with AI thing. It's a team thing. It's not just, you know, AI replacing the creators. It's more like there will be people who will be almost like the AI covers the things that they do less or even like it lets them do way more than what they could afford. Like, a one x engineer can become like a 10 x engineer.

一个10倍效率的工程师可以变成1000倍效率的工程师，一个设计师甚至也可以变成10倍效率的工程师。也许你一开始只是随便写写代码，后来你开始有点好奇，这是什么？然后你开始学习。

A 10 x engineer becomes like a thousand x engineer. A designer becomes like a 10 x engineer even. Maybe you started from just vibe coding, then you got a little curious. What is this? Then you start learning.

这就像React、Next.js、Tailwind CSS这些技术。然后你开始构建更多的东西，这些东西也变得越来越好。然后你会想，我不希望这个工具只是——啊，我们为设计师打造了一个“光标”。我们为产品经理之类的人打造了一个“光标”。

This is like React, Next. Js, Tailwind CSS. And then you start building more things, and then the things get better. And then it's like, I don't want the tool to be, ah, we built, like, a cursor for designers. We built a cursor for, I don't know, PMs.

它其实就是光标，是同一个智能体。根据使用者的不同，Cursor的体验可能会有所不同。

It's just cursor. It's the same agent. Cursor might change how it feels depending on who you are.

好的，那我们再深入探讨一下这个话题。因为直到今天，当你打开Cursor时，它看起来还是像一个IDE，它具有一种大家熟悉的界面，你们也因此受益。但与此同时，现在产品本身正受到两种不同力量的拉扯：一方面是以“氛围编程”为主的用户群体，他们甚至根本不知道IDE应该是什么样子的。

Okay. Then let's pull on that strand a little bit Because still, to this day, you open up Cursor, you know, it feels like an IDE. There's a familiarity to it that you all have been able to benefit from. And yet, now you kinda have these two different forces pulling on what the product is. You have the rise of the vibe coders and people who have no idea what an ID even is supposed to look like.

嗯嗯。另一方面，我们正进入一个越来越智能化的世界，越来越多任务可以并行发生，也许未来软件开发的很大一部分，是战略性地将人类融入流程中，而不是由人类亲自去写代码。所以，我想请你谈谈一下这种张力：一边是IDE那种熟悉的体验，另一边是维护一个系统，让它能够适应这样一个未来世界，即“Cursor for X”可能就是Cursor本身，你可以从电脑上完成任何任务。

Mhmm. And then you also have this increasingly agentic world where more and more things are happening in parallel, and perhaps much of the future of software creation is more about strategically putting humans in the loop rather than having humans write code. So talk to me a little bit about that tension between the familiarity of an IDE and also maintaining a system that allows you to scale for a world where cursor for x might just be cursor, and you can kinda do anything from your computer.

没错。IDE只是Cursor的一种形式，我们从这里起步，是因为这是最普遍的选择。甚至不是我决定的，而是像我这样的Michael和其他人选择的。我们选择了VS Code，因为它是最受欢迎的代码编辑器，程序员都知道它是干什么的。

Yeah. The IDE is just one form of cursor, and we started there because that is the like, we pick not not even me. That is, like, maybe I'm Michael and people. They pick Versus Code because it is the most popular code editor. Coders know what it is.

现在你把它与AI和所有最新技术深度融合，推出新的工具，这些工具与之非常契合。也许我们是从这种手动编码的工作流程开始，然后逐步在其基础上不断构建。如果你回顾一下发展轨迹，这种演进其实是有道理的。比如，从手动写代码，到代码自动补全，再到我可以编辑代码的某一部分，再到我可以向整个文件、整个代码库提问，哦，原来这个工具真的能做事。

Now you deeply fuse it with AI and all the latest things. You ship new tools that really, you know, fits with that. Maybe we started from this, like, manual coding workflow, and you start kinda building on top of it gradually. It it kinda makes sense if you look at the trajectory again. Like, you start from manually writing code to auto completion of code to now I can edit this part of code to now I can ask the the whole file, the whole code base to know, ah, this thing can actually do stuff.

它可以调用工具、进行修改、自主搜索，在一个线程里，甚至可以在前台同时运行三个线程，这有点像我们现在的标签页。而有了后台智能体，你就可以同时做n件事，可以是并行的，也可以是顺序的。这是一个逐步演进的过程，对吧？但即使到现在，Cursor也不再局限于IDE了。

Make, like, make tool calls, make modifications, search on its own, do stuff like in a in one thread, maybe three parallel threads in the foreground. That's kind of like the tabs that we have. And now with background agent, you can do like n things at once, simultaneously, maybe parallel, maybe in sequence. It's kind of like a gradual process, right? But Cursor, even today, is not stuck in the IDE anymore.

比如，我们推出了Slack集成，还有网页智能体，它可以在手机上运行，也可以在任何浏览器中运行。你可以感觉到，它只是同一件事物的不同形式而已。不同的人，或者在工作流程的不同阶段，你可能更喜欢不同的形式。比如说，那些最习惯手动操作的程序员，他们仍然喜欢输入代码，他们比智能体更喜欢标签页这种形式。

Like, we ship the the Slack integration, there's the web agent, there's like, it works on the phone, it works in any browser. Then you can almost feel feel like it's just, like, different forms of the same thing. Different people, or, like, when you're in parts of the workflow, you might prefer different forms. Say, the coders, the most manual people, they still like type. They love the tab thing more than the agent.

但在这个领域里，到处都有人。可能到了某个阶段，有些人甚至根本不需要使用光标（cursor）和集成开发环境（IDE）。他们可能只是使用网络代理（web agent），甚至根本不需要看到代码。他们可能只会在一个非常高的层面进行规划，也许会用一些看板（Kanban board）工具。

But there's, like, people everywhere on the spectrum. There could be, like, people at some point, they might not even use cursor, the IDE. They might just use the web agent. They might not even see code. They might be just planning things on a really high level, maybe with some Kanban board.

但那仍然是Cursor，本质上还是一样的东西。也许你回到电脑前，打开Cursor应用，所有东西都还在那里。你可以轻松切换不同的分支。

But it's still Cursor. It's still the same thing. Maybe you go back to a computer, you open up Cursor. App, everything's still there. Like, all you need to do is, then you can switch between different branches.

你可以合并所有内容，尝试不同的方案。你可以在任何地方开始，比如中途接手，然后在电脑上完成。这完全取决于你是谁，以及你在做什么。

You can merge them all. You can try different things. You can start them anywhere, pick them up in, like, in the middle, and then finish it off on the computer. Really depends on who you are and what you're doing.

我想了解你具体是如何工作的，但在进入这个话题之前，我必须问一下你对未来发展的看法。考虑到你刚才描述的现实情况，比如你可能根本看不到代码，可以从任何地方访问Cursor，并拥有n个代理为你工作，你显然也在认真思考这些未来。那么，你目前最关注的是一些什么样的问题？

I wanna get into how you work specifically, but before we get there, I can't not ask for your thoughts on where this is all headed in terms of just what the future of software creation even looks like, given these realities that you're laying out where Mhmm. You might not even see code and you can access Cursor from anywhere and have n number of agents working on your behalf. You're obviously thinking about these futures as much as anybody. So what are some of the things that are in your mind right now?

嗯。要实现这一切，你需要解决一些相当困难的、深入的AI技术问题。可能是模型方面的问题，也可能是构建更好的系统来支持这一切。另外，如果Cursor对每个人、每件事来说都不一样，那它到底是什么？

Mhmm. In order for this to work, you need to solve some pretty hard, like, deep AI technical problems. Maybe it's with, like, modeling. Maybe it's, like, building, like, better systems to kinda support all of this. And then there is, like, if cursor is different for every single person, for every single thing, then what is it?

我们又回到了系统层面的问题。有哪些核心概念是始终不变的，可以支撑这一切？人们更喜欢哪些形式因素？对于所有人或特定人群，我应该提供什么样的默认设置？我们关心的是哪些人群？

Again, we go back to the system part. Like, what are the concepts that never changes that will kinda support all of this? What are the form factors that people would prefer? What is the right default for me to give to, say, everyone or specific groups of people? What are the groups of people we care about?

我们从哪里开始？然后，从那里你可以大致看出事情会如何发展。

Where do we start? And then from there, you can kinda see where things go.

当你越来越多地转向并行代理时，有没有哪些特定的设计挑战是你花了很多时间思考的？

Are there specific design challenges that you've spent a lot of time wrestling with as you move more towards simultaneous agents and

列表

lists

请再谈谈这个过程中的这一部分。嗯。

and like, talk to me about that part of the process a little bit. Mhmm.

我大概这一个月大部分时间都在思考这个问题。问题是，你该如何同时启动多个智能体并进行管理，查看它们的运行情况，当它们完成任务之后，又该如何处理？它们是如何运作的？你又该如何提前进行规划？大多数人仍然是一次只做一件事，但有些人可能希望提前规划很多事情。

I spent probably this month mostly thinking about this problem. It's like, how do you both, like, spin up multiple agents and manage them, view what's going on, and then once they're done, what to do with them? How do they work? How do you, like, say, plan things ahead? Most people will still, like, do one thing at a time, but some people might want to plan a lot of things ahead.

其中一些任务可能是按顺序执行的，它们之间可能存在依赖关系；而有些任务可能是可以并行处理的。比如，你有10个bug需要修复，那就一次性全部修复，然后看看结果如何。

Some of them might be executed, like, sequentially. Maybe they have dependencies between each other. Some of them might be, like, paralyzable. So, like, you have 10 bugs that I want to fix. Just fix them all and see what happens.

接着就形成了一个完整的流程：你从一些计划好的任务开始，可能你在执行它们，也可能没有执行，而是由智能体来执行，但你仍需对结果负责。当任务完成后，你需要回顾一下到底发生了哪些变化。

And then there's this whole flow of, like, you start with some tasks that are planned. You're do doing them. Maybe you're not doing them. The agent is doing them, but you kind of is responsible. And then once they're done, you need to kind of review what are what are the changes.

你需要决定是否保留这些更改中的某些部分，还要决定如何将它们合并回去并发布出去。然后我就突然意识到，哦，天哪，这又回到了待办事项列表的老路上了，这种事情我已经做过无数次了。

You need to decide whether I want to keep parts of the change or not. You need to decide how to merge them back and, you know, ship them. Then I was like, oh, shit. It's to do list all over again. I've done this so many times.

我们又回来了。

And we're back.

每次都是这样，我们又回到了我们两个人的状态。对于智能体来说，对于人类来说，又回到了列表视图、网格视图或列视图中的待办事项列表。

Every single time, we're back to the two of us. Like, for the agent, for the humans, to do list in the list view, in the grid view, in the column.

是啊，那我们干脆做成看板（Kanban）形式，然后我们又回到了

Yeah. How about we make it a Kanban board, and we're back to

引擎界面？结果还是一模一样。唯一的区别是，这些任务现在可能由智能体来完成。就是这样，非常简单。

the engine? And it's the fucking same thing. The only difference is, these things might be done by the agent. That's it. It's so simple.

那你是什么时候这么快就想到这一点的呢？因为你说你已经研究这个问题一个月了。

How quickly did you arrive at there then? Because you said you were working on this for a month.

就是随便聊聊

Like, talk

对我来说，那个剥削范围有多广。

to me about how wide that spectrum of exploitation was.

我们想要的是，这几乎就像，也许我们可以绕过去，或者我们可以做点别的。比如说，这几乎就像每次聊天都变成了一项任务。也许这就像一对一的关系。但后来我们意识到，人们使用它的方式真的非常不同。有些人有一个很长的聊天记录，他们所有的事情都在里面完成。

What we wanted was it's almost like maybe, like, we can get around it or, like, we can do something else. Say, it's almost like maybe the chats, each of them become almost like a task. Maybe it's like a one to one thing. But then what we realized was, like, just people use the thing so differently. Some people, they have this giant long running chat that they do everything.

也许他们只为特定类型的修改或代码库的特定区域建立一个聊天，而我们更推荐的方式仍然是：你每做一项任务，就新建一个聊天。

Maybe they have, like, a chat just for specific kinds of edits or areas of the code base, and then our preferred method is still, like, you should just make a new chat for every single task that you want to do.

是的。我确定这确实非常诱人，因为这是对基本功能的一种简化，对吧？从系统思维的角度来说，这正是理想的情况。

Yeah. Which I'm sure was really tempting too because that is the simplification of primitives. Right? Like, from the systems thinking. That is ideal thing.

比如，如果每个人都这么做，那么每一次聊天就代表一项任务。对吧？这样你就不需要另一个概念了。这几乎就像是你在围绕聊天进行组织。没错。

Like, if everyone were doing that, then every chat is a task. Right? Then you don't need another concept. It's almost like you're kinda organizing the chats around. Yeah.

但后来我们发现，有些人想在一个聊天里做五件事，而有些人只想做一件。所以我们仍然需要一个东西来帮助代理，你知道，代理的上下文窗口是有限的，它们会把所有的文件上下文、聊天历史、它做过的事情都塞进那个窗口里。当你聊得越久，它就会逐渐遗忘。这就有点像，有时候模型在最开始几次表现非常好，但随后性能就逐渐下降了。

But then it's almost like, some people want to do, like, five things in one chat. Some people just want to do one. Then we still need a thing to kinda help the agent even you know, agents have, like, a limited context window, and they were kinda stuffing all the file context plus the chat history, what it did, everything in that window. As you go longer, it forgets. Then it's kinda like, you know, sometimes the model is, like, really great for the first few few times, and then boom, it gets stunburned over time.

我们也需要一个东西来持续跟踪它需要完成的高层任务，它现在处于什么阶段，正在思考哪一项任务，这项任务与其他任务有什么关联，接下来要做什么。代理也需要这个，才能在更长的时间跨度内完成更复杂的任务。我觉得更有趣的部分是，这不是一个仅仅为代理或仅仅为一次聊天设计的待办清单，而是整个系统。想象一下，你可以把一个软件，甚至整个软件开发过程拆分成一堆任务，然后这些任务会被打包成提示，也就是聊天。

We it also needs a thing to keep track of what is the high level things it needs to do, where is it, which item is it thinking about right now, how does it relate to other things, what is coming up. Like, the agent also needs that. To do better things on a longer time span or doing more things. I feel like the the more interesting part is it's not to do list just for the agent or, like, just for one chat, but it's almost like the whole thing. Like, imagine you can break up a piece of software, the entire software development process into just a bunch of tasks, and they are kind of, you know, packed to the prompts, like, to the chats.

然后，因为这个概念非常通用，所以界面不需要很复杂。任何看过Nicholas View的人都可以开始做这些事情。这就是为什么我们倾向于在IDE之外构建这些功能。你可以通过 cursor.com/agents 访问。没错。

Then, you know, because this thing, this concept is so universal, the interface doesn't have to be complex. Anybody who have seen Nicholas View can start doing these things. And that's why we kinda build these things outside of the IDE. You can access it, like, in cursor.com/agents. Yeah.

砰，你就能看到代理的列表视图。点击一下，就能看到它们在做什么。如果你不想看代码，也可以只看聊天内容。然后还有一个按钮，砰，合并，完成。

Boom. You see a list view of agents. You click around and then you see what they do. You can see the chat if you don't want to look at a code. And then there's, like, a button, boom, merge, done.

我能理解为什么这是一个有价值的原始功能，因为它为那些根本不想进入IDE的人提供了一个很好的入门方式。哦，他们仍然可以查看项目的进展情况。

That makes sense to me why it would be a valuable primitive because it's such a nice on ramp for people who actually have no interest in entering an IDE. Oh, that's like still wanna see what's happening with the project.

这就是现实世界中人们规划事务和开发软件时正在发生的事情。Jira 看板是线性的，你知道的，人们就是那么做的，这是一样的事情。但如果将其更多地与人工智能、与智能体融合，使其更具协作性，让它们共同编写代码，共享同一个代码库，对事情的运作方式、当前状况以及计划内容都有相同的认知，那么智能体就能做得更好，人类也能做得更好。

That is what's happening in the real world right now when people plan things and make software. The Jira boards are, like, linear, you know, like, people do that. It's the same thing. But if you fuse it more with AI, with the agents, make it more collaborative, they're working on the code they're, like, the same code base, same awareness of how things work, what's going on and what's being planned, then the agents can do better. The humans can also do better.

我想先退一步，稍微铺垫一下背景，这其实是我二十分钟前就该做的事情，但事情很快就变得非常有趣了。所以我想更多了解一下设计方面的事情，也就是你实际上的工作方式，在公司里你是如何运作的，你的角色是怎样的，你们又是如何确定该做什么的。跟我聊聊，比如说你作为 Cursor 的设计师，每周的工作大概是怎样的。

I wanna take one step back and kinda just set the stage a little bit, which arguably I should have done twenty minutes ago, but it just got very interesting very quickly. So I wanna learn a little bit more about how design, which is, you know, effectively you, how you operate at this company and what the role looks like, how you're even figuring out what to work on. Talk to me a little bit about, you know, maybe even just your week to week as the person designing Cursor.

每周我都会想出一些我想要做和探索的事情。这通常是一些具体的问题。比如，这周的任务就是让我们的定价策略更清晰一些，在后台智能体、网页端和移动端发布方面做更多的工作，把这些内容整理清楚，让整体体验更好。但与此同时，我也会从各个渠道收集大量信息，以便了解当前的状况以及人们是如何看待 Cursor 的。我也会自己做一些项目。

Every week, I'll come up with things I want to do and explore. So, like, it's just specific problems. Say, like, this week is, like, making our pricing clearer, doing more on the background agent web mobile launch, cleaning that up, making things better. But at the same time, I try to just gather a lot of information from everywhere so that I keep an awareness of what's going on and, like, how people perceive cursor. I try to just do projects on my own.

这就是我们所谓的‘内部试用’。同时，这也是我逐渐获得直觉判断的方式，比如 AI 的能力边界在哪里，我们的问题出在哪里。然后你就去尝试。我们用 Cursor 来构建 Cursor。有时候我还会用 Cursor 构建一个‘小 Cursor’，最终这些都会集成到 Cursor 中，有时候还会为了好玩而制作一个 RealOS 的测试版。

That's how we dog food the thing. And also how I kind of get intuition of, like, where the the limits of the AI are, where where our problems are. And then you just play. You build maybe it's like, you know, we build cursor with cursor. And then also I build, like, baby cursor with cursor that end up in cursor, and then make RealOS test for fun.

同时，我也在不断探索边界：这个东西是否可行？是否容易实现？应该怎么做？目前对于 Rio OS 来说，我甚至不会添加新功能，只是改进我自己或智能体已经做过的东西。

But, also, I'm trying to poke at the boundaries of is this thing possible? Is it easy? Is it like, how to do it? For Rio OS right now, I don't even add new features. I just improve the things that I did or the agents did.

我会尝试重构系统，尝试构建更好的系统，从而不断学习。此外，我还能了解到，比如 o3 在某些方面比 Gemini 更好。然后我会把这些经验带回工作中，改进我们的工具，让它变得更好。

I try to refactor systems. I try to, like, make better ones, and then I learn. And, also, I I can know, maybe o three is, like, better at this versus, like, Gemini. And then I carry that knowledge back to work, and then we fix the tool. We make it better.

它就这样持续发展下去。

It just does keeps going.

我想谈谈个人项目这件事，但首先我想再深入探讨一下你刚才提到的关于信息收集的部分。

I wanna get into the personal projects thing, but I wanna double click on something you said where you talked about just gathering information.

嗯嗯。

Mhmm.

我想知道你是如何从众多信息中识别出有价值的信号，以及哪些信息是你选择忽略的。因为现在有很多人在给你反馈。比如，我回过头看了你最初发布的移动端设计截图，下面有 772 条评论，这简直太疯狂了。你是怎么处理这么多反馈的？

And I wanted to know where you're deriving signal versus what you can choose to ignore because Mhmm. There are a lot of people that are giving you feedback right now. Like, I went back and looked at your screenshot of the original mobile designs, and there were 772 comments, which is ridiculous. So how do you even deal with that?

是的。我只是关注Twitter上、Slack上的一切，以及所有的用户报告和反馈。我只是试着去慢慢消化它们。这就像训练一个模型，就像你在不断输入更多的数据。

Yeah. I just look at everything in on Twitter, in in Slack, all the, like, user reports and feedback. I just try to, like, simmer them in. It's like training a model. It's like you're just feeding more data.

你是在培养自己的直觉。然后你会发现，看得越多，你的优先级判断就越准确，你的感觉也会越来越好。

You're building your intuition. Then, you know, the more you see these things, your priorities get better, your sense gets better.

好的。那如果我们尝试逆向工程你使用的系统提示，也就是你用来判断哪些反馈需要采取行动、哪些只是说‘不，这没道理’的那个标准。你是如何不断改进这个系统提示，从而判断哪些反馈应该忽略，因为它们在战略上不重要？

Okay. So then if we were reverse engineering the system prompt that you were then using as the razor to figure out what feedback to act on versus what to say, no, that doesn't make sense Mhmm. How have you evolved that system prompt to understand what feedback to ignore because it doesn't make strategic sense?

我想这么说，大多数情况下，单独来看，一些小决定其实并不重要。但当你把这些小事情放在一起时，它们就都变得重要了。或者说，方向更重要，概念更重要，想法更重要，而不是你具体怎么去做。我会试着去理解这个人真正想要的是什么，他为什么告诉我这些，然后我发现，哦，他的解决方案，我不在意。

I will say this. It's like, for most things, in isolation, little decisions, they don't really matter. But then when you kinda put all of these little things together, they all matter. Or like, say, the direction matters, the concepts matters, the idea matters more, then say how you do it. I try to get a sense of what the person really wants, why they told me this, then say, ah, your solution, I don't care.

有时候我就直接忽略这些反馈。因为它们真的不重要，甚至对我自己来说也不重要，所以我不会花太多时间在这些事情上。

Bye. Sometimes I ignore those two. It's like because they are really not important. Even for myself, they're not important. Then I won't spend too much time on it.

你看得越多，就越容易自然而然地处理这些信息。这几乎就像你建立了一个自己的处理器，用来过滤噪音并建立直觉。而且，它也在不断变化，是一种动态的东西。可能这周大家觉得X、Y、Z更好。

Like, the more you look at these things, the the easier you just kinda naturally process these. It's almost like you build your own, like, processor filtering out noise and then building intuition. So, also, like, it's it changes. It's like a dynamic thing. Maybe, like, this week, people are saying, x y z is, like, better.

X、Y、Z不好，它会变化。

X y z is bad. It changes.

此外，现在有越来越多相互冲突的时间线在同时发生。根据我的经验，你会收到一些看起来非常合理的功能请求。但正如大家都用烂了的那个比喻，这就像人们要求制造更快的马一样。你

And, also, there's competing timelines at play more than ever, where in my experience, you get feature requests that make a lot of sense. But to, you know, tack I know. To the overused analogy, it's like, it's all about making faster horses. You

明白吗？嗯。

know? Mhmm.

有时候很难判断什么时候该遵循这些请求，什么时候该说，你知道吗？其实我们正专注于打造一个完全不同的未来。

And it's difficult to know when to abide by some of those requests versus to say, you know what? Actually, like, we're focused on a totally different future that we're trying to create.

是的，是的。带走所有东西，但你提到过优先级，而优先级会变化。这更像是一个动态排序的问题。不仅仅是外部因素。

Yeah. Yeah. Take everything, but you said the priorities, and they change. It's more like a dynamic ordering thing. It's not just, like, the outside too.

比如说，有公司层面的事情。比如资源或技术上的限制。有当下，有未来，还有你自己。

It's, like, there's there's like company stuff. There's, say, like resource technical limitations. There's the present. There's the future. There's the you.

有工程师，有设计师，有所有人。有更多手动控制与更多自动化的区别。如果你尝试根据规模来做选择，会非常困难，因为你很容易卡住。

There's the engineers. There's the designers. There's everyone. There's more manual control versus more automation. It's really hard if you try to pick size because you get stuck a lot.

更简单的方式是先看到所有因素，然后你发现，也许现在我们做这个，但也许以后我们做另一个。

It's much easier to just look at everything, and then you figure out, maybe for now we do this, but maybe later we do that.

我们来稍微谈谈你个人的工作流程。你正在做这些探索，听起来你在探索的内容和实验的性质方面有相当大的自主权。那么跟我们说说你在自己的实践中什么时候会使用Cursor，Cursor和其他工具之间是否存在某种关联，特别是在你脑中想法的保真度处于不同阶段的时候？

Let's talk a little bit about your personal process. You're doing all these explorations. It sounds like there's a lot of autonomy in terms of what you're exploring and the nature of your experiments. So talk to us a bit about when are you using Cursor in your own practice, and is there any correlation between Cursor versus other tools as it relates to where you're at in the fidelity of the idea in your own mind even?

是的。因为我们是在构建软件，而代码就是材料，至少目前Cursor仍然是最适合做这件事的地方。你可以与代码互动，并完成其周围的一切事情。你没有任何限制，你可以做任何你想做的事情。

Yeah. Because we're building software and the code is the material, Cursor, right now at least, it's still the best place to do that. Like, to interact with the code and then do everything around it. You have no limitations. You can do whatever.

当你使用它时，随着你的代码库变得越来越复杂，Cursor也有越来越多的工具来覆盖所有这些情况。它可以从一个单一的小东西扩展到更复杂的大型项目。如果你观察人们在做什么，你会发现有人只是在Cursor里写文档，也许他们在做一些市场调研，或者写一些报告，它几乎可以做各种各样的事情。

And as you use it, as your code base gets more complex, Cursor has more tools to kinda cover all of those. It scales from, like, a single thing to, like, a more complex big thing. If you look at people, like, what they're doing, there are people who are just writing docs in Cursor. Maybe they're, like, doing some marketing research, doing some report. It's like doing all sorts of things.

因为代码就像是最底层的原始元素。甚至不是最低层，比如说不是汇编语言或机器码。但至少目前来说，它是我们可以几乎完成所有事情的层级。如果你从这个层级开始，围绕如何与任何代码库交互来构建一个系统，并解决大量困难的AI软件工程问题，这样代理就可以构建更复杂的软件，能自我检查错误，并在你使用过程中不断变得更好。

Because it's like code is it's like the lowest level primitive. It's not even the lowest. Say, like, it's not assembly or like machine code. It is, at least for now, the layer where we can do almost everything. If you start from that, like, from that layer, and you build a system around how to interact with, like, any code base and solve a lot of, like, hard AI software engineering problems so that the agent can make more complex software, check its own errors, get better as you use it.

那么构建上层就会容易得多，因为你已经解决了很多问题，比如传统程序员会遇到的错误无法修复的问题。现在这些错误可能根本不会出现。或者也许他们会看到一个更简单的、更适合他们的界面。不再是侧边栏加文件、编辑器、编辑器、聊天窗口这样的结构，它可以是任何东西。

Then it's much easier to build upper layers because you kinda eliminated a lot of problems that, say, like, a live coder would face. Say, like, instead of them seeing a error they cannot fix, the error is just not there anymore. Or maybe it's, like, they they will see some it's like a simpler alternative interface that fits them better. That is not the sidebar of files, editor, editor, editor, chat. It can be anything.

好的，我们先暂时记下这点。我想再深入一点。在你确定将‘待办事项’作为这些n个代理的基本单元之前，你那些探索是在哪里进行的？当时那些探索是在哪里发生的呢？

Alright. I'm gonna put a pin in that. I wanna go a little bit deeper because put me into the part of your explorations before you had arrived at the to do as the primitive for these you know, the n number of agents. Where were those explorations explorations happening happening then? Then?

你是在 Docs 里写东西吗？你是用 Cursor 来快速搭建界面的吗？还是用了别的工具？

Were Were you you writing writing in in Docs? Were you using cursor to spin up UIs? Was it something else?

我通常会使用任何适合问题的媒介。我经常在办公室里走动，然后用手机打开 Notion，把一些想法以列表、项目符号等形式记录下来。我会一边走一边写，可能会想到一些比较概念性的东西，之后再回头看看。有时候可能需要处理一个视觉上的问题，这时候我需要去摆弄一下。

I just use whatever medium that fits the problem. I do a lot of walks around the office, and I'm just on my phone with Notion, and I'm just typing ideas in like a list, bullet list or whatever. I'll just walk and I'll just write. I'll come up with like maybe they're more conceptual, and then maybe I go back. Maybe there's like a visual problem I need to play with.

我需要二维空间，需要精确的像素定位，而且我需要能够快速在不同的布局之间切换迭代，因为目前的工具无法通过真实代码或 AI 来实现这一点。所以我仍然会使用 Figma。在 Figma 中进行原型设计或制作界面非常困难，但用代码实现却非常简单。对于这些情况，我会使用 Cursor，直接写代码搭建出来，看看实际效果。

I need like two d space. I need exact pixel placement, and I need to, like, quickly iterate between different layouts and stuff because the current tools don't allow you to do that with real code or, like, with AI. So I still use Figma for that. So, like, it's super hard to prototype or mock up in Figma, but it's so easy to do it in code. Like, for all of those, I just use cursor, build build it out, see how it feels.

比如今天或者明天我们要发布的“停止和队列”交互功能，最初就是从 Cursor 中的一个简单原型开始的。我把它展示给其他人，大家都觉得不错，于是我们就把它开发出来了。

One example is the, like, the stop and queue interaction that we're gonna ship today or, like, tomorrow or something. That started just from, like, a prototype in baby cursor. I showed it to people. People were like, oh, cool. And then we built it.

我们还在做更多关于多智能体方面的功能，同样也会使用原型。因为当你在处理这些 AI 交互时，原型特别容易实现。因为

And then we're doing more, like, on the multi agent stuff. Also use, like, prototypes for that. Because it's just so much easier, especially when you're, say, doing these, like, AI interactions because

是的。

Yeah.

输入、输出、上下文、响应都在其中，每一个环节都很重要，你无法伪造它们。

The input, the output, the context, the the response was in it. They all matter. You just can't fake them.

你用了“感受”这个词，没错，对于停止队列来说，这正是唯一重要的东西。就是唯一关键的点。嗯嗯。我之前还和某个人在一条可能不该参与的公共评论里聊天，他说他完全不理解。

And you use the verb feel it. I mean, that's exactly it's the only thing that matters for stopping a queue. It's the only thing that matters. Mhmm. And I was even having a conversation with someone in a a common thread that I probably shouldn't have been in, but they were just like, don't understand.

比如，为什么你还要写代码？而你会说，兄弟，如果你正在做一个具有稳定 AI 输出的产品，那还好。但只要稍微有点复杂，想在 Figma 里推动它是完全不可能的。

Like, why would you need to do code? And you're like, man, if you are working on a product that has consistent AI output, there's Yeah. Anything even remotely close to a shot, it's impossible to move the needle in fig it's impossible.

没错。我只是觉得，未来的界面会变得更加动态。理想中的界面，对每个人来说都可能是不一样的。

Yep. Yep. I just feel, like interfaces will become just way more dynamic. It will become almost like the ideal interface is different for every single person.

好的，那我们就来聊聊这个话题吧。你之前发过一条我很喜欢的推文，谈到了未来人工智能的灵活性。是的，是的。所以可以分享一下你当时的想法，也许我们可以以此为线索，看看能延伸到哪里。

Alright. Let's talk about it then, because you had a tweet that I really liked where you talked about fluidity of future AIs. Yeah. Yeah. So share some of your thinking there, and maybe we can use that as a logic path and see where it takes us.

是的，这几乎就像你已经无法再用静态原型来设计一个东西了。我的意思是，那种过去的做法，就是画出一个静态画面，代表一个状态、一个你认为所有人类都能理解的理想状态，这种想法已经行不通了。我们作为设计师，可能会试图把一切都简化，把内容压缩、简化，确保这是最通用、所有人都能理解的东西，但也许这样反而会毁掉你的整个产品，因为它被过度简化了。

Yeah. It's almost like you just can't design a thing with mocks anymore. Meaning, like, there's just static picture of one state, one ideal state that you think every single human will understand. Like, that is just impossible. We, as designers, we can try to, like, simplify everything, dump dump it down, make sure that this is, like, the most universal thing people can understand, and then maybe you fuck up your whole product because you watered it down.

它可能不再具备某些人期待的那种魔力。说这个可能不太合适，但有点像 macOS 从 Liquid Glass 那种风格重新设计的转变。你有点强迫用户进入一个网格、一个模式、一个系统，而那个系统在特定的场景下并不合理，或者没有为鼠标指针、触控操作或视觉交互等进行优化。界面当初是为不同的交互方式而设计的，是有原因的。比如 iPhone 的按钮高度是 44 像素，而 Mac 上可能只有 28 像素左右。

Like, it doesn't do the magic that some people wanted anymore. Maybe it's not good to say, but it's almost like the Mac OS redesign from Liquid Glass. It's like, you kind of force people onto this grid, onto this pattern, onto this system that doesn't make sense for that context, or is not optimized for, say, cursors, like mouse cursors versus, like, tap or vision, whatever. Like, the interfaces were designed differently for a reason. Like, I iPhone buttons are, like, 44 pixels tall versus, say, like, on Macs, it's like, I don't know, 28.

但每个人的想法、说话方式都不一样，他们与世界、他人以及他们正在思考或做的事情之间的互动方式也各不相同。我经常和很多工程师合作，他们之间也有很大差异。有些工程师已经完全进入代理（agent）的世界了，但还有一些人仍在手动敲代码。

But every single person thinks differently, talks differently. They have different preferred methods of interacting with the world or other people or the thing they're thinking about or the things they're doing. I work with a lot of engineers. Even the engineers are so different. Some engineers are already fully in the agent world, but some of them are still typing code manually.

有些工程师完全依赖键盘操作，比如 Vim 用户和 Emacs 用户之间的区别。但也有很多人就是喜欢用鼠标点击。比如，如果你看看 Twitter 上昨天的一条推文，我认识的最厉害的程序员之一 Jared，他在 Button 公司工作，他说：‘用桌面端应用吧。’

Some of them purely use the keyboard. So, like, you know, all the Vim users were, like, Emacs. But also, there are a lot of people just click. Like, if you look at Twitter I I saw a tweet from yesterday. Like, of the most crack coders I know, Jared, who works on, like, at Button, he said, get a desktop, the app.

那是查看这个内容的最佳方式。

That's the best way to see this.

哦，哇，我都不知道工程师还能这么说。

Oh, wow. I didn't know that was legal to say as an engineer.

太疯狂了。

That's crazy.

这让我感觉好多了，是的。

I feel so much better about myself. Yeah.

是的，是的。所以我的想法是，我不想把自己的偏好强加给别人。我希望能满足所有人的需求，理想情况下是这样。我们可能会舍弃其中的一部分，但理想情况下，大多数人使用时都会觉得这个东西是为他们而设计的。

Yeah. Yeah. So it's like, I don't want to impose my preference onto people. I want to satisfy all of them, ideally. We might want to cut some parts of it, but ideally, like most people, when they come in, they can feel like this thing is for them.

但那样做的话，就意味着界面会改变，而且它会变成人们可以用一百万种方式来使用它。这时候你就需要设计一个底层架构，能够容纳各种不同的配置和定制。你希望向不同的人提供多少选项？不同的人会得到哪些默认设置？

But then there's, like, in order for you to do that, that means the interface will change, and it will be, like, people can use it in a million ways. Then you need to kinda design, like, a low level architecture where, you know, you can fit all these different configurations and customizations. How much do you want to offer to different people? What are the different defaults people get?

我一直坚信视频在传达我的设计理念方面具有强大的力量。所以当需要获取反馈时，我会在Slack里发一个Loom的链接，还有一个Figma原型的链接，然后反馈就散落在各处。这简直一团糟。所以我正在打造我一直希望存在的产品，叫做In Flight。你可以把它看作是一种异步的设计评审。

I'm a big believer in the power of video to explain my thinking as a designer. So when it's time to get feedback, I'll drop a Loom link in Slack and another link to a Figma prototype, and and feedback will be scattered everywhere. And, mean, I it's a mess. So I'm building the product that I've always wanted to exist, and it's called In Flight. You can kinda think of it like an async crit.

它能轻松地分享视频演示，同时附带一个交互原型，或者任何你在设计的内容。然后AI会采访你团队中的成员，为你收集所需的反馈，并将所有内容整理成一个美观的洞察页面。目前我只向Dive Club听众开放访问权限。如果你想成为首批使用In Flight的人之一，请访问dive.club/inflight来抢占名额。我不记得具体是什么时候了。

It's an easy way to share a video walkthrough along with an interactive prototype or whatever you're designing. And then AI interviews the people on your team to get you the feedback that you need and organizes everything for you in a beautiful insights page. So right now, I'm only giving access to Dive Club listeners. So if you wanna be one the first to use In Flight, head to dive.club/inflight to claim your spot. I don't remember when it was.

也许是一段时间以前，你曾谈到一个产品要经历哪些变化才能跨越不同的规模化阶段。你大致讲到，当发展到每个人都必须使用这个产品的时候，它就会失去一些灵魂。

Maybe a while back, but you talked about what has to happen to a product to make the jump toward different phases of scale. And you basically talked about how if you get to the point where everyone has to use the product, you lose a little bit of soul.

是的，没错。

Yeah. Yeah.

听起来，在你看来个性化就是解决这个问题的方法。也许很多模型带来的可能性，让我们能够在触及十亿用户的同时，依然保留那种灵魂和工艺感。那么，要实现这个目标，还需要做些什么？

Yeah. So it sounds like personalization is the antidote in your mind to that, and a lot of potentially maybe what the models are making possible allows us to achieve that level of soul and craft while reaching, you know, a billion people kind of thing. Yep. Yep. What needs to happen to get there?

比如，作为以某种方式掌舵的那个人，你觉得我们离目标还有多远？作为一名设计师，当你把个性化作为最终目标时，你在思考哪些类型的问题，来跨越这个鸿沟？

Like, as the person in, you know, some shape or form steering the ship, like, how close are we? What types of things are you thinking about as a designer with personalization being the end goal that you're trying to cross that chasm?

我们在这个方向上甚至还没真正开始。就像我之前说的，当你把Cursor的按钮开放到三个时，我们作为设计师所设计的东西，其实就上升了一个层级。你不再设计某个UI组件具体长什么样子，或者按钮的顺序和位置，而是设计一个容器。这些就是我整个系统中的模式。

Yeah. We haven't even started yet on this one. As I said, like, when you open up Cursor to three buttons, the things we design as designers, they just kinda go up one level. Instead of you designing exactly how this piece of UI will look, the order of buttons where they are placed, you are actually designing a container. These are the patterns in my whole system.

它们之间会相互转化。比如在Cursor中，当你选中文本时，会有一个小输入框弹出，按下Command+K就会出现这个小输入框。然后旁边还有一个聊天窗口。这个聊天窗口也可以作为完整的编辑器打开，变成一个完整的窗口。

And then they translate between each other. So like in cursor, you know, we have like a little input when you select text. You command k, there's like a little input. And then there's like a chat on the side. The chat on the side can also be opened as a full editor, then it becomes like a full window.

这些在概念上其实都是同一个东西。但在不同的场景下，比如网站、移动端或后台代理中，你可能会赋予它们不同的形式。关键在于，这个系统中最核心的模式和理念是什么？以及它们所有可能的配置方式。

There is the same thing, maybe like in the background agent on the website on mobile. All of them, conceptually, they are the same things. But maybe you give them different forms, depending on, you know, where you are doing the thing. What are the most essential patterns and ideas in this whole thing? And then all of their possible configurations.

那这个列表是有限的吗？比如，作为这种未来状态的光标设计者，你是否在这里列出了所有的基础功能？是的。它们的组合方式可能只是标准的阶乘式组合。在那种未来状态下，当你思考个性化的上限时，有没有空间让人工智能动态生成输出、界面或组合？在你看来，这方面的影响有多大？

Is that a finite list then? Like, as the designer of this future state of cursor, are you coming up with here are all of the primitives Yep. They can be combined probably in in it's probably just a a standard factorial at that point. In that future, when you think about the ceiling for personalization, is there room for dynamically generated output or UIs or combinations from an AI? Like, how much of that is a factor in how you see this going?

这是可能的，但我不认为让人工智能随意生成界面，比如连工具的创造者都无法控制或预测其行为是一件好事。这只会带来更多混乱。是的。比如，当你打开 Cursor，你可能不会看到三个按钮，而是根据我们对你的了解，比如你从事的项目类型，或者你告诉过我们的一些偏好，AI 可以为你重新配置整个 Cursor。也许它会把界面完全颠倒过来。

It's possible, but I don't think it's, like, arbitrary generating UI that, say, even the creators of the tool cannot control or cannot predict is a good thing. It just creates more chaos. Yeah. Plus, Say, if you come into cursor instead of seeing the three buttons, maybe based on what we know about you, what kind of projects you work on, maybe you told us some of your preferences, and then the AI can kinda reconfigure the entire cursor for you. Maybe it flips it upside down.

也许你看到的只是一个画布，你可以画一些东西，然后砰的一声，你的想法就出现了，而不是一个矩形的框变成一个可以交互的真实组件。或者你可能纯粹是个程序员。

Maybe all you see is like this I don't know. Like a canvas where you can draw stuff and then boom. Your your idea instead of like a I don't know. Like a rectangle thing turns into like a real component you can play with. Or maybe you're like a pure coder.

你进入 Cursor 后，看到的可能只是一堆终端界面。为什么不呢？对吧？但你仍然在使用 Cursor，只是通过一种不同的形式。

You come into cursor, all you see is, like, terminals. Why not? Right? But then you're still using cursor. It's just through, like, a different form.

你依然在操作所有相同的底层基础功能，而且它们并不多，实际上非常少。我认为，尤其是对于 AI 来说，如果你现在构建了太多抽象层，你可能会陷入困境，因为其中很多抽象可能没有意义。但有一些东西是永远不会改变的。

You're still touching all the same low level primitives, and there's not a lot of them. There's actually very few of them. And I think, especially for AI, if you build too many abstractions now, you're gonna get fucked because a lot of them will not make sense. But there are certain things that will never change.

这是一个很好的观察角度。从 Notion 出身的背景来看尤其完美，因为未来我们使用的许多工具中，AI 将在每个人所看到的形式和结构中扮演重要角色。而我们能够从每个用户身上提取的上下文信息量，相比过去可能要高出 100 倍，这背后有模型的支持。因此，现在为 AI 设计一套合适的模块，让其能够根据每个用户的需求动态使用，这在数字产品设计史上可能比以往任何时候都更加重要。

It's a good way of looking at it. What a perfect background coming from Notion, you know, because it's like how many of the tools that we use in the future will have AI playing a large role in the form and the shape that it takes for any individual person. And just even the amount of context that we'll be able to extract from each individual user is, like, a 100 x Okay. With models behind the scenes. And so coming up with the right set of blocks for AI to wield for each user dynamically probably is more important now than at any point ever in in designing digital products.

是的。但我想说的是，我们所交互的形式并没有太大变化，而且它们也不会

Yeah. But I would say, like, the forms that we interact with, they they haven't changed much. And they don't

待办事项清单。

To do list.

差不多就那样。是的。人们处理信息的方式各不相同。可以是视觉化的，也可以是列表形式。

That much. Yeah. Different ways people process information. Could be visual. Could be like a list.

可以是卡片形式，也可以是表格形式，或者任何其他形式。但真正取决于你在做什么，你是谁。

Could be like a card. Could be like a table. Could be anything. But it really depends on what you're doing, who you are.

好的，嗯，在给你机会谈谈Rigos之前，我不能结束这次通话，因为

Alright. Well, I can't end this call without giving you an opportunity to talk about Rigos because

大家

people are,

你知道的，在推特上人们因为各种原因彻底爱上了它。我的意思是，这真的很好玩。甚至在这次通话之前，我就在试着使用它，和里面的聊天、iPod以及各种功能玩得不亦乐乎。你之前也谈到过自己开发操作系统这件事，把它当作一种‘吃自己做的狗粮’（自用测试）的价值体现。但我觉得背后应该还有更深层的动力吧。

you know, completely in love with it on Twitter for every reason. I mean, it's it's really fun. I was even playing around with it before this call and doing all the chats and iPod and everything. And you spoke to the value of building your own operating system as an exercise in dog fooding. But, like, there's gotta be a little bit more of a deeper motivation.

那么，你是从哪里获得灵感的？你为什么愿意花时间在凌晨三点做这些类似Slack的小玩意儿呢？是的，说说看。

And, you know, where's the inspiration come from? Why do you spend time doing this and making your own mini slacks at 3AM, basically? Yeah.

这个项目一开始完全是出于偶然。我先是在他们的平台上开发了第一个应用，也就是Soundboard（声音板）应用。如果你打开它，会发现里面有一些我预先录好的声音片段。我制作了

So how this thing started was, like, pure accident. I built the first app in their, the Soundboard app. And then if you open it, it's like, there's some prerecorded sounds of me making noises. I built

那些声音是你自己录的？

Those are you?

是的，是

Yeah. There's I

我之前还真不知道。

didn't know that.

对，就是我自己录的声音。我当时这么做是因为我即将离开Notion，想让我团队的人能继续听到我的声音

Yeah. Was, like, me making noises, and then I did this because, like, I was leaving Notion, and I want, like, my team to have my voices

挺酷的。

That's cool.

会议。一开始它就像一个React、Chat、CNN、Tailwind CSS应用。很普通。功能上是对的，但看起来非常丑陋。

Meetings. It started as, like, a React, Chat, CNN, Tailwind CSS app. Like, generic. It was, like, functionally correct. Looks very ugly.

然后我就说，让它看起来更像复古的Mac OS一些。然后它就从谷歌上随便找了个像素字体。还是很丑，但你能看出它想做什么。接着我说，把它放进一个窗口里。然后它放了一个非常差劲的破窗口进去。

And I I just said, make it more like retro Mac OS y. And then I think it pulled some random, like, pixel y font from Google. Still very ugly, but you can get a sense of what this gonna do. And then I I was like, put it in a window. And then it put in a really bad, crappy window.

然后我说，做一个菜单栏。它就做了一个菜单栏。然后我就想，这玩意儿为什么只有一个应用？看起来像个操作系统，却只有一个应用。然后我做了第二个应用，也就是Internet Explorer应用。

And then I said, make a menu bar. And I made a menu bar. Then I was like, why the fuck does this thing only have one app? It looks like an OS, but it only has one app. And I built the second app, the Internet Explorer app.

一开始它只是一个浏览器。看起来像浏览器，有一个工具栏，但其实只是一个输入框和一个iframe，我就把它叫做应用。但当我这样做的时候，就好像我问了代理（agent），然后和代理一起重新设计了整个操作系统架构。比如，我怎么处理多个应用？怎么实现多个窗口？

It started just from it's just like a browser. It looks like a browser with a bar, but all it is is just an input and an iframe, and I called it an app. But then when I did that, it's almost like I asked the agent, and with the agent, we kind of redesigned the whole OS architecture. Like, how do I handle multiple apps? How do I, you know, have multiple windows?

有窗口的前后置、背景化。你知道哪个窗口是激活的，哪个不是，可以拖动窗口、调整窗口大小，管理所有应用的状态，让它们以相同的方式保存到本地存储中，这样当你关闭网站再打开时，所有状态都还在。然后我说，加一个文本编辑器吧。因为我当时在做Notion那样的东西。所以我做了一个文本编辑器，它还有类似斜杠命令之类的功能。

There's, like, window foregrounding, backgrounding. There's, like, you know, which one's active, which one's not, dragging them around, resizing windows, managing all the app states so that they're stored the same way, putting it in local storage so that when you close this website and open it again, all the states are remaining. And then I was like, let's add a text editor. Because I I was making Notion. So I made a text editor, and then it has, like, slash commands and stuff.

然后我又想，如果聊天内容可以写入文本编辑器呢？我就这么做了。没有计划，纯粹是感觉。

And then I'm like, what if the chat can write into the text editor? So I did that. No plans. Pure vibes.

你觉得是不是因为你对想法的执行力很强？在通话开始前我自己也问过这个问题。因为我之前在刷推特，我发了一条帖子，很多人留言提问。

Do you think it's just that you're quick to act on ideas? Like, I was asking myself that before this call started. Because I was going through Twitter. Right? I I made a post, and so many people commented asking questions.

他们很多问题都在试图挖掘，比如iOS的灵感来源是什么？而我想的是，不是这样的。很多听众并不是说你比他们更有创造力，而是到底有什么不同？你知道吗？

And a lot of them were trying to dig at, like, you know, what's the inspiration for iOS? And I'm like, you know No. So many of the people listening, it's not that you're that much more creative than all these people. It's like, what's the difference? You know?

我猜测，你可以自己确认或否定这一点，对你来说，从想法到第一次输出之间可能几乎没有时间间隔，然后它就自然展开了。

And and my hunch, and you can, you know, confirm or deny, is that there's probably not a lot of time for you between idea and that first output, and then it just Yeah. Lets it unravel from there.

是的。我加入Cursor的原因之一就是，我想让从产生想法到实现想法之间的差距尽可能接近于零。有了Cursor，我真的可以做到这一点。我可以几乎实时地实现想法。现在我能做的事情甚至比以前一个工程师能做的事情多得多。

Yeah. One of the reasons I joined Cursor is I want the gap between have an idea and it becoming reality, getting that closer to zero. And with Cursor, I can do that. Like, literally, I can do that. It's almost like now I can do way more than, like, it's almost like any single person was capable of before, even as an engineer.

我写了大部分的Real OS代码，我自己都不太相信，大部分代码是一两个月内完成的。现在大概有13万行代码。哇。我还问了，我想我问过Chat GPT，一个普通的工程团队需要多久才能完成这样的项目。它的回答大概是，对于一个几十人或者二十人左右的团队来说，可能需要一个月甚至好几年。

I wrote most of the Real OS code, I don't know, like most of it in like one or two months. Right now it's like a 130 k lines of code. Woah. But and I asked like I think I asked Chad GPT like, how long it would take for, like, a normal engineering team to build it. It's, like, month or years for, like, tens of people or, like, 20 something.

而我只是一个人，业余时间在做，一边听着音乐一边写代码，就是一些随机的想法。

It's just me by myself on the side, vibe coding, just random ideas.

我们目前正在招聘。今天下午，我们和一位工程师进行了交流。我们正在讨论未来一年我们核心团队的构建策略。Cursor彻底改变了我们的这个思路，因为我们有两个设计师，这意味着我们只需要两个前端工程师就可以了，你知道的。

So we're hiring right now for in flight. And this afternoon, we were talking with an engineer. And we're kinda just working through the strategy of what's the core team that we wanna have for the next year. And Cursor has fundamentally changed that equation for us because we have two designers, which means we have two front end engineers. You know?

当你不需要一个非常精通前端的人时，你所需要招聘的工程师类型就发生了变化，因为我自己就可以完成我们正在开发的功能。这简直太棒了。

Like, the types of engineers that you even need to hire change when you don't need someone to be super front end savvy because I can just finish whatever feature we're working on. It's amazing.

我认为这种情况会发生在越来越多的人身上，而过去十年左右我们所经历的过度专业化将完全不再有意义。这有点像，只要你懂得如何与AI互动，就有点像是让大家重新站在同一条起跑线上。我的意思是，我看到很多比如17岁的孩子用AI一边听着音乐一边写代码，做出的东西比一些在大科技公司每天只写10行代码的工程师疯狂多了。现在这些年轻人正在AI的边缘不断尝试，不断探索。

I think that will just happen for more people, and then the over specialization that we had over the last ten years or so just complete does not make sense anymore. It's almost like everyone if you know how to interact with the AI, it's almost like releveling the field a little bit. Meaning, like, I see a lot of, say, 17 year olds vibe coding with AI doing way crazier things than, say, some engineer at, like, big tech doing 10 lines of code a day or ten. You know, all these people right now, they're playing with AI on the edge. They keep poking at it.

他们知道该怎么做。也许他们是在很短的时间内完成的，因为工具本身也在变得非常快，但他们已经领先了一大步。相比之下，如果你还在考虑也许我们需要做周计划、开各种会议、坐在会议室里、吃午饭、无所事事，那对你来说情况可能不太妙。

They know what it is. Maybe they did it within, like, a pretty short time span because the tools are also, like, getting really fast, but they're, like, pretty ahead. Versus if you are still thinking, maybe we need to do, like, I don't know, weekly plans, standoffs, meetings, certain rooms, eat my lunch, do nothing. It's gonna be bad for

祝你好运。

you. Good luck.

是的，我们

Yeah. We

之前谈到了Cursor在创意和实验阶段所扮演的角色，但你能稍微讲讲你在开发Cursor的过程中是如何与工程师协作的吗？还有，你多长时间会参与一次产品代码的开发？这种情况发生过吗？什么时候发生？

talked about the role that Cursor plays in more of the ideation experimentation phase, but can you talk a little bit about how you collaborate with engineers at Cursor while building Cursor? And Yeah. How often are you contributing production? Is that something that's happened? When does it happen?

这个流程中的这部分具体是什么样的？

What does that part of the process look like? Yeah.

举个例子，比如我自己就不一样。我们有一位其他设计师，他的名字叫 Ricky。他之前也在 Notion 工作，是一个非常专注于设计系统的专家。

One example is not even, like, for myself. So we we have another designer. His name is Ricky. He was also from Notion. He's, a really big, like, design system guy.

他特别喜欢在 Figma 里制作组件相关的内容，比如所有的颜色标记、样式、组件、嵌套组件，以及各种不同的状态等等。他加入之后，就开始用以前的习惯做事，比如把所有东西整理干净，画出原型，让它们在视觉上达到完美，我觉得这也是非常重要的。但这更像是一个只需要做一次的事情。

Like, he loves making componentry stuff in Figma. All the color tokens, styles, components, nested components, all the different states and stuff. He joined, and then he started there, you know, kinda like old habits. Like, just clean up everything, mock them up, make them, like, visually perfect, which I think is really important too. But it's almost like a thing that you only do once.

所以他做了这些事情，然后我们开始重新架构和设计所有的设置页面，包括设置和仪表盘。他在 Figma 里做了大概两周左右，我当时就在想，你在干嘛？要不我们直接试着用 vibe 编码实现吧。

So he did that. And then we started, like, rearchitecting and redesigning all of our setting pages, like, the settings and the dashboard. So he did that in Figma for, like, maybe, like, two weeks. And I was like, what are you doing? Like, let's just, like, try vibe coding it.

工程师们对这个怎么看？

What do the engineers think about this?

有很多问题。你知道吗？他们很喜欢这种方式？

That's lot

是的。

of question. You know? They love it?

是的。

Yeah.

他们现在觉得我们更像是他们中的一员。你能解释一下吗？我开始在不了解设计师、工程师、产品经理等角色区别的情况下就动手做东西。我自己直接设计、自己编码。

Yeah.

后来我成为了一名设计师，却觉得整个流程完全说不通。我的意思是，设计师只是负责画图的人，而工程师需要根据这些图来完成开发。但事实上，设计师画完图后，工程师却需要根据这些图来设计整个架构，每一个部分，然后完成整个产品的构建，这显然不合理。

They see us more like part of them now, which is Explain that. I started building things without knowing the distinctions between a designer, engineer, a PM, whatever. I just made stuff myself. I designed the thing in my mind. I coded it.

And then I became a designer, and I just felt this whole thing doesn't make sense. Meaning, like, the designers are the people who draw pictures in the the pixel states, And then the engineers need to, like, say, okay. Great. Given these pictures, now you kinda designed the whole architecture, every piece of it, and built the whole thing. That doesn't make sense.

And then I became a designer, and I just felt this whole thing doesn't make sense. Meaning, like, the designers are the people who draw pictures in the the pixel states, And then the engineers need to, like, say, okay. Great. Given these pictures, now you kinda designed the whole architecture, every piece of it, and built the whole thing. That doesn't make sense.

这就像，这是同样的问题，同一个谜题，只是谜题的大小不同，是对同一事物不同层次的抽象。如果你这样来切割，最终得到的可能是一个很奇怪的东西，而它本可以变得好得多。这让我很自然地回想到，在我之前，Cursor里根本没有设计师，因为人们只是为自己而构建产品，他们为自己设计。我认为这很棒。

It's like this is the same problem, same puzzle, different size of the puzzle, different layers of abstraction of the same thing. If you slice it like this, it will end up in a weird thing when it could be something way better. It's a good segue back to before me, there were no designers at Cursor because people just built for themselves. They designed for themselves. And I think it's great.

就是说，Cursor之所以能走到今天，就是因为我们打造了最适合程序员的AI工具。我认为我们有一个非常优秀的团队，我们几乎是在打造最强大的AI工作流程，它涵盖了所有手动的编码环节。但这仅仅是个开始。当你想要覆盖更多用户时，你需要让系统能够适应更多不同的操作方式、不同的可视化呈现和不同的抽象层次。

It's like, that's how Cursor got here because we built the best AI tool for programmers. I think we have a really good team, and then we're almost building the most cracked AI workflow that involves all the manual, you know, coding. But it's like, that is just the start. But as you expand to more people, you need to make the system, you know, accommodate more ways of doing things, different visualizations, different abstractions.

这正是我想说的。你的故事恰恰体现了设计师的价值。对吧？当有一群人只是为自己构建产品的时候，真正需要的是一个设计师进来，理清复杂的逻辑，创造出一个可以扩展到更多用户群体之外的解决方案。

That's what I was gonna say. What your story speaks to the value of the designer. Right? Like, since you have a bunch of people building for themselves, but it was the designer required to come in, untangle complexity, and create a solution that could scale to more people outside of themselves.

没错。就像我们有这么多出色的工程师，但他们在某些方面其实也挺懵懂的。他们能解决整个问题中最难的部分，却可能忘了去建造‘门’。或者说，他们忘了让过去的内容自然地融入整体。也许我们本该只做一个东西，而不是做五个东西。

Exactly. It's like we have so many great engineers, but they're kinda clueless in some way too. It's like they they build the most hard part of the whole problem, but they forget to build the doors. Or they forget to make the past flow into the same thing. Like, instead of building five things, maybe we should just build one thing.

其实我们只需要一个东西，但它可以有n种，或者一百万种不同的呈现方式。我认为这正是设计师，甚至软件架构师所要做的事情：设计事物的边界，设计概念之间如何协作。而不再是像以前那样一层层地推进——你必须先从战略层面开始，写一份庞大的文档，分享出去，然后让产品经理写出更具体的需求和任务，拆分任务，进行长时间的规划会议，再把任务分配给工程师，让他们像写代码的猴子一样各自完成任务。我们不需要所有这些流程，我们就是建造者。

It's just one thing that has, like, n or, like, a million different ways to see it. And then I think that is what I think, say, designers or even, like, software architects will be doing. Like, you're just kinda designing the the the boundaries of things, how the concepts work together. And instead of doing that layer by layer like before, meaning you have to start with the, I don't know, the strategy, you write a giant doc, share it out, and then get some PMs to write more specific, like, requirements and tasks, split the tasks, do some long planning session, split the tasks to the engineers, let them do each of them like coding monkeys. Instead of all that, we're just builders.

我们有想法，我们想一起打造最好的产品。也许我更偏向艺术感，也许我更多地负责视觉部分。也许你更关注数据模型，或者机器学习方面的东西。

We have ideas. We want to build the best thing together. Maybe I'm more artsy. Maybe I do more visuals. Maybe you think about the data model more, or like the ML stuff.

其实我对机器学习了解不多，但你们一起完成了整个拼图。当所有参与的人都能写代码时，角色和头衔已经不再重要了。

I actually don't know much about ML stuff, but you're kind of completing this whole puzzle together, and the roles, the titles just don't matter anymore when these people, all of the people involved, get to write code.

我们之前谈到了系统思维的部分。

We talked about the systems thinking piece.

嗯。

Mhmm.

除此之外，在一个每个人都能用代码表达和贡献想法的世界里，你觉得设计师还能带来哪些真正持久的、不可替代的技能？

Aside from that, in a world where everyone can write and contribute ideas in code, what are the other really durable skills that you think define what a designer brings to the table in that world?

没错。我觉得这真的要说到，如果你退到最远、最高的层面来看，其实就是你如何解读这个世界，你如何看待周围的事物，以及你所使用的概念。因为我们大家都不一样。有些人可能特别擅长深入的细节，但在高层次方面可能稍弱一些。而有些人则更擅长宏观层面的东西，但在具体操作上可能没那么灵巧。

Right. I think it's really about like, if you pulled all the way up, like the most high level, it's really just how you interpreted the world, how you viewed the things around you, the concepts that you're working with. Because, you know, like we're all different. Some people are more like, maybe they're really good at some really deep detail, but maybe less on the high level. Some people are more, like, really good at high level stuff, but maybe they're not as crafty.

有些人可能非常擅长底层代码，但在设计用户界面时，他们只想把按钮到处乱放，结果让用户完全摸不着头脑。但归根结底，我们所做的一切都会体现在高质量、运行顺畅的软件上。这也就是理想状态下，所有人共同努力想要达到的目标。而在这之前，人们不得不依赖一些非常原始的方式来沟通、协调和合作。我认为问题的关键在于，这些角色、这些专业分工，每个人都有自己独特的思维方式，几乎就像是各自脑海中的宫殿一样。

Some people maybe are, like, really good at, like, low level code, but then when they build the UI, they just want to throw buttons everywhere and then confuse the shit out of the people. But it's like all we're doing at the end results in beautiful quality software that works. That is, you know, the ideal state of all like, the sum of all these people where they want to get to. And then it's almost like before cursor, these people had to rely on, like, really archaic ways to communicate and to align and to work together. And then I think the problem is actually this is, like, each of these roles, each of these specializations, they think differently in their own, almost like a mental palace.

我们设计师说话可能是视觉层次、字体、间距、颜色之类的。而工程师们说的可能是后端的一些东西。但归根结底，我们其实做的是一回事。比如，后端生成了一条需要在界面上显示的消息，最终它还是要通过像素来传达给用户。

It's like we talk in, I don't know, visual hierarchy, typography, spacing, colors. The engineers talk in, like, I don't know, some back end y stuff. But, you know, it's all the same thing at the end. Like, the back end is generating some message that you need to display in the UI. It will be communicated through pixels.

也许将来某一天我们会实现脑机接口。但不变的是你构建东西的方式。比如，你是怎么思考的，怎么拆解问题的，又如何通过人与人工智能协作，甚至代码本身，把你想要的东西重新组合起来。有些人认为，打造一个只专注做一件事的单一用途工具才是最好的。但我不是这么想的。

Maybe at some point, we'll get to, like, brain computer interface. But, you know, what doesn't change is how you build the thing. Like, how you think about it, how you break it up, how do you tie them back together with people and AI and, you know, to code themselves, what you want the thing to be. Some people think, ah, building like a single purposefully built thing that only does one thing is great. I don't think like that.

你会有不同的偏好，不同的做事方式，而这些差异可能正是造成最终结果不同的关键所在。

Then you have different preferences, different ways of doing things, and then those might be what makes the difference.

我们已经聊了很多话题了。我决定把最后一个问题交给Rio S来提。

We've covered a lot of ground. And I decided to outsource my final question to Rio S.

好的。

Yes.

我之前和虚拟版的你聊过。是的。我问了一个问题，我的提示是：Uriel，有什么最有趣的问题可以用来结束这次对话？

And I I was talking with the virtual you earlier. Uh-huh. And I was asking, and my prompt was basically, Uriel, what is the most interesting question that I can ask to end this conversation? And

是什么问题？

What is it?

你对人机交互（HCI）的未来有什么看法，听起来可能有点疯狂，但你仍然坚信它是正确的？

What's something that you believe about the future of HCI that sounds a bit insane, but you still believe it's true?

界面会变得就像你思考的方式一样。我认为它会越来越贴近你自己。意思是，也许我们不再通过代理设备进行操作，而是更加贴近，比如说，我是一个视觉型思考者。

The interface will just become, like, how you think. And I think it will just get closer to you. Meaning, like, maybe we don't operate from, like, proxy devices. Maybe it's even closer. Say, like, I'm a visual thinker.

我仍然会看到我那些类似画布的内容，但它们可能就像浮现在我的脑海里，像是在屏幕上一样。

I'll still see my, like, Canvas stuff, but then maybe they're floating in my mind and stuff, like, on a screen.

是的，这确实是一个令人惊叹的功能。

Yeah. That's a trippy feature.

你有没有看过Neuralink最新的展示？是的，他们现在已经可以通过大约一千个电极，在你的视野中绘制图像。是的，太疯狂了。

Have you seen the new, like, Neuralink, like, presentation? Yeah. Like, they can already, like, with, like, I think a thousand electrodes, draw stuff in your vision field. Yeah. It's crazy.

很难不让人惊叹，这彻底改变了我们对设计师的定义。在这个世界里，设计师到底意味着什么？你知道吗？有多少东西会被取代？太疯狂了。

I mean, it's hard not to just be like, what? The I mean, the whole definition of what we think of as a designer in that world is just what does it mean? You know? How much is over? It's crazy.

仍然需要有人提出概念，甚至为事物命名。什么是

There's still someone coming up with the concepts, how you call things even. What are

语言的重要性。天哪，你说得对。

The importance of language. Oh my gosh. You're right.

这实际上是我现在工作的一个重要部分，就是把那些应该一致的概念和想法，简化成最简单、不变的形式。

It's like that is actually, like, a a big part of my job now. It's, like, clarifying concepts and ideas that are supposed to be the same into, like, their simplest form that doesn't change.

布里奥，这次交流太棒了。感谢你花时间和我一起畅聊你脑海中的各种想法。看到你的工作方式真的非常有趣。现在了解了你对这个产品的影响之后，我比一开始更感激你接受这个职位了。作为用户和观察者，看着这一切的发展都是一件非常愉快的事情。

Well, Brio, this has been amazing. Thank you for hanging out and geeking out on all of the things in your brain. It's been really, really fun to see how you work. And I I'm even more appreciative that you took this role than I was at the beginning of this knowing now the impact that you've had on this product. It's really been a joy to watch both as a a user and a observer.

期待继续在推特上关注你啊，兄弟。

Excited to keep following you on Twitter, man.

谢谢。

Thank you.

在让你离开之前，我想花一分钟时间向你介绍我最喜欢的产品，因为我经常被问到我的工具栈里都有什么。我用 Framer 来构建网站，用 Genway 来做研究，用 Granola 在评论时做笔记，用 Jitter 来为我的设计添加动画效果。

Before I let you go, I wanna take just one minute to run you through my favorite products because I'm constantly asked what's in my stack. Framer is how I build websites. Genway is how I do research. Granola is how I take notes during crit. Jitter is how I animate my designs.

Lovable 用来用代码构建我的想法，Maven 用来寻找设计灵感，Paper 用来像创意人员一样进行设计，而 Raycast 则是我每一步都在使用的快捷工具。我已经精心挑选了这些产品，这样我就可以全职制作这些节目。因此，支持本节目的最佳方式就是去查看这些产品。

Lovable is how I build my ideas in code. Maven is how I find design inspiration. Paper is how I design like a creative, and Raycast is my shortcut every step of the way. Now I've hand selected these companies so that I can do these episodes full time. So by far, the number one way to support the show is to check them out.

你可以在 dive.club/partners 找到完整的列表。

You can find the full list at dive.club/partners.