Ryo Lu（Cursor）：AI让设计师变身开发者

在过去大约十五年左右的时间里，软件开发的艺术变得碎片化，随后我们逐渐分化成了不同的角色。

Over the last, I don't know, fifteen years or so, the art of making software fragmented a lot, and then we kind of split into different roles.

每个角色都使用自己的工具和自己的产物。

Each role kind of use their own tool, use their own artifact.

他们用自己特有的语言和术语来思考。

They think in their own kind of words and lingo.

有了 Cursor，情况又发生了逆转。

With Cursor, things kind of flip again.

第一次，设计成为了一个对更多人来说都易于理解和掌握的概念和技能集。

For the first time, that design is such an approachable concept and skill set to a lot more people.

它将那些有设计志向、希望构建事物、希望进行原型设计、希望向世界展示美好作品的人们凝聚在了一起。

And it brings together sort of people who have aspirations for design and wanting to build things, wanting to prototype things, putting beautiful stuff out in the world.

必须有人来界定什么是好的、什么是正确的，以及我想要如何去做。

There needs to be something for the human to specify what is good, what is right, how I want to do it.

如果你不投入自己的观点，AI 就只会生成一堆无意义的垃圾。

If you don't put in that opinion, it will just produce AI slog.

人们总会拥有自己的优势或独特技能。

People will always have their strength or their unique special skill.

在我看来，AI几乎就像一个通用接口。

I see AI almost like it's almost like a universal interface.

因此，设计就是试图找出对我们所有人来说最佳的配置和最简状态。

So design is the kinda, like, trying to figure out what is the best configuration and the simplest state for all of us.

真正的美在于将所有事物整合在一起。

The beauty is actually putting things all together.

当设计师成为开发者时，会发生什么？

What happens when the designer becomes the developer?

曾经在Figma中夭折的原型，如今竟能在几分钟内变成活生生的产品。

When mock ups that used to die in Figma can suddenly become living products in minutes.

今天的嘉宾是十六号资本的普通合伙人Jennifer Li，以及AI代码编辑器Cursor的设计负责人Rio Lu，Cursor正在消融设计与工程之间的传统界限。

My guests today are Jennifer Li, general partner at a sixteen z, and Rio Lu, head of design at Cursor, the AI code editor that's collapsing the traditional boundaries between design and engineering.

Ryo曾在Notion和Asana工作多年，目睹自己的设计被困在无尽的会议和交接中。

Ryo spent years at Notion and Asana, watching his designs get stuck in endless meetings and handoffs.

现在他正在开发工具，让设计师能够自己发布真正的软件。

Now he's building tools that let designers ship real software themselves.

我们正在探讨人工智能如何终结碎片化团队的时代，为什么‘品味’其实不值一提，以及当一个人就能完成过去整个产品团队才能做到的事情时，这意味着什么。

We're exploring how AI is ending the era of fragmented teams, why taste isn't really worth talking about, and what it means when a single person could do what used to take an entire product team.

欢迎来到Async播客。

Real welcome to the Async podcast.

嗯。

Mhmm.

詹妮弗，你一直在思考设计的演变，以及它与基础设施和软件开发的关系。

Jennifer, you've been thinking a lot about sort of evolution of design, evolution sort of as as it relates to, infra as as well as software development.

你为什么对邀请里奥来参加这次对话感到如此兴奋？能谈谈吗？

Why don't you talk about what got you so excited about having Rio and, you know, why we're having this conversation?

我和里奥在过去几个月里一直讨论大型语言模型和AI工具将如何影响设计师、设计工程师，以及人们如何构建原型和产生好点子。

Rio and I, got to know each other over the past few months talking about how large language models and AI tools are going to impact not just designers, design engineers, and how people are building prototypes and coming up with great ideas.

我觉得第一次，设计成为了一个对更多人来说都触手可及的概念和技能。

I feel like for the first time that design is such an approachable concept and skill set to a lot more people.

它将那些有设计抱负、想要构建东西、想要做原型、希望更轻松快捷地向世界展示精美作品的人们凝聚在了一起。

And it brings together sort of people who have aspirations for design and wanting to build things, wanting to prototype things, putting beautiful stuff out in the world much, much easier and faster.

所以，Rio 对设计的含义、以及 Cursor 如何成为设计构建模块之一，进行了大量思考和探索。

So Ryo has gone through a lot of thinking and journey of what design means or design means in the sense of having Cursor being part of like, the the building blocks of it.

我只是真的很想请他来播客，聊聊编码和设计的未来。

Like, I I just really wanted to have him on the podcast and talk about the future of both coding and design.

Rio，你目前在 Notion 担任设计负责人，同时也在 Cursor 担任设计主管。

Rio Rio, you've been at Notion now, obviously, head of design at Cursor.

你能跟我们分享一下你的经历，以及你是如何思考这些话题的吗？

Why don't you take us through your journey and how you've been thinking about some of these topics?

对我来说，这就像在开发软件。

I think to me, it's like building software.

其中涉及太多层次的抽象和需要处理的深度。

There's, like, so many layers of abstractions and depth that you need to take care of.

要想做出真正出色的东西，你实际上需要掌握一切。

And in order to do something really great, you actually need to know everything.

或者你组建一个团队，团队成员在每一层都有各自擅长的技能。

Or like you assemble a team that works really well together with, you know, people with different strings on every layer.

