Cursor：为设计师打造的 AI 代码编辑器

欢迎收听 Dive Club。我是 Rid，这里是设计师永不停止学习的地方。本周的嘉宾是 Ryo Lu，你可能在之前我们聊早期 Notion 和系统设计的那期节目里听过他。但自那以后，Ryo 加入了 Cursor 担任设计主管，而 Cursor 无疑是当下科技界最具影响力的公司之一。所以，我们将深入了解 Cursor 的设计运作方式，以及 Ryo 所有疯狂的 AI 实验。话不多说，让我们开始吧。

Welcome to Dive Club. My name is Rid and this is where designers never stop learning. This week's episode is with Ryo Lu, who you might have heard on an earlier episode back when we were talking about early Notion and systems design. But since then, Ryo's 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 going to get an inside look at how design operates at Cursor and including all of Ryo's crazy AI experiments. So, without further ado, let's dive in.

Cursor 的人第一次联系我是在去年八月，那时智能体还没出现。Cursor 的产品路线是：他们从 Tab 开始，就是代码自动补全，比 GitHub Copilot 好很多。然后去年初我们做了聊天功能，你可以在聊天里问 Cursor 关于代码库的问题，它会回答，但不会帮你做什么。接着七月他们加了 Composer。Composer 就是聊天现在可以实际为你写代码，然后你可以修改代码。所以他们那时联系了我。我们聊了一下，我觉得挺酷的。但我当时还是觉得 Cursor 主要是给程序员用的工具。现在也还是，但它已经变了很多，我当时想我还是继续做我的 Notion 主题吧，因为我想为每个人做点东西。

Cursor people first reached out like August last year. That was before the agent existed. The Cursor product trajectory, they started with the tab. It's like auto completion for code. It's like a much better GitHub copilot. Then we did the chat like early last year and then in the chat you can ask cursor about the codebase 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 kind of like now the chat can actually write code for you and then you can modify code. So they reached out to me back then. We talked a little bit. I thought oh cool. I still thought cursor back then is like a tool mostly for coders. It is still but it has changed so much since I thought oh I'm just still going to do my notion theme cuz I want to make something for everyone.

然后去年十一月左右，我们在 Notion 做规划，规划一个我长期在做的多年项目。结果计划是我们要在今年下半年才做。我很生气，因为我想做这个可能从我加入 Notion 就开始了。我先去了 Vzero，做了个小原型，是一个用 Next.js、React、Tailwind CSS 做的未来 Notion 应用。然后我玩了几轮，卡住了。我想做更多但做不了。于是我就下载了应用，打开 Cursor，用了智能体。花了好长时间才找到智能体在哪，然后我就上瘾了。我连续做了三天，就搭出了整个未来 Notion 的原型，完全是我脑子里想要的样子。我建了一个菜单，可以开关每个新功能，就像一个功能开关菜单，全部关掉，然后你可以看到整个应用变化。它有真实数据。有个很酷的东西是我建了一个 3D 地球视图，但想法是，在 Notion 里我们有看板、表格、画廊，但你可以有自己的自定义视图。可能是人写的，也可能是 AI 生成的，但使用相同的概念和相同的数据模型。

And then last year around November we were doing planning at notion, like planning this multi-year project that I was working on for a long time. And then the plan happened to be like we're gonna do this for second half of this year. And I was so angry because I wanted to do it maybe since I joined notion. I first went to Vzero. I made a little prototype. It's like an Next.js React Tailwind CSS app of the future notion. And then I played couple rounds there and I was stuck. I want to do more but then I can't. So I just downloaded the app. I got cursor, open 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 3 days and then I built this whole prototype of the future notion exactly in my head what I want. I built like a menu where you can turn every single new feature, like there's a feature flag menu off off off and then you can see the whole app change. It has like real data. It has like a cool thing is like I built like a 3D globe view but the idea is like in notion you know we have like board table galleries but you could have your own custom views. Maybe they're written by humans. Maybe they're generated by AI who uses the same concepts, same data model.

那彻底改变了我。以前做软件是一个非常漫长的过程。你可能需要自己开始，也许能做点小工具什么的，挺有趣的。但要做更大的东西，你得先组建一个团队。团队里有各种各样的人做不同的事，你得想办法把他们整合起来，对齐目标，制定计划。而现在，我有个想法，画几张草图，或者口头描述给智能体，甚至拍一张餐巾纸上的菜单结构草图，就是一些矩形框、线条、分隔线之类的。然后告诉智能体菜单里要哪些项目，砰，搞定。就是这样，而且每件小事都如此。这意味着你可以以快得多的速度不断推进，直到达到你想要的状态。而且在这个过程中，你操作的不是软件的其他产物或表征。以前人们要写 PRD 文档，要在 Linear 里制定计划、创建任务，要在 Figma 里画像素，试图用流程把所有东西串起来。而现在几乎就像雕刻一样。你得到一个东西，然后去戳它，去掉某些部分，重新安排某些部分，或者你说“啊，再来一次，再来一次，再来一次，做五次，选对的”。这完全改变了。

That completely changed me. Making software before it was like a really long process. You might need to kind of start like, you know, by yourself. Maybe you can make some 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 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 napkin sketch of this menu structure that I wanted. And then it'll be like just a rectangle box line line divider line line line. And then I'll tell the agent the items that I want in the menu. And then boom, done. That's it. 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 like linear make some tasks. They have to draw some pixels in Figma, try to stitch everything with 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 rearrange certain parts. Maybe you say, "Ah, do it again, again, and again, do it five times. Pick the right one." It changes completely.

是的。然后 Cursor 的人又联系了我。

Yeah. And then the cursor people reached out again.

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

And a lot had changed at that point.

是的。就在我做完原型的三天后，我就想“哦，我得去和你们一起搞”。然后我在那里待了两天。那算是我在 Cursor 交付的第一个项目，具体是什么？

Yeah. Like right after I made the prototype, after like 3 days and I'm like, "Oh I need to go and jam you all." And then I stayed there for like 2 days. And then that was like the first project I shipped at cursor was what exactly?

就是把 Cursor 的所有概念统一成一个东西。之前 Cursor 有 Tab、Command K（一种内联编辑智能体）、Chat（一个只跟你说话但不做任何事的智能体）、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 a inline editing agent thing. The chat which is like a 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 automates the head. 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 weren't able to find it.

是啊，回想起来我是三月开始用的。

Yeah, I'm like looking back using in March.

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