也许你拥有最顶尖的信息工程师、做机器学习的人。

Maybe you have the greatest info engineers, people doing ML.

也许你还有非常出色的设计师，他们能直接手写 CSS，然后做得完美无缺。

Maybe you have, you know, really good design engineers who really like, they can just handwrite CSS, and then they'll be, like, perfect.

要让一个人掌握所有这些技能或学习所有这些内容，需要经历漫长的研发与试错过程。

In order for, say, one person to do all of this or learn all of this, it takes a long time of trial and error.

你必须从最简单的东西开始构建，逐步过渡到更复杂的任务，扩大规模，让更多人参与，将你的成果公开，观察反应，形成反馈循环。

You have to build from the simplest things to, you know, gradually more complex, scale it up to more people, share your workout to the public, see what happens, do this feedback loop.

而如果你是在团队中做这件事，有时会更慢，比如你只是一个设计师。

And if you're doing it in a team, sometimes it takes even longer because, say, you're just a designer.

你用 Figma 做了一些设计稿，然后分享出去。

You you're doing some mocks in Figma, and then you shared it out.

你收到了一些反馈。

You got some feedback.

然后你的产品经理得做PRD文档，还要开更多会议。

Then your PM needs to do this, like, PRD thing and then run more meetings.

然后涉及的人越来越多，整个过程就变得特别慢。

And then there's, like, more people involved, and then they're like, and takes a long time.

可能一年后你的设计终于出来了，但结果只有你原本想法的20%。

And then maybe like a year later, your design came out, but then it's like 20% of what you wanted.

但有了这个新工具，比如Cursor，你只需要说出一个想法，哪怕有点模糊也没关系。

But with this new thing, say with cursor, you can just say you have an idea, it might be a little ambiguous.

你只要告诉它，让它去和代理沟通。

You just tell it to tell the agent.

然后它可能第一次就能给你产出60%、70%的效果，但你跳过了很多复杂的过程。

And then it might give you something maybe like 60%, 70% on the first shot, but you kinda kinda skipped a lot of the, you know, complexities.

我们已经从‘必须理解所有这些软件开发的概念’，转变成——

We kinda transformed from like, you need to understand all these things, all these concepts of making software.

你也可以直接动手做了。

Then you can do something too.

我现在就能做点什么了。

I can do something now.

然后我可能会得到一个不完美、不完全符合我想法的东西。

And then I might get something that's maybe imperfect, not exactly what I want.

但迭代和不断调整的过程变得非常迅速。

But the process of iterating and kind of poking at it becomes really quick.

随着智能体的进化、模型的提升以及它能接入更多工具，它对视觉的理解也会更好。

And then as the agents evolve, as the models get better, as it talks to more tools, it understands visuals better.

它可以和Figma沟通，查看我之前的原型图。

It can talk to Figma, the mocks that I had.

它可以和Notion沟通，获取所有想法、文档、会议记录等任何内容。

It can talk to Notion, all the, you know, ideas, the docs, the meeting notes, anything.

最重要的是，它了解代码库，而代码库才是我们构建软件的真正基础。

And the most important thing is it knows the code base, which is the truth, the material of how we, you know, build software.

所以这彻底改变了整个过程。

So that kind of changes the whole thing.

这就像这个工具不仅影响了单个软件工程师，比如对于Cursors，我们尽量适配尽可能多的工作流程和用户。

It's like the tool not only impacts the individual software engineers, like for them, maybe like for Cursors, we kind of try to fit as many workflows and people as we can.

比如有些人以深入思考、编写最整洁的代码为傲。

Say there's like people who they pride themselves at like, you know, really think thoroughly, write the most clean code.

对于这些人，他们只需打字，然后我们来做标签操作。

For those people, they can just type and then we do the tab thing.

而这个标签功能已经变得非常出色，几乎像是知道你接下来想做什么。

And the tab thing got really good at like, it's almost like it knows what you want to do next.

所以对这些人来说，他们可以这样做。

So for those people, they can do that.

但越来越多的人开始使用智能代理。

But there's, like, increasingly more people doing the agent.

即使对于最专业的程序员，也开始采用这种新方式。

Where like even for the most professional coders, they start to do this new thing.

是的。

Yeah.

我试着以自己为例，在加入公司之前，我是在产品侧工作的。

I am trying to think of even myself as an example, prior to joining the firm, was on the product side.

我经常与很多设计工程师团队合作。

I was working with a lot of designing designers design engineering teams.

那时候还不叫这个名字。

Back then it wasn't called that way.

现在更

It's more

像是设计师、前端工程师，还有用户体验设计师。

like designers, front end engineers and then UX designers too.

当时的工作流程非常分散。

It was still a very disjointed workflow.

很多设计工作都是设计师独自孤立地完成的。

It's like a lot of the design work happens more in an isolated fashion with just the designers themselves.

他们花两周时间来构思一个概念。

They spent two weeks coming up with a concept.

界面是什么样子的？

What does the UI look like?

和UX设计师一起讨论UX的外观。

And work with UX designers on what the UX look like.

然后交给产品团队，并与工程师合作。

And then hand it off to the product team and work with engineers.

我觉得我已经把这种流程拉得更近了，大家可以围绕同一个工件协作，提供意见、进行原型设计，并将更贴近现实的工件交到大家手中。

Think I'm already bringing that sort of process a lot closer that you can collaborate around one artifact that everybody can give inputs and prototype and bring sort of more of a close to the reality artifacts into these people's hands.

而使用Cursor时，甚至更进一步，你可以直接探索和操作这些功能齐全、可运行的工件。

Where with Cursor, it's even one step closer, is you can actually poke around and play with these artifacts that are functional and working.

我想知道，这对这些团队之间的协作意味着什么？

I'm curious, what does it mean for collaboration among these teams?

正如你提到的，迭代的合并和速度的提升意味着什么？

As you're mentioning the collapse of that iteration and the speed?

这对参与设计的不同角色又意味着什么？

And also what does it mean for the different roles that's involved in design?

是的。

Yes.

所以我认为，在过去大约十五年左右，软件开发的艺术变得碎片化了，我们逐渐分化成了不同的角色。

So I think maybe like over the last, I don't know, fifteen years or so, I think the art of making software fragmented a lot, and then we kind of split into different roles.

每个角色都使用自己的工具和自己的产物。

Each role kind of use their own tool, use their own artifact.

他们用自己特有的语言和术语来思考。

They think in their own kind of words and lingo.

比如设计师们被困在Figma里，以前可能是Sketch。

Say the designers are stuck in Figma before maybe it's like Sketch.

实际上，那时候都是些文件。

There were actually like, you know, files.

而产品经理们可能只是写文档、开会议，或者用Google文档。

And then the PMs, maybe they're like just writing docs and writing meetings or maybe they're in Google Docs.

至于数据人员，可能用的是其他工具。

And say the data people, maybe like some other tool.

然后每个人都被孤立在自己的领域里，我们需要设计一个流程来整合一切，或者开发更好的工具来统一所有内容。

And then everyone's like kind of siloed in their own way and then we need to kind of come up with a process to tie everything or like build better tools to kind of unify everything.

我们在 Notion 尝试过这一点。

We tried that at Notion.

但问题是，人们已经养成了太多习惯。

But the problem is, like people have like already developed like so much like habits.

改变这些习惯、更换工具非常困难，你无法强迫任何人采用一个并不完全契合他们需求的新工具。

There's like inertia to kind of change that or like change people's tools or like kind of like you can't really force anyone to like, adopt something new that doesn't perfectly fit them.

但有了 AI，有了 Cursor，情况又反转了。

But with AI, with no with Cursor, things kinda flip again.

因为我们希望打造一个能够连接并吸收所有这些工件和格式的系统。

Because we want to kind of build something where it can kind of, you know, connect and absorb all of these artifacts and formats.

将来，也许在 Cursor 内部，同一个代码可以有不同的视图。

And later maybe even like within cursor, like there could be different views of the same code.

比如将代码显示为原始代码或差异视图，这几乎只是最开始的一步。

Like showing the code as raw code or like as diffs is almost like just the very beginning.

编写软件的本质其实就是修改代码。

The act of making software is really just modifying the code.

某种程度上，产品经理撰写产品需求文档（PRD）也是一种修改代码的方式，只不过他们通过更被动的组织方式来实现。

Like in some sense, like the PM writing the PRD is modifying the code, but they're doing it through a more passive organisational way.

也许设计师更多地影响个体。

Maybe the designers influence more individuals.

但当你以这种分散、孤立的方式进行时，会带来大量的沟通协作问题。

But when you do this, know, disjointed lead, there's so much like back and forth collaboration issues.

随着团队规模扩大，情况会变得更加复杂。

As you grow the team, it gets even more complex.

人们开始把软件拆分成碎片。

People start like breaking the software apart.

事情不再简单，也不再统一。

Things are no longer simple, no longer unified.

我们经常说，你最终交付的其实就是你的组织架构图。

Like we always talk about, like you kind of ship your org chart type of thing.

然后不同的角色就会发生冲突。

And then the different roles kind of fight.

设计师是对的，工程师是对的，产品经理也是对的。

Like designers are right, the engineers are right, the PMs are right.

但你知道，存在一个共同的真相，那就是代码——你可以通过代码收集大量信息，将所有东西整合在一起。

But like, you know, there is this shared truth, which is the code where like, you know, you can also gather a lot of information around putting everything, synthesizing everything together.

然后这个代理可以处理所有你可能并不完全了解的事情，但它知道真相。

Then the agent can kind of handle all these things that you might actually not know fully, but it kind of knows the truth.

它可以了解现状，比如你的代码库中有什么、实际在进行的任务或项目，甚至收集来自现实世界的反馈或信息。

It could know the present, which is maybe like, you know, what's in your code base, what are the actual running tasks or projects, even gathering feedback or information from the real world.

它也可以了解过去，比如你积累的所有知识、团队的偏好，以及代码库是如何演变的。

It could be also like, you know, from the past, say like all the knowledge that you've accumulated, your team preferences, like how the code base evolved and gets maybe.

还有未来，比如你在规划未来，思考愿景，或构思一些更大的想法。

There's also the future which is like say you're planning ahead, you're like thinking about the vision, you're maybe ideating some bigger ideas.

你实际上可以用一个代理完成所有这些事情。

You can actually do all of this with just one agent.

但对每个个体用户或团队来说，心中的形态会有所不同。

But in mind, for each individual user or team, in mind take a different shape.