I talked to so many people. I'm like curs 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?"

我不希望这个工具变成“我们为设计师建了一个 Cursor”。它就是 Cursor，同一个智能体。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 are 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.

比如我聊过的资深工程师，我们再深入一点。因为我看到你今年早些时候发的一条推文，讲的是 AI 时代设计工具的一些技巧，其中一条就是“思考系统而非功能”的重要性。所以退一步，也许从更原则性的层面谈谈，你当时脑子里是怎么想的，才得出那些看似显而易见的改变，从而简化了 Cursor 背后的概念和心智模型？

For like senior engineers that I talked to, 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 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. So back up for a second and maybe at more of a principal 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 报告、反馈，也可能来自内部人员，同时也要看它在代码中的实际表现。然后你可能会想出更好的做事模型。也许你会简化事情。你不是去掉东西，而是统一东西。意思是人们正在做的事情、正在用的东西，它们还在，但现在被重新组织成更简单的形式。不是五个概念，而只有一个。而且这几乎就像你在构建同一事物的不同层次。对大多数人来说，他们会使用 Cursor 的默认智能体模式。他们不需要做任何改动。在理想状态下，它就能直接工作。但我们几乎是想服务所有人——从想要完全手动控制的最有经验的程序员，到更随性的人，他们让智能体做所有事情。中间还有很多不同的小配置、模式和行为。你想服务所有人，但你想给人们在这个谱系中理想的那个点。你可能会搞错，然后你就构建一些机制，让人们可以逐步向左或向右移动。你不想完全推动人们说“啊，从现在开始智能体是默认的，每个人都会开始用它，然后我不给你退路，我移除所有其他东西”，然后你会说“啊，我之前的东西去哪了？我没有连续性，我无法想象你是怎么从今天到这个地方的。”更像是，不是五个离散的小东西，而是你把圆圈变大。现在它是一个东西。但人们仍然有办法做那五件离散的事。但也许不是只有五件事，而是有无数件事。

Mhm. 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 as internal people, but also what it is 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 are using, they're still there, but now they're say reorganized into something that's a little simpler. Instead of like five concepts, you have just one. And it's almost like you build 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 ah 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. It's now one thing. But then there are still ways for people to do the five discrete things. But maybe it's like instead of just five things, now there's end things.

现在很多人说你必须成为设计工程师。但我不认为这是真的，因为 Paper 给了你很多代码的好处，同时又不牺牲设计体验。你仍然可以在一个感觉像 Figma 精简版的界面里搞砸一切、疯狂探索，但画布本身是用代码渲染的，而不是矢量。这意味着开发者可以简单地右键点击，复制为 React，然后按你设计的样子直接交付。不再有翻译丢失。很快你甚至可以直接把代码组件导入到设计画布上，这样你就不用再处理重复的真相源了。但这确实是个大事，也是我全力支持 Paper 成为下一个伟大设计工具的又一个原因。所以如果你想成为首批使用 Paper 的人，请访问 dive.com/club/paper 抢占名额。我最喜欢的动画工具 Jitter 刚刚发布了一个重大更新。你现在可以用全新的钢笔工具绘制自己的形状，并通过流畅的形状到形状过渡来制作动画。这对 Jitter 中的运动设计来说是一个巨大的解锁，也是创建真正独一无二动画的好方法。所以如果你还在睡觉，是时候醒来了。只需访问 dive.com/club/jitter 立即试用。那是 j i t t e r。现在回到节目。所以从某种意义上说，你正在把一个工具——至少在你加入时，它的理想客户画像主要是开发者——现在你正在创造的东西理论上可以支持设计师和所有不同类型的构建者。

Nowadays, a lot of people are saying that you got to 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. 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 want to be one of the first to access Paper, head to dive.com/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 in Jitter and a great way to create animations that are truly one-of-a-kind. So if you're still sleeping, it's time to wake up. Just head to dive.com/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 kind of 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，会看到三个按钮，很多人不明白它们是什么意思。有“打开项目”，你需要在文件系统上创建一个包含代码的文件夹。有“克隆仓库”，仓库是什么鬼？有“打开 SSH”之类的，SSH 是什么？不，编程小圈子之外没人知道。但从概念上讲，这个工具本身，甚至软件开发的实践——所有围绕构建软件的人，也许你是设计师，也许你是产品经理，也许你是数据人员——我们所做的一切，最终都是被写下来的代码，我们在影响哪些代码被写出来，我们是这个游戏的一部分，比如构建软件，什么是构建的正确形状，如何构建。然后，一旦 AI 能帮我们把那些翻译成代码，这更像是一种协作。是人与 AI 的事情，是团队的事情。不仅仅是 AI 取代创造者。更像是，会有一些人，AI 覆盖了他们做得少的事情，甚至让他们比以前做得更多。比如一个 1x 工程师可以变成 10x 工程师，10x 工程师变成 1000x 工程师，设计师甚至可以变成 10x 工程师。也许你从随性编码开始，然后你有点好奇“这是什么？”，然后你开始学习，比如 React、Next.js、Tailwind CSS，然后你开始构建更多东西，然后东西变得更好。然后我不希望这个工具是“我们为设计师构建了一个 Cursor”，或者“我们为产品经理构建了一个 Cursor”。它就是 Cursor。是同一个智能体。Cursor 可能会根据你是谁而改变它的感觉。好的，那我们再深入一点，因为直到今天，你打开 Cursor，它感觉像一个 IDE。有一种熟悉感，你们所有人都从中受益。但现在你有了两种不同的力量在拉扯这个产品。一方面是随性编码者的崛起，以及那些根本不知道 IDE 应该长什么样的人。

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. What the 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 we're kind of 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 it. 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. 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 before. Like a 1x engineer can become like a 10x engineer. A 10x engineer becomes like a thousandx engineer. A designer becomes like a 10x engineer even. Maybe you started from just vibe coding. Then you got a little curious. what is this? Then you start learning. It's 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. It's just Cursor. It's the same agent. Cursor might change how it feels depending on who you are. Okay, then let's pull on that strand a little bit more 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 kind of 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 IDE even is supposed to look like.

而且我们还看到一个越来越智能体化的世界，越来越多的事情在并行发生，也许软件创作的未来更多是关于策略性地让人类参与其中，而不是让人类编写代码。那么，请跟我聊聊这种紧张关系：一方面是 IDE 的熟悉感，另一方面是维护一个能让你扩展的系统，以适应一个世界——在那里，Cursor for X 可能就只是 Cursor，你可以从电脑上做任何事情。

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 kind of do anything from your computer.