而我们想要的是，有一种基础体验几乎适用于任何人、任何情况。

And then what we want is like, there's like a base experience that almost works for anyone, anything.

但如果你知道自己在做什么，或者有特定需求，就可以更加具体化。

But you can get more specific if you know what you're doing or if you have specific needs.

你甚至可能在未来把 Cursor 当作 Figma 来使用。

You can even maybe use cursor as if you were using Figma at some point in the future.

但不同的是，你不再与这些各自为政、格式独立的应用交互，也不必通过会议或其他方式手动进行转换。

But the difference is you're not interacting with these siloed apps with their own formats, and then you don't have to do the conversion manually with meetings or whatever.

它会自动完成这一切。

Like, it just does it.

你所需要做的，只是思考想法，并以最适合你的方式不断迭代。

Then all you need to do is you're kinda thinking about the idea, you're like iterating on it in whatever way that is the best for you.

对工程师来说，可能是代码编辑器；但对设计师来说，可能更偏向视觉化的东西。

For the for the engineer, it might be like a code editor, but maybe for a designer, it's something more visual.

对于产品经理来说，它可能更像一个文档。

For the PM, it might be something more like a document.

这说得通。

That makes sense.

我很感兴趣，因为随着人工智能的发展，人们对‘品味’这一概念的关注和强调越来越多。

I'm curious given that there's a lot more focus and emphasis on this concept of taste after AI comes about.

现在还出现了一个协作者，它是一个代理，帮助编写代码、设计产品元素。

And now there's also this coworker that's an agent helping with writing code, designing elements of the product.

那么，品味应该存在于哪里？

Where would the taste live?

它从何而来？

Where does that come from?

你能依赖代理来拥有良好的品味吗？

Can you rely on agents for having good taste?

这是否仍然严重依赖于作为人类设计师或开发者的创作者？

Is that still heavily reliant on the creator as the human designer or developer?

我不太喜欢人们把‘品味’这个词挂在嘴边。

I don't really like people talking about taste as a word.

为什么呢

Why is

因为我觉得这个词太模糊了。

Because I think it's so ambiguous.

在我看来，品味更像是从所有选项中进行筛选，但要做到这一点，你必须先看到一切。

Like how I see it is more like I think taste is kinda like there is a part of like you're selecting out of all the options, but in order to do that, you have to kinda see everything.

或者至少你曾经见过。

Or like you have seen it.

你可能深入研究过过去，弄清楚了人们以前是如何做这类事情的。

You have maybe dug into the past, you have kind of figured out, oh these are the ways people did this kind of thing.

你把过去的一些东西联系起来，那些你曾在自然界中见过的，我不知道是人类创造的还是自然形成的。

You made a connection of some stuff from the past where you've seen in nature, where I don't know, some human made it or nature made it.

然后你把这些联系到你自己的东西，或者你想要做的事情上。

And then you kinda connect that to to your thing or the thing you want to do.

或者你随着时间的推移逐渐形成了一种偏好。

Or you kinda over time develop, like, preference.

这几乎像是你自我设定了一个界限：这就是对的。

It's almost like you're self selecting a boundary of this is what is right.

这就是美的。

This is what is beautiful.

这就是好的。

This is what is good.

我认为每个人的情况都非常不同。

And I think it's very different for each person.

没有对错之分。

There is no right, there is no wrong.

这更取决于你所见过的东西。

It's more dependent on say like the things that you've seen.

这几乎就像一个大语言模型。

It's almost like an LLM.

但LLM的问题在于，它实际上见过一切，却并没有真正的观点。

But the problem with an LLM is like it actually has seen everything and it doesn't really have an opinion.

或者它会混淆自己，以为人们喜欢 everywhere 都是紫色渐变。

Or like it kind of confused itself thinking that people prefer purple gradients everywhere.

但真正好的是LMN，因为它见过很多东西，能非常快且出色地完成基础工作。

But what is good is like the LMN, because it has seen a lot of things, it can do the baseline really fast and really good.

而上面的部分则是品味，或者说是你对自己认为什么是好的自我选择。

Then the thing on top is taste, or like your self selection of what is good.

你实际上是在划定界限。

Like you're kind of drawing the boundary.

这是你的决定。

That is your decision.

尽管AI可以越来越多地帮助你完成这一点。

Though the AI can increasingly help you do that.

比如说，我们在光标中新增了一个叫做‘计划模式’的功能。

Say we have a new thing in the cursor called plan mode.

如果你输入提示后不想详细填写，可以切换到计划模式，它会帮你自动生成规范。

If you type in the prompt and then you don't really want to fill in the details, can switch to plan, go, it will kind of just build the spec for you.

然后你可以根据需要添加细节或进行修改。

And then you can add details, you can change it as you want.

但我并不真的相信，你给代理一个长时间运行的、模糊不清的、非常不具体的提示，然后期待它能精确地给出结果。

But it's almost like, I don't really believe in, say, you give the agent something long running or like it's really like occluded, like a really non specific prompt and then expect it to give you exactly which one.

这根本行不通。

Like it's just not gonna work.

必须有人来明确什么是好的、什么是正确的、我想要怎么做。

There needs to be something for the human to specify what is good, what is right, how I want to do it.

如果你不投入自己的判断，它只会产出一堆垃圾。

If you don't put in that opinion, it will just produce AI slob.

是的。