是的。IDE 只是 Cursor 的一种形式，我们从那里起步，因为——不是我个人选的，可能是用户选的——他们选了 VS Code，因为它是最流行的代码编辑器，程序员都知道它。现在你把它和 AI 深度融合，推出各种最新工具，真正贴合这个场景。也许我们从手动编码工作流开始，然后逐步在上面构建。如果你看这个轨迹，其实很有道理：从手动写代码，到代码自动补全，再到我现在可以编辑这部分代码，再到我可以询问整个文件、整个代码库，再到这个东西能实际做事——调用工具、做修改、自己搜索、在前台一个线程甚至三个并行线程里操作，这有点像我们的标签页。现在有了后台智能体，你可以同时做 N 件事，可能是并行的，也可能是顺序的。这是一个渐进的过程，对吧？但即使今天，Cursor 也不再局限于 IDE 了。我们推出了 Slack 集成、网页智能体，它可以在手机上用，可以在任何浏览器上用。你几乎能感觉到，这就像是同一件事的不同形式，不同的人，或者在工作流的不同阶段，你可能偏好不同的形式。比如程序员，最手动的那群人，他们仍然喜欢打字。他们更喜欢标签页功能而不是智能体，但各种人都有。可能有些人到了某个阶段，甚至不再使用 Cursor IDE，只用网页智能体，他们可能根本看不到代码，只是在很高的层面做规划，也许用一些看板，但它仍然是 Cursor，仍然是同一件事。也许你回到电脑前，打开 Cursor 应用，一切都在那里，你只需要轻轻一点，就可以在不同分支间切换，合并它们，尝试不同的事情。你可以在任何地方开始，中途接手，然后在电脑上完成。这真的取决于你是谁，你在做什么。

Yeah. The IDE is just one form of Cursor and we started there because that is the like we pick not not even me it's like maybe I might go and people they pick VS Code because it is the most popular code editor coders know what it is 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 kind of building on top of it gradually. It kind of 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 now ah this thing can actually do stuff make like make tool calls make modifications search on its own do stuff like in the 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 in 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. 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 the agents, 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 comb board but it's still Cursor it's still the same thing maybe you go back to your computer you open up Cursor app everything's still there like all you need to do is boop 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 and like in the middle and then finish it off on the computer. Really depends on who you are and what you're doing.

我想具体聊聊你是如何工作的，但在此之前，我不得不问你，考虑到你描绘的这些现实——你可能根本看不到代码，可以从任何地方访问 Cursor，并且有任意数量的智能体为你工作——软件创作的未来到底会是什么样子？你显然和任何人一样在思考这些未来。那么，你现在脑子里在想些什么？

I want to 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 you might not even see code and you can access Cursor from anywhere and have any 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 对每个人、每件事都不同，那它到底是什么？我们又回到系统层面：哪些概念是永远不变的，能够支撑这一切？人们偏好哪些形态？我应该给所有人或特定群体提供什么样的默认设置？我们关心哪些人群？我们从哪里开始？然后从那里，你可以看到事情的发展方向。

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 kind of 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 kind of 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 group groups of people? What are the groups of people we care about? Where do we start? And then from there you can kind of 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.

我这个月大概主要都在思考这个问题。就是如何同时启动多个智能体并管理它们，查看进展，然后当它们完成后，该怎么处理？它们如何工作？你怎么提前规划？大多数人仍然一次只做一件事，但有些人可能想提前规划很多事情。其中一些可能是顺序执行的，也许它们之间有依赖关系。另一些可能是可并行的。比如你有 10 个 bug 要修，那就全部修掉，看看结果。然后整个流程是：你从一些计划好的任务开始，你在执行它们，也许不是你亲自做，而是智能体在做，但你仍然要负责。一旦完成，你需要审查变更内容，决定是否保留部分变更，以及如何合并回去并发布。然后我就想，“哦，这又是待办事项列表。”我已经做过无数次了——

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. 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 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 it's to-do list all over again." I've done this so many times like

我们又回到了原点。

and we're back.

每次我们都回到待办事项列表——智能体的、人类的，以列表视图、网格视图、列视图呈现。

Every single time we're back to the to-do list like for the agent, for the humans to-do list in a list view, in a grid view, in a column.

是啊。要不我们把它做成看板？结果还是一样。唯一的区别是，这些事情可能由智能体完成。仅此而已。就这么简单。

Yeah. How about we make it a kanban board and we're back to the same thing. The only difference is uh 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 explorations was.

我们原本希望，也许我们可以绕过它，或者做点别的。比如说，也许每个聊天都变成一个任务，可能是一对一的。但后来我们意识到，人们使用这个东西的方式太不同了。有些人有一个巨大的、长期运行的聊天，在里面做所有事情。

What we wanted was it's almost like maybe like we can get around it or like you can do something else. Um 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 codebase 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 privileges, right? Like from the systems thinker, that is the idea: 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 kind of organizing the chats around that. But then it's almost like, some people want to do five things in one chat, some people just want to do one.

那我们仍然需要一个东西来帮助智能体。你知道，智能体的上下文窗口有限，它们把所有文件上下文、聊天历史、做过的事都塞进那个窗口。随着时间推移，它会遗忘。然后就像，有时候模型前几次表现很好，然后砰，它变得越来越笨。它还需要一个东西来跟踪它需要做的高层次事项：它在哪，现在在想哪个项目，它与其他事项的关系，接下来是什么。智能体也需要这个才能在更长时间跨度上做得更好，或者做更多事情。我觉得更有趣的部分是，这不仅仅是智能体的待办清单，也不仅仅是一个聊天的待办清单，而是几乎整个事情。想象一下，你可以把软件、整个软件开发过程分解成一大堆任务，它们被固定到提示词上，也就是聊天上。那么，因为这个概念如此通用，界面就不必复杂。任何看过列表视图的人都可以开始做这些事。这就是为什么我们在 IDE 之外构建了这些东西。你可以通过 cursor.com/agents 访问它。

Then we still need a thing to kind of help the agent. You know, agents have like a limited context window and they're kind of 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 kind of like, you know, sometimes the model is really great for the first few times and then boom, it gets dumber over time. It also needs a thing to keep track of what are 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 agents also need that to do better things on a longer time span or doing more things. I feel like the more interesting part is it's not a to-do list just for the agent or 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 pegged to the prompts, like to the chats. Then, you know, because this thing, this concept is so universal, the interface doesn't have to be complex. Anybody who has seen a list view can start doing these things. And that's why we kind of built 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 the 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. Still want to see what's happening with a project.

这就是现实世界中正在发生的事情。当人们规划事情和开发软件时，Jira 看板是线性的，你知道，人们就是这么做的。这是同一回事，但如果你把它与 AI、与智能体更紧密地融合，让它更具协作性，他们在同一个代码库上工作，对事情如何运作、正在发生什么、计划什么有相同的认知，那么智能体可以做得更好，人类也可以做得更好。

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, 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, 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.

我想退一步，稍微铺垫一下，按理说我 20 分钟前就该做了，但事情一下子变得非常有趣。所以，我想多了解一点设计——也就是你——在这家公司是如何运作的，这个角色是什么样的，你甚至是如何决定做什么的。跟我聊聊，也许就聊聊你作为 Cursor 的设计师每周的工作。

I want to take one step back and kind of just set the stage a little bit, which arguably I should have done 20 minutes ago, but it just got very interesting very quickly. So, I want to 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 的看法。我尽量自己做项目。我们就是这样挖掘出那个东西的，也是我获得直觉的方式，比如 AI 的极限在哪里，我们的问题在哪里。然后你就玩，你构建。也许就像，我们用 Cursor 构建 Cursor，我也用 Cursor 构建小 Cursor，最终它们都融入 Cursor，我把它变成真的，这很有趣，但我也在试探边界：这个东西可能吗？容易吗？现在真正做起来怎么样？我甚至不添加新功能。我只是改进我做的或智能体做的事情。我尝试重构系统。我尝试做出更好的系统，然后学习。而且我还能知道，也许 03 在这方面比 Gemini 更好。然后我把这些知识带回工作，我们修复工具，让它变得更好。就这样一直持续下去。

Every week I'll come up with things I want to do and explore. Say like it's just specific problems. I say like this week is 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. That's how we dug food the thing and also how I kind of get intuition of like where the limits of the AI are, where our problems are. And then you just play, you build. Maybe it's like, you know, we build cursor with cursor, and also I build like baby cursor with cursor that end up in cursor, and I make real that's for fun 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 real as right now? I don't even add new features. I just improve the things that I did or the agents did. I try to refactor systems. I try to like make better ones and I learn. And also I can know, maybe 03 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 keeps going.

我想深入聊聊个人项目的事，但我想再细究一下你刚才说的收集信息这件事。我想知道你是从哪里获取信号，又选择忽略什么，因为现在有很多人在给你反馈。比如我回去看了你最初移动端设计的截图，有 772 条评论，这太离谱了。那么，你是怎么处理的？

I want to get into the personal projects thing, but I want to double click on something you said where you talked about just gathering information, and I want to know where you're deriving signal versus what you can choose to ignore because 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 what, how do you even deal with that?

是的，我只看 Twitter、Slack 上的所有内容，以及所有用户报告和反馈。我试着把它们慢慢吸收。就像训练模型一样。就像你在输入更多数据，建立你的直觉。然后，你知道，你看到这些东西越多，你的优先级判断就越好，你的感觉就越好。

Yeah, I just look at everything in on Twitter, 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.

嗯。

Mhm.

你是如何演进那个系统提示，来理解哪些反馈因为不符合战略意义而应该忽略的？

How have you evolved that system prompt to understand what feedback to ignore because it doesn't make strategic sense.

我会说，对于大多数事情，孤立的小决定其实并不重要。但当你把所有小事情放在一起，它们就都重要了。比如方向重要，概念重要，想法比怎么做更重要。我试着理解这个人真正想要什么，为什么告诉我这个，然后说“啊，你的解决方案，我不在乎”。有时我也忽略那些。因为它们真的不重要。即使对我自己，它们也不重要。那我就不会花太多时间在上面。你看这些东西越多，就越容易自然地处理它们。这几乎就像你建立了自己的处理器，过滤掉噪音，然后建立直觉。而且它也在变化。这是一个动态的东西。也许这周人们说 XYZ 更好，XYZ 不好。它在变。

I will say this is like for most things in isolation little decisions they don't really matter. But then when you kind of put all of these little things together, they all matter. Where say the direction matters, the concepts matters, the idea matters more than 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. Sometimes I ignore those too. 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. Like the more you look at these things, the easier you just kind of naturally process these. It's almost like you build your own processor filtering out noise and then building intuition. Also it changes. It's like a dynamic thing. Maybe like this week people are saying XYZ is better, XYZ 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 the overused analogy, it's like it's all about making faster horses, you know, 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 set the priorities and they change.

这更像是一种动态排序的事情。不只是外部因素，还有公司事务、资源技术限制、当下、未来、你自己、工程师、设计师、所有人，以及更多手动控制与更多自动化之间的权衡。如果你试图选边站，很容易陷入困境。更简单的方法是审视全局，然后决定也许现在这样做，但以后那样做。

It's more like a dynamic ordering thing. It's not just like the outside too. There's company stuff, resource technical limitations, the present, the future, you, the engineers, the designers, everyone, more manual control versus more automation. It's really hard if you try to pick a side 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 至少目前仍然是做这件事的最佳场所——与代码交互并围绕它做所有事情。你没有限制，可以做任何事。随着你使用它，代码库变得更复杂，Cursor 有更多工具来覆盖所有这些需求。它从单个东西扩展到更复杂的大东西。看看人们都在做什么，有人只是在 Cursor 里写文档，也许做市场调研、写报告。它做各种事情，因为代码是最底层的原语。它甚至不是最低层的，比如不是汇编或机器码。但至少目前，它是我们可以做几乎所有事情的层次。如果你从那个层次出发，构建一个系统来与任何代码库交互，并解决许多困难的 AI 软件工程问题，使得智能体能够构建更复杂的软件、检查自己的错误、随着使用变得更好，那么构建上层就更容易了，因为你消除了很多实时编码者会面临的问题。比如他们看到无法修复的错误，但错误根本不存在了。或者他们会看到更适合他们的更简单的替代界面，而不是文件侧边栏、编辑器、编辑器、编辑器、聊天。它可以是任何东西。