Yeah.

你之前提到过产品经理、设计师和工程师之间那种某种意义上的冲突或互动。

You were alluding earlier to this sort of, you know, fight between product managers, designers, and engineers to some or this sort of dance.

一位面试官说，几年前，这些类别还略有不同。

And an interviewer saying a few years ago, the categories were were somewhat different.

随着界限日益模糊，你认为这些类别未来会如何演变？

As there is this blurring, how do you think these categories will evolve over the years?

我

I

我认为，人们总会有一些优势、独特的专长或某个方面的突出能力。

think, like, people will always have their strength or their unique special skill or some spike.

比如，有些人更擅长协调，有些人擅长视觉设计，有些人则擅长架构底层结构。

Say like some people are more good at coordinating, some people are good at the visual space, some people are maybe good at architecting like you know, the lower level constructs.

但我把所有这些人都看作是软件构建者或创造者。

But I I think of all of these people as just like like they're software builders or makers.

我们当初就是从这里开始的。

Like, we kinda started there.

如果你回望早期计算时代，那时还没有明确的头衔，人们可能是研究人员，但他们也可能设计底层架构。

Like, if you look back when so like the early computing era, there was no title or people were maybe like researchers or like but they they maybe designed a low level architecture.

他们甚至可能还构建了用户界面，以及如何在屏幕上显示界面，整个系统都是他们做的。

They maybe even built the UI and how to display the UI on the screen and the whole thing.

可能是一个人、两个人，或者五个人。

Maybe one person or two or five.

当你这么做时，我想那时候经济约束也少一些，他们有资金支持，并不那么急于赚钱。

And when you did that, and also I think back then there were like less, say economic constraints where they were funded and they weren't like trying to make money as much.

所以他们把整个系统做得非常完整。

So they kind of made the whole thing really whole.

而现在，你把一切都拆分开了。

And now it's like you kinda break everything down.

你试图通过流程和成本优化来改进它们。

You try to optimize them with, like, processes and cost optimizations.

人们只是被局限在小小的领域和问题集中，而实际上整个系统本应是一个整体。

And people just become, like, boxed into little areas and problem sets when the whole thing is actually all together.

我认为这导致了很多问题。

And that causes a lot of problems, I think.

现在人们开发的软件，我不知道，他们甚至不再去思考那种理想状态，那种东西已经丢失了，人们太过于关注技术问题、设计问题、金钱问题，而忽略了整体，忽略了我们真正想为人们改善的是什么。

Like people now make software that, I don't know, like they don't even think of like like there's some like ideal that's kind of lost and people think too much on the technical problems, the design problems, the money problems, not the whole thing or what we're trying to make better for people.

但现在我们似乎在倒退，像Cursor这样的工具，如果你自认为是设计师或开发者之类的人的话。

But we're kind of going backwards now as tools like Cursor, if you were self identified as a designer or developer or something.

我也曾经为此困扰。

I used to also struggle with this.

我曾经自己动手做一切，完整的整个东西。

I started making stuff myself, the whole thing.

然后我来到美国，得到了一份名为产品设计师的工作。

And then I came to The US, I got a job titled product designer.

我停止了编程。

I stopped coding.

我制作了设计稿和原型，然后等待它们实现，一等就是好几年。

I made mocks and prototypes, and I waited for them to happen for like years.

但它们从未实现，或者最终只以一段YouTube视频的形式发布了。

And they don't happen, or they ended up shipping as a YouTube video.

这太疯狂了。

That's crazy.

但有了这个新工具，设计师也能构建了。

But you know with this new tool, a designer can build.

他们可以真正专注于自己的技艺，做自己真正关心的东西，把它做得很好，而其他部分交给代理处理。

They can actually like, you know, work on their craft, stuff that they really care about, make that really good, and let the rest be handled by the agent.

他们可以把自己的品味融入其中。

They can, you know, kind of put their taste on top.

所有那些他们不想操心的事情，都交给代理去做。

And all the stuff that they don't want to worry about, give it to the agent.

但你也可以组建一个非常优秀的团队。

But you can also assemble like a really good team.

比如有非常出色的基础设施工程师、前端工程师、产品经理，他们不只是开开会而已。

So like there's like really good infra engineers, front end engineers, PMs who are like, I don't know, not just running meetings.

把他们聚在一起，给他们相同的工具和代码库，他们就能互相弥补短板，同时放大各自的优势。

Get all of them together, give them the same tool, the same code base, they can start covering each other's weaknesses and then amplify their strength.

而代理程序则掌控着一切。

And the agent kind of holds everything.

你知道，不用再跑去问别人‘你的设计在哪？’，它都知道。

And you know, instead of you pinging this guy, 'Ah, where is your design?' It knows.

是的，这解决了许多常见的冲突：是把更多精力放在软件的功能部分，还是花更多时间在产品的艺术审美层面，使其对用户更具吸引力。

Yeah that resolves a lot of the common conflicts of spending more effort on the functional part of the software or spending more time on the artistic aesthetic side of the product itself and being appealing to the users.

你曾在许多以设计为中心的公司工作过，从Notion到更早的Asana。

And you have worked at many of the very design focused, design centric companies from Notion to even prior to that Asana.

鉴于现在任何人都能接触产品外在的审美部分，你如何看待影响你当前的团队以及像Cursor这样的人，让他们更多地关注这一方面，而不仅仅是产品的功能部分？