Yeah, because we're building software and the code is the material. Cursor, at least right now, is still the best place to do that, to interact with the code and then do everything around it. You have no limitations. You can do whatever. And as you use it, as your code base gets more complex, cursor has more tools to cover all of those. It scales from a single thing to a more complex big thing. If you look at people, there are people who are just writing docs in cursor. Maybe they're doing some marketing research, some report. It's doing all sorts of things because code is the lowest level primitive. It's not even the lowest, like it's not assembly or machine code. It is, at least for now, the layer where we can do almost everything. If you start from that layer and you build a system around how to interact with any code base and solve a lot of 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 kind of eliminated a lot of problems that a live coder would face. Instead of them seeing an error they cannot fix, the error is just not there anymore. Or maybe they will see some simpler alternative interface that fits them better, that is not the sidebar of files, editor, editor, editor, chat. It can be anything.

好的，我先把这个放一放。我想深入一点，带我回到你探索的早期阶段，在你把待办事项作为这些 N 个智能体的原语之前。那些探索当时是在哪里进行的？你是在写文档吗？还是用 Cursor 快速搭建 UI？还是别的什么？

All right, I'm going to put a pin in that. I want to 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 n number of agents. Where were those explorations happening then? Were you writing in docs? Were you using cursor to spin up UIs? Was it something else?

我只是用适合问题的任何媒介。我经常在办公室散步，用手机上的 Notion 打字记录想法，列表、项目符号列表之类的。我就边走边写。有时想法更概念化，然后我可能回去。有时是视觉问题需要摆弄，我需要 2D 空间、精确的像素位置，并且需要快速迭代不同的布局等，因为当前工具不允许你用真实代码或 AI 做到这一点。所以，我仍然用 Figma 做那部分。在 Figma 里做原型或模型非常难，但在代码里却很容易。对于所有这些，我就用 Cursor 构建出来，看看感觉如何。一个例子是我们今天或明天要发布的停止和队列交互。它始于一个在婴儿版 Cursor 中的原型。我给别人看，他们说“哦，酷。”然后我们就构建了它。然后我们在多智能体方面做了更多工作。也用了原型，因为这样容易得多，尤其是当你做这些 AI 交互时，因为输入、输出、上下文、响应及其内容都很重要。你无法伪造它们。

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 and a list, bullet list or whatever. I'll just walk and I'll just write. I'll come up with maybe they're more conceptual and then maybe I go back. Maybe there's a visual problem that I need to play with. I need 2D space. I need exact pixel placement and I need to quickly iterate between different layouts and stuff because the current tools don't allow you to do that with real code or with AI. So, I still use Figma for that. It's super hard to prototype or mock up in Figma, but it's so easy to do it in code. For all of those I just use cursor, build it out, see how it feels. One example is the stop and queue interaction that we're going to ship today or tomorrow or something. That started just from a prototype in baby cursor. I showed it to people. People were like, "Oh, cool." And then we built it. And then we're doing more on the multi-agent stuff. Also use prototypes for that because it's just so much easier, especially when you're doing these AI interactions because the input, the output, the context, the response, what's in it, they all matter. You just can't fake them.

是的。

Yeah.

输入、输出、上下文、响应及其内容都很重要。你无法伪造它们。

The input, the output, the context, the response, what's in it, they all matter. You just can't fake them.

而且你用了“感觉”这个词。我的意思是，正是如此。对于停止队列来说，唯一重要的就是感觉。我甚至在一个我不该参与的评论线程里和某人聊过，他们说：“我不明白为什么需要写代码？”然后我就想，老兄，如果你在做一个有持续 AI 输出的产品，哪怕只是稍微接近聊天，在 Figma 里根本不可能推动任何改变。根本不可能。

And you use the verb "feel" it. I mean, that's exactly it. The only thing that matters for stopping a queue. It's the only thing that matters. And I was even having a conversation with someone in a comment thread that I probably shouldn't have been in, but they were just like, "I don't understand 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 anything even remotely close to a chat. It's impossible to move the needle in Figma. 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.

好的，那我们来聊聊这个，因为你有一条我很喜欢的推文，谈到了未来 AI 界面的流动性。分享一下你的想法，也许我们可以以此为起点，看看会走向哪里。

All right, let's talk about it then because you had a tweet that I really liked where you talked about fluidity of future AI interfaces. So share some of your thinking there and maybe we can use that as a launching pad and see where it takes us.

是的，几乎就像你不能再通过模型来设计东西了。意思是它们只是一个状态、一个你认为每个人都能理解的理想状态的静态图片。那根本不可能。作为设计师，我们可以尝试简化一切，降低门槛，确保这是人们能理解的最通用的东西，但然后你可能因为稀释了产品而毁了它。它不再能实现某些人想要的魔法了。也许不该这么说，但这几乎就像 Mac OS 从液态玻璃的重新设计。你有点强迫人们进入这个网格、这个模式、这个系统，而这个系统在那个上下文中没有意义，或者没有针对鼠标光标与触摸或视觉等进行优化。界面之所以设计不同是有原因的。iPhone 按钮是 44 像素高，而 Mac 上大概是 28。但每个人思考方式不同，说话方式不同。他们与世界、他人或他们正在思考的事情或正在做的事情有不同的偏好交互方式。我和很多工程师一起工作。即使工程师之间也差异很大。有些工程师已经完全进入智能体世界，但有些仍然手动输入代码。有些人纯粹使用键盘。你知道所有 Vim 用户或 Emacs 用户，但也有很多人只是点击。如果你看 Twitter，我昨天看到一条推文。我认识的最厉害的程序员之一，在 Bun 工作的 Jared，他说：“把桌面应用下载下来。”这是理解这个的最好方式。

Yeah, it's almost like you just can't design a thing with mocks anymore. Meaning they're just a static picture of one state, one ideal state that you think every single human will understand. That is just impossible. We as designers, we can try to simplify everything, dumb it down, make sure that this is the most universal thing people can understand, and then maybe you up your whole product because you watered it down. It doesn't do the magic that some people wanted anymore. Maybe 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 tap or vision, whatever. Like the interfaces were designed differently for a reason. iPhone buttons are 44 pixels tall versus on Mac it's like 28. But every single person thinks differently, talks differently. They have different preferred methods of interacting with the world, 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. Some of them purely use the keyboard. So you know all the Vim users or Emacs, but also there are a lot of people just click. If you look at Twitter, I saw a tweet from yesterday. One of the most crack coders I know, Jared, who works at Bun, 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.

我不记得是什么时候了，可能是之前，你谈到一个产品要跨越不同规模阶段需要发生什么。你基本上说，如果到了每个人都必须使用这个产品的地步，你就会失去一点灵魂。所以，在你看来，个性化似乎是解决这个问题的解药。而且，模型可能带来的潜力让我们能够在触达十亿用户的同时，实现那种灵魂和工艺的水平。要达到那个目标需要什么？作为某种形式掌舵的人，我们离那有多远？作为设计师，当个性化是你试图跨越这个鸿沟的最终目标时，你在思考哪些事情？

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. 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. What needs to happen to get there? Like as the person in you know some shape or form steering the ship, 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 具体看起来如何、按钮的顺序和位置，你实际上是在设计一个容器。这些是我整个系统中的模式，然后它们之间相互转换。所以在 Cursor 中，你知道，当你选中文本时，有一个小输入框，按 Command K，有一个小输入框，然后旁边有一个聊天窗口。旁边的聊天窗口也可以打开成全屏编辑器，然后它就变成了一个全屏窗口。同样的东西可能出现在后台智能体、网站、移动端上。所有这些东西在概念上都是一样的，但你可能根据你在哪里做这件事而赋予它们不同的形式。什么是整个事情中最本质的模式和想法，以及它们所有可能的配置？

Yeah, we haven't even started yet on this one. As I said, like when you open up Cursor, the three buttons, 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, the order of buttons where they are placed, you are actually designing a container. These are the patterns in my whole system and then they translate between each other. So like in Cursor, you know we have like a little input when you select text, 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 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?

那么这是一个有限的列表吗？作为 Cursor 未来状态的设计师，你是不是在提出所有的基础元素？

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?

它们可能可以组合，到那时可能只是一个标准的阶乘问题。

They can be combined probably in it's probably just a standard factorial at that point.

在那个未来，当你考虑个性化的上限时，是否有空间让 AI 动态生成输出、UI 或组合？这在你看来的发展过程中占多大比重？

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 does that is a factor in how you see this going?

这是可能的，但我认为随意生成 UI，甚至工具创建者都无法控制或预测，这不是一件好事。它只会制造更多混乱。但假设你进入 Cursor，不是看到那三个按钮，而是根据我们对你的了解、你从事的项目类型，也许你告诉了我们一些偏好，然后 AI 可以为你重新配置整个 Cursor。也许它把它上下颠倒。也许你只看到这个。我不知道，像一个画布，你可以在上面画东西，然后砰，你的想法，而不是像一个矩形的东西，变成了一个你可以玩的真实组件。或者像一个纯粹的编码员，你进入 Cursor，你只看到终端。为什么不呢，对吧？但你仍然在使用 Cursor，只是通过不同的形式。你仍然在接触所有相同的底层基础元素，而且它们并不多。实际上非常少。我认为特别是对于 AI，如果你现在构建太多抽象层，你会遇到问题，因为很多抽象层没有意义。但有些东西是永远不会改变的。

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. But 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 kind of 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 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 like a pure coder, 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. 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 going to get because a lot of them will not make sense. But there are certain things that won't ever 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 100x 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 designing digital products.

是的。但我想说，我们与之交互的形式并没有太大变化，而且它们不会改变太多。是的。人们处理信息的不同方式可以是视觉的，可以是列表，可以是卡片，可以是表格，可以是任何东西。但这真的取决于你在做什么，你是谁。

Yeah. But I would say like the forms that we interact with 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.

好了。好吧，我不能结束这次通话而不给你一个谈论 Ro 的机会，因为人们在 Twitter 上完全爱上了它，出于各种原因。它真的很有趣。我甚至在这次通话之前就玩过它，做了所有的聊天和 iPod 之类的东西。你谈到了构建自己的操作系统作为“吃自家狗粮”练习的价值。但肯定还有更深层次的动机，灵感来自哪里？为什么你花时间做这个，基本上在凌晨 3 点制作你自己的迷你 Slack？

All right. Well, I can't end this call without giving you an opportunity to talk about Ro because people are, you know, completely in love with it on Twitter for every reason. 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 got to be a little bit more of a deeper motivation and where's the inspiration come from? Why do you spend time doing this and making your own mini slacks at 3:00 a.m. basically?

是的。所以，这个东西的开始纯属偶然。我在里面构建了第一个应用，音板应用。如果你打开它，里面有一些我发出噪音的预录音效。那些是我做的。

Yeah. So, how this thing started was like pure accident. I built the first app in there, the soundboard app. And if you open it, it's like there's some pre-recorded sounds of me making noises. I built those.

是吗？我不知道。

Are you? There's I didn't know that.

对，这就像是我在制造噪音，然后我这么做是因为我要离开 Notion 了，我希望我的团队在会议中能听到我的声音。

Yeah, this was like me making noises and then I did this because I was leaving Notion and I wanted my team to have my voice in meetings.

它最初是一个 React 聊天转 CSS 的应用，非常通用。功能上没问题，但看起来很丑。我就说让它更像复古 Mac OS，然后它从 Google 拉了一个随机的像素字体。还是很丑，但你能看出它要做什么。然后我说，把它放到窗口里。它放到了一个很糟糕的窗口里。然后我说，做个菜单栏。它做了菜单栏。然后我想，为什么这个东西只有一个应用？它看起来像个操作系统，但只有一个应用。于是我做了第二个应用，Internet Explorer 应用。它最初只是一个浏览器，看起来像个带栏的浏览器，但实际就是一个输入框和一个 iframe，我称之为应用。但当我这么做时，几乎就像我询问了智能体，然后我们一起重新设计了整个操作系统架构。如何处理多个应用？如何有多个窗口？有窗口的前景、背景。哪个活跃，哪个不活跃，拖动它们，调整窗口大小，管理所有应用状态，让它们以相同方式存储，放到本地存储中，这样当你关闭这个网站再打开时，所有状态仍然保留。然后我说，加个文本编辑器吧，因为我在做 Notion。所以我做了个文本编辑器，它有斜杠命令之类的。然后我想，如果聊天能写入文本编辑器呢？所以我做了。没有计划，纯粹凭感觉。

It started as like a React chat to win CSS app, very generic. It was functionally correct, looked very ugly. And I just said make it more like retro Mac OS, and then I think it pulled some random pixel font from Google. Still very ugly, but you can get a sense of what this is going to do. And then I was like, put it in a window. And it put it in a really bad crappy window. And then I said, make a menu bar. And it made a menu bar. Then it was like, why 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. It started just as 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. How do I handle multiple apps? How do I have multiple windows? There's window foregrounding, backgrounding. Which one's active, which one's not, dragging them around, resizing the 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 still remaining. And then I was like, let's add a text editor because I was making Notion. So, I made a text editor and then it has 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.