Now given sort of the democratization of who can touch that external facing aesthetic part of the product, how do you think about influencing even your current team and people like Cursor to spend more effort in thinking about that versus just the functional part of the product itself?

是的。

Yeah.

我想强调的一点是，设计不仅仅是关于美学。

One thing I want to call out is design is not just about aesthetics.

在我看来，它实际上涵盖了所有架构设计，或者这个东西、甚至整个公司的理念。

How I think of it is, like it's all it actually includes all the say the architectural designs or like all the concepts of what this thing is, or like the company.

以Notion为例，Notion是一个纯粹的概念型产品，意味着每一个概念都是由人设计的。

Say, for Notion as an example, Notion is a pure conceptual product, meaning every single concept was designed by a person.

所以在Notion中，它本质上就是块、页面、数据库和工作区。

So like in Notion, it is really just blocks, pages, databases, the workspace.

然后所有功能都围绕这些概念展开。

And then everything kind of works around these concepts.

而在每一层，都有它们的体现。

And then at every layer, there's like a representation of them.

在最顶层，可能是用户界面、品牌或视觉元素、美学设计。

There could be like, you know, at the very top, there's like the UI or like the brand or like the visuals, the aesthetics.

但事实上，每一层都有其美学体现——比如前端代码和架构的设计，状态如何同步，内容如何渲染，对象如何存储，以及它们如何与产品的核心概念相互关联。

But then there's actually the aesthetics, every layer, how you architect, say, like the front end code and architecture, how they you know, how the reactive states sync and how you render stuff to, like, how do you, like, store these objects, how they, you know, relate to each other to all the core concepts of the thing.

如果你从概念本身来看软件，其实它非常简单。

And if you look at software, it's actually really simple if you look at the concepts themselves.

因此，设计就像是在寻找对我们所有人而言最理想、最简洁的配置和状态。

So design is kind of like trying to figure out what is the best configuration and the simplest state for all of us.

有些人可能只关注视觉效果、交互的某些片段。

Some people maybe only focus on the visuals, where the interactions were, certain slices.

但我认为真正的美在于尽可能把所有东西整合在一起。

But I think the beauty is actually putting things all together as well as you can.

所以我认为这正是我刚才提到的。

So I think it is really about what I just talked about.

它不是简单地纠结于该用六像素还是四像素的圆角边框。

It's like not seeing design as just, should we use a six pixel border radius or four?

而是应该思考：如何设计一个最简单的系统，用最少的概念和最少的代码路径，为最多的人实现最多的功能？

But it's rather, like, how do I design the most simple system, fewest number of concepts, fewest code paths to do the most things for most people?

你们显然在开发者群体中拥有极佳的产品市场契合度。

You guys obviously have incredible product market fit with developers.

你们之前已经提到过一些，但能否更深入地分享一下，你们是如何应对设计用户需求的思维迷宫的？或者，你们认为在工具开发上还有哪些机会？

Can and we've alluded to a bunch of it, but can you share more about maybe either how you guys have navigated the IdeaMaze of how you wanna serve designers or just more around what kind of tooling you think there's an opportunity to provide?

嗯。

Mhmm.

嗯。

Yeah.

所以我认为 Cursor 的主要焦点仍然是专业开发团队。

So I think Cursor is still like, our primary focus is on professional developers teams.

但正因为如此，他们周围的人也已经在这里了。

But because of that, like, people around them are already here.

嗯。

Yeah.

长期以来，我们实际上是有意让 Cursor 对非技术人员来说很难进入。

And I think for the longest time we've been actually intentionally making cursor pretty hard to get in for say the non technical people.

但他们现在已经在这里了。

But they are here now.

他们实际上很难进入，而且非常希望进来。

And they actually struggle to get in, and they really want to get in.

一个例子是，当你打开 Cursor 时，会有三个按钮。

One example is, like, when you open up Cursor, there's, like, three buttons.

它显示的是打开项目、连接SSH、克隆仓库之类的选项。

It says open project, connect to SSH, clone repo or something.

作为初学者或非技术人员，我完全看不懂这些。

As a beginner or, like, a nontechnical person, I can't understand any of this.

但如果我们直接给你一个空白的智能代理视图呢？

But what if say, like, we just kinda give you the agent view blank.

你可以直接开始做事情。

You can just start doing things.

我们可以改进很多小细节，让Cursor对这些与技术相关但不会编程的人更友好、更易亲近——他们可能懂一些软件概念或某些层面，但不一定能写代码。

Like there's a lot of little things we can kinda fix to just make Cursor feel more friendly and welcoming for these people who are like kind of inj adjacent people who are maybe they know software concepts or certain layers, but they might not be able to code.

我希望当他们进来时，不会感到不知所措，也不会觉得‘哦，这是个代码编辑器，是个IDE’，而是感觉我可以直接开始做事。

I want to make sure that when they come in they can, like without feeling overwhelmed or feeling like, 'ah, this is like a code editor, it's an IDE', it is more like I can start doing things.

当我开始做事时，我可以慢慢选择自己偏好的路径。

And then as I start doing things, I can maybe like pick the paths that I prefer.

比如选择一个设计师，他们可能只是和旁边的浏览器聊天。

Select a designer, maybe they're just like kinda chatting with the browser next to it.

当代理在进行编辑时，它们可以预览这些更改。

As the agent is like making edits, they can kinda preview the changes.

它们可以在浏览器中跟踪，选择这个元素，然后说：‘我想把这个换成别的’，然后瞬间就完成了。

They can maybe like in track in the browser, pick this element, change like, ah, I want to swap this with something else, and then boom, it happens.

所以我们做这件事的方式，并不是创建新产品或拆分 Cursor。

So how we do it is not, say, creating new products or splitting cursor.

这其实是同一个东西，只是做了不同的预配置和打包。

That is the same thing, but just, like, different pre configurations and packaging of the same thing.

因为就像我刚才说的，从概念上讲，Cursor 本身其实非常简单。

Because kind of like what I just said, thinking about the concepts, cursor itself is actually really simple.

或者说，AI 代理整体上都相当简单。

Or like AI agents in general are pretty simple.

如果你看看，比如一个 ChatGPT 代理、Cursor、Replit 的 A0，甚至 Notion 代理，它们的架构或工作方式几乎是相同的。

What you want to do is actually like not like, if you look at, I don't know, like a chat GPT agent versus like a cursor versus like a repl dot a v zero, a Notion agent even, the architecture or how they work are like, they are almost the same.

那么，如果我们能制定一套通用的共享概念，用于与 AI、代理、代码和软件交互，但又能对每个版本进行调整，以适应更多人和更多使用场景，会怎么样？

So what if we can come up with like a set of universal shared concepts for interacting with AI, with agents, with code, with software, But you can kind of mutate each each one to fit more people and to fit more use cases.

然后每个工具都可以利用最佳模型来完成这个UI操作，并提供最适合我的视图。

And then each of them can leverage, say, the best model to do this UI thing with the best view that fits me.

我可以按照自己的喜好进行配置。

I can configure it however I want.

如果我想看到一切，我就可以做到。

If I want to see everything, I can.

如果我不想看到任何东西，我也可以做到。

If I don't want to see anything, I can too.

这引出了我的一个问题：在过去几年——我不确定是几年还是十年——出现了针对特定用户角色的专用工具，比如Webflow针对特定用户角色或用例（如着陆页），Vercel v0则更面向前端开发者构建Next.js应用。

This leads to my question of over the last few years and I don't know if it's few years or a decade, there is the concept of purpose built tools for certain persona, whether it's Webflow for persona or use cases like for landing pages, Vercel v0 for more of the front end developers building Next.

Js应用。

Js apps.

有面向设计师的工具。

There are tools for designers.

有从设计到工程的交接工具。

There are tools for handoff from design to engineering.

现在则更多地出现了‘万能应用’的概念。

Where now there's more of a concept of the everything app.

ChatGPT 就是一种万能应用。

ChatGPT is kind of everything app.

Notion 也是一种万能应用。

Notion is kind of everything app.

你可以在上面做笔记，但也可以发布 Notion 页面。

You can go to it for your note taking, but you can also publish Notion pages.

Cursor 正在变得更加像一个万能应用。

Cursor is becoming more of an everything app.

我们是否正朝着拥有这些无所不包的应用方向发展，这些应用能完成过去由单一专用应用承担的更多任务？

Is that a path that we're going down towards of having these all encompassing apps that can do a lot more things that used to be captured by a single purpose app?

针对特定使用场景或用户角色的专用工具还有存在的空间吗？

Is there still a place for purpose built tools for a specific use case or persona?

你如何看待这一点

How do you see that

我认为这只是做事情和开发软件的不同理念。

I think it's just like different philosophies of doing things and making software.

我觉得看待这件事的方式几乎有两种。

I think there's like almost like two ways you can look at the thing.

有一种是以用户为中心、以人为本的设计路径，也就是你从一个问题出发。

There is this, like, the user centric, human centered design path, which is, you know, you start from a problem.

你先找出有这个问题的群体，弄清楚他们想要什么，然后为他们打造非常具体的解决方案。

You identify the group of people who have this problem, figure out, you know, what they want, build really specific solutions for them.

而另一种是从系统角度思考问题，你关注的是软件本身的结构，然后思考如何稍作调整来满足某个限制条件，或让这个用例可行，或让这个工具能为这些人服务。

Versus, like, there's the more system angle to think about things, where you're just kind of looking at the software itself, how it is composed, and then think about, where do I tweak a little bit to satisfy this constraint or to make this use case work or to enable this tool to work for these people?

我认为这本质上是两种不同的理念。

I think it's fundamentally two different philosophies.

然后我认为，做以用户为中心的方式要容易得多。

Then I think it is much easier to do the, say, the user centric way.

但它从一开始就限制了你的可能性。

But it kind of limits you from the beginning.

因为当你开始构建这些特定解决方案时，它们只适用于那些特定的人。

Because when you start building these specific solutions, they only work for those specific people.

如果你想扩大用户群体或扩展使用场景，实际上需要彻底拆解你现有的所有东西和核心概念。

If you want to grow the people or you want to grow the use cases, you actually need to kind of tear apart everything you have, your core concepts.

但很多人根本做不到这一点。

And a lot of people just can't do that.

所以他们选择不做这种拆解，而是添加更多东西、更多概念、更多功能。

So what they do is instead of doing that, they add more things, more concepts, more features.

然后就会出现一个节点，这个东西不再服务于你最初的一群用户。