你觉得是不是因为你行动迅速？我在这次通话前就在想这个问题，因为我刷了推特。我发了个帖子，很多人评论提问，很多人都在深挖，你知道，EOS 的灵感是什么？我想，很多听众，并不是你比所有人都更有创造力。区别是什么，我的直觉是——你可以确认或否认——从想法到第一个输出之间，你花的时间可能很短，然后就让事情自然展开了。

You think it's just that you're quick to act on ideas? I was asking myself that before this call started because I was going through Twitter, right? I made a post and so many people commented, asking questions, and a lot of them were trying to dig at, you know, what's the inspiration for EOS? And I'm like, you know, 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 my hunch and you can 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 lets it unravel from there.

是的。我加入 Cursor 的原因之一就是希望想法变成现实之间的差距趋近于零。有了 Cursor 我就能做到。真的能做到。现在我能做的事情几乎比以往任何一个人——即使是工程师——都要多。我写了大部分实际代码，大概一两个月内写了大部分。现在大概有 13 万行代码。

Yeah. One of the reasons I joined Cursor is I want the gap between having an idea and it becoming reality to get closer to zero. And with Cursor I can do that. Literally I can do that. It's almost like now I can do way more than any single person was capable of before, even as an engineer. I wrote most of the real code, I don't know, most of it in like one or two months. Right now it's like 130k lines of code.

哇。

Wo

但我问过，我想我问过 ChatGPT 一个正常的工程团队要花多久才能构建它。答案是几个月或几年，需要几十人或 20 人。而只有我一个人在旁边凭感觉编码，随机想法。所以我们现在正在为 InFlight 招聘，今天下午我们和一位工程师聊了，我们正在制定策略，确定未来一年的核心团队，Cursor 从根本上改变了这个等式。

But I asked, I think I asked ChatGPT like how long it would take for a normal engineering team to build it. It has like months or years with tens of people or like 20. It's just me by myself on the side vibe coding just random ideas. So we're hiring right now for InFlight and this afternoon we were talking with an engineer and we're kind of just working through the strategy of what's the core team that we want to 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. 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 10 years or so just completely does not make sense anymore. It's almost like everyone, if you know how to interact with the AI, it's almost like leveling the field a little bit. Meaning I see a lot of say 17-year-olds vibe coding with AI doing way crazier things than say some engineer at big tech doing 10 lines of code a day. 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 a pretty short time span because the tools are also getting really fast, but they're pretty ahead versus if you are still thinking maybe we need to do weekly plans, stand-ups, meetings, certain rooms, eat my lunch, do nothing, it's going to be bad for you.

祝你好运。

Good luck.

我们谈到了 Cursor 在构思实验阶段的作用，但你能谈谈你在构建 Cursor 时如何与 Cursor 的工程师合作吗？你多久贡献一次生产代码？这是已经发生的事吗？什么时候发生？这部分过程是什么样的？

We 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 how often are you contributing production? Is that something that's happened? When does it? And what does that part of the process look like?

是的。举个例子，甚至不是关于我自己。我们还有另一位设计师，他叫 Ricky，也来自 Notion。他非常喜欢设计系统。他喜欢在 Figma 中制作组件。所有颜色 token、样式、组件、嵌套组件、所有不同状态等等。他加入后就开始，你知道，老习惯，清理所有东西，做 mockup，让它们视觉上完美，我认为这也很重要，但这几乎是一件你只做一次的事。所以他做了，然后我们开始重新架构和重新设计所有设置页面，比如所有设置和仪表盘。他在 Figma 中做了大概两周，然后我说：“你在干什么？我们试试凭感觉编码吧。”

Yeah. One example is not even for myself. So we have another designer, his name is Ricky. He was also from Notion. He's like a really big design system guy. 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, kind of like old habits, just clean up everything, mock them up, make them visually perfect, which I think is really important too, but it's almost like a thing that you only do once. So he did that and then we started rearchitecting and redesigning all of our setting pages, like all the settings and the dashboard. So he did that in Figma for like maybe two weeks and I was like, "What are you doing? Let's just try vibe coding it."

工程师们对此怎么看？

What do the engineers think about this?

这个问题，你知道，他们喜欢这样。

The question, you know, they love it.

是的。

Yeah.

他们现在更把我们看作他们的一部分。

They see us more like part of them now.

解释一下。

Explain that.

我开始构建东西时，并不知道设计师、工程师、PM 之间的区别。我自己做东西。我在脑子里设计，然后编码。然后我成了设计师。我只是觉得整件事没有意义。意思是，设计师是画图和像素状态的人，然后工程师需要说，好的，有了这些图，你现在要设计整个架构的每一部分并构建整个东西。这没有意义。这就像同一个问题，同一个拼图，只是拼图大小不同，同一事物的不同抽象层次。如果你这样切分，最终会得到奇怪的东西，而它本可以更好。这很好地过渡到：在我之前，Cursor 没有设计师，因为人们为自己构建。他们为自己设计。我认为这很棒。Cursor 就是这样走到今天的，因为我们为程序员构建了最好的 AI 工具。

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 and the pixel states and then the engineers need to say okay great given these pictures now you kind of design the whole architecture every piece of it and build the whole thing. It doesn't make sense. 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. It's like that's how Cursor got here because we built the best AI tool for programmers.

我认为我们有一个非常优秀的团队，几乎在构建最极致的 AI 工作流，其中包含了所有的手动编码，但这只是开始。随着团队扩大，你需要让系统容纳更多做事方式、不同的可视化和不同的抽象层次。

I think we have a really good team and we're almost building the most cracked AI workflow that involves all the manual coding, but that is just the start. As you expand to more people, you need to make the system accommodate more ways of doing things, different visualizations, different abstractions.

这正是我想说的。你的故事体现了设计师的价值，对吧？因为有一群人在为自己构建东西，但需要设计师介入，理清复杂性，并创建一个能够扩展到更多人的解决方案。

That's what I was going to say. Your story speaks to the value of the designer, right? 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.

完全正确。我们有很多优秀的工程师，但他们在某些方面也有些茫然。他们构建了整个问题中最难的部分，却忘了建门，或者忘了让路径汇合。与其建五个东西，不如只建一个东西，但它有一百万种不同的视角。我认为这就是设计师甚至软件架构师要做的事：设计事物的边界，概念如何协同工作。不再像以前那样分层进行——从策略开始，写一份大文档，分享，让 PM 写具体的需求和任务，拆分任务，开漫长的计划会，把任务分给工程师，让他们像编码猴子一样工作——而是我们都只是构建者。我们有想法，想一起构建最好的东西。也许我更艺术化，更注重视觉；也许你更关注数据模型或 ML 方面。我其实不太懂 ML，但我们一起完成整个拼图。当所有参与者都能写代码时，角色和头衔就不再重要了。

Exactly. It's like we have so many great engineers, but they're kind of clueless in some way, too. They build the hardest part of the whole problem, but they forget to build the doors, or they forget to make the paths flow into the same thing. Instead of building five things, maybe we should just build one thing that has a million different ways to see it. I think that is what designers or even software architects will be doing: designing the boundaries of things, how concepts work together. Instead of doing that layer by layer like before—starting with strategy, writing a giant doc, sharing it, getting PMs to write specific requirements and tasks, splitting tasks, doing long planning sessions, splitting tasks to engineers, letting them code like 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 the ML stuff. I actually don't know much about ML, but you're completing this whole puzzle together. The roles and titles just don't matter anymore when all the people involved get to write code.

我们谈到了系统思维。除此之外，在一个每个人都能用代码写作和贡献想法的世界里，你认为还有哪些真正持久的技能定义了设计师能带来的价值？

We talked about the systems thinking piece. 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?

没错。我认为归根结底，从最高层面看，这其实取决于你如何解读世界，如何看待周围的事物，以及你正在处理的概念。因为我们各不相同。有些人非常擅长深入细节，但不太擅长宏观层面；有些人擅长宏观，但不够精巧；有些人擅长底层代码，但构建 UI 时到处乱放按钮，让人困惑。但最终我们做的所有事都是为了产出漂亮、高质量的软件。那是理想状态，是所有这些人贡献的总和。在 Cursor 出现之前，这些人不得不依赖过时的方式沟通、对齐和协作。问题在于，每个角色、每个专业都在自己的思维宫殿里以不同方式思考。我们用视觉层次、排版、间距、颜色来交流；工程师用后端术语交流。但最终都是一回事：后端生成一些消息，需要在 UI 中显示，通过像素传达。也许有一天我们会用到脑机接口。但不变的是你如何构建东西，如何思考，如何分解，如何通过人、AI 和代码本身将它们重新组合。你希望这个东西成为什么。有些人认为构建一个只做一件事的单一用途的东西很好。我不这么想。不同的偏好，不同的做事方式——这些可能才是关键。

Right. I think it's really about, if you pull all the way up to the highest level, it's really just how you interpret the world, how you view the things around you, the concepts that you're working with. Because we're all different. Some people are really good at deep detail but less on the high level. Some people are good at high-level stuff but not as crafty. Some people are good at low-level code but when they build UI they just throw buttons everywhere and confuse people. But all we're doing at the end results in beautiful quality software that works. That is the ideal state, the sum of all these people. Before Cursor, these people had to rely on archaic ways to communicate, align, and work together. The problem is that each of these roles, each specialization, thinks differently in their own mental palace. We talk in visual hierarchy, typography, spacing, colors. Engineers talk in backend stuff. But it's all the same thing at the end: the backend generates some message that needs to be displayed in the UI, communicated through pixels. Maybe at some point we'll get to brain-computer interface. But what doesn't change is how you build the thing, how you think about it, how you break it up, how you tie them back together with people and AI and the code themselves. What you want the thing to be. Some people think building a single purposefully built thing that only does one thing is great. I don't think like that. Different preferences, different ways of doing things—those might be what makes the difference.

我们谈了很多，我决定把最后一个问题外包给 Ryo。我之前和虚拟的你聊过，我问的问题是：结束这场对话最有趣的问题是什么？

We've covered a lot of ground and I decided to outsource my final question to Ryo. I was talking with the virtual you earlier and I was asking, my prompt was basically, what is the most interesting question that I can ask to end this conversation?

是什么？

What is it?

关于人机交互的未来，你相信什么听起来有点疯狂但你仍然认为是真的？

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 maybe we don't operate from proxy devices; maybe it's even closer. So like I'm a visual thinker, I'll still see my canvas stuff, but maybe they're floating in my mind instead of on a screen.

是啊，那是个迷幻的未来。你看过 Neuralink 的新演示吗？他们用大约一千个电极就能在你的视野中绘制东西。太疯狂了。我的意思是，很难不让人想：什么？在那个世界里，我们对设计师的定义完全变了，这意味着什么？有多少东西能延续？太疯狂了。

Yeah, that's a trippy future. Have you seen the new Neuralink presentation? They can already, with like a thousand electrodes, draw stuff in your vision field. It's crazy. I mean, it's hard not to just be like, what? The whole definition of what we think of as a designer in that world is just what does it mean? How much carries over? It's crazy.

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

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

是的。语言的重要性。哦天哪，你说得对。这其实是我现在工作的一大部分：将本应相同的概念和想法澄清为最简单、不变的形式。

Yeah. The importance of language. Oh my gosh, you're right. It's like that is actually a big part of my job now: clarifying concepts and ideas that are supposed to be the same into their simplest form that doesn't change.

好了，Ryo，这太棒了。谢谢你和我一起畅聊你脑中的一切。看到你的工作方式真的很有趣，而且知道你对这个产品的影响后，我比开始时更感激你担任这个角色。作为用户和观察者，看着这一切都是一种享受。很期待继续在 Twitter 上关注你，伙计。

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

谢谢。

Thank you.

在结束之前，我想花一分钟介绍我最喜欢的产品，因为我经常被问到我的技术栈。Framer 是我建网站的工具；Genway 是我做研究的方式；Granola 是我在评审时记笔记的工具；Jitter 是我制作设计动画的工具；Lovable 是我用代码实现想法的工具；Mobin 是我寻找设计灵感的地方；Paper 是我像创意人一样设计的工具；而 Raycast 是我每一步的快捷方式。我精心挑选了这些公司，这样我就能全职做这些节目了。所以，支持这个节目最重要的方式就是去看看它们。你可以在 dive.comclub/partners 找到完整列表。

Before I let you go, I want to 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 is how I build my ideas in code. Mobin 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. You can find the full list at dive.comclub/partners.