And then there will be a point where this thing no longer serves your initial group of people anymore.

简单的东西不再简单了。

The simple thing is no longer simple.

有目的性的设计也不再简单了。

The purposeful thing is no longer simple.

所有这些有目的性的应用，某种程度上都是自私的。

And all of these purposeful apps, they're kind of selfish.

它们将人们和工作流程孤立起来，为我们的文件格式创建了孤岛。

They are siloing people, siloing workflows for our file formats, creating islands.

但如果你仔细看这些所谓的目的性应用，不管是什么。

When if you look at the thing, like all these purposeful app whatever.

我也在Asana工作。

It's like I also work at Asana.

Asana的核心概念其实是任务和项目。

Asana, the core concepts are really tasks and projects.

所有东西都围绕着任务和项目展开。

Everything around tasks and projects.

它们添加的任何功能都必须与这些核心概念兼容，这自然限制了它的能力。

Everything they add needs to work with those, and that naturally limits what it can do.

相比之下，比如Notion。

Versus, say, like Notion.

我们看待Notion的方式，它并不是一个笔记工具。

Like how we see Notion, it is not note taking.

它被伪装成笔记工具。

It is disguised as note taking.

你进来后可以从空白页面开始，直接打字。

Like you come in, you can start from a blank page, can type.

但你实际上是在创建博客页面、数据库和工作空间。

But then what you're doing is actually like, you know, blog pages, databases, and a workspace.

每个模块几乎就像一个 JSON 对象。

Each block is almost like a JSON object.

一个页面就是一组 JSON 对象的数组，然后我们根据每个模块的布局和类型进行渲染。

A page is just an array of JSON objects, and then we render each block in the layout and the type it is.

然后你可以把它们放入数据库中。

And then you can put them in a database.

现在它们拥有了更多属性。

Now they have more properties.

它们共享了更多内容。

They share more stuff.

层级更多了。

There's more hierarchy.

所有页面都可以相互嵌套。

And all pages can nest each other.

这就是Notion。

That is Notion.

但你可以用它做任何事情。

But then you can do whatever with it.

你可以有任务、项目数据库，它们都能协同工作。

You can have a task, project database, they all work together.

它们可以是列表，也可以是看板。

They can be a list, they can be a board.

随你怎么用。

Do whatever you want.

但问题是，你知道，对于这种更通用的应用来说，因为它太开放了，所以刚开始有点难上手。

But then the problem is, you know, for these more universal type of apps, it's like because it's so open ended, it's kinda hard to get started.

如果我没有耐心去慢慢弄清楚它是如何工作的，我可能根本不会接触到测试和项目。

If I don't have the patience to kinda figure out how it works, I might not even get to the tests and projects.

所以总是存在这种张力，但它是可以解决的。

So there's always that tension, but it is fixable.

你可以打造更好的包装。

You can build better packaging.

你可以使用人工智能。

You can use AI.

所以我认为，我个人的偏好是，我会尝试打造一个比‘只有这些人才是我们关心的对象’更好用的东西。

So I think there's just like my personal preference is I would try to build something that works better for everyone than just, ah, these people are the people we care about.

我不关心其他所有东西。

I don't care about everything else.

然后我认为他们应该使用我的东西。

And then I think they should use my thing.

这不是正确的做法。

That's not how you do it.

我们谈论AI，谈论智能代理，以及它们如何极大地加速了构建和原型设计。

We talk about AI, we talk about agents, and we talk about how it really speeds up building things and prototyping.

但当真正涉及到帮助用户更好地理解产品、完成引导和学习新概念时，作为设计师或设计领导者，与AI的互动如何真正提升产品的可用性和实用性？

But when it really comes to these type of helping users to understand the product better, onboarding, learning the new concepts, also to you as a designer, design leader, how does interacting with AI really improve the usabilityutility of the product?

是的，我觉得AI几乎就像一个通用接口。

Yeah, I see AI almost like it's almost like a universal interface.

而它的最基本形式就是输入一个提示，然后得到一些回应。

And then the bare minimum of it is really just a prompt and then you get some response.

然后你可以将这种形式应用到各种不同的场景中。

Then you can kind of put this into like different forms.

它可能只是一个小小的输入框，比如聊天窗口。

It could be like a little input, like a chat box.

它也可能是一个侧边栏，你可以看到聊天内容。

It could be like a sidebar, you know, you see the chat.

也可能是你选中某个内容后，可以对其进行操作。

It could be maybe you select something, you can do stuff with it.

但它也可以直接说：你完全转换这个图层。

But it could also say like, you completely transform this layer.

这并不是聊天。

It's not chat.

这也不是一种输入。

It's not like an input.

它更倾向于说，甚至更有目的性。

It's more fitted to say, it's more purposeful even.

但其底层仍然是同样的东西。

But underneath it is still the same thing.

它仍然是同样的AI、同样的代理、同样的架构，你可以切换不同的模型和提示等内容，但本质上它就是如此。

It is still the same AI, same agent, same architecture, same like you can flip different models and prompts and stuff, but then fundamentally that is what it is.

但正因为如此，你实际上可以构建出许多不同的层级和形态。

But because of that you can actually build a lot of different layers and shapes.

这样每个人都能找到适合自己的形态，使用起来也会更舒适。

Then each person can find the shape that fits them and it will feel more comfortable.