Cursor 的崛起:年经常性收入 3 亿美元、工程师们爱不释手的 AI 工具 | Michael Truell
Cursor 的崛起:年经常性收入 3 亿美元、工程师们爱不释手的 AI 工具 | Michael Truell
文字记录
开场预览
Michael Truell: 我们的目标是用 Cursor 发明一种全新的编程,一种截然不同的软件构建方式。可以说是某种”代码之后”的世界。我认为,做工程师会越来越多地开始像做逻辑设计师——真正核心在于精确表达你希望一切如何运转的意图。
Lenny Rachitsky: 迄今为止,在构建 Cursor 的过程中你学到的最反直觉的事情是什么?
Michael Truell: 我们完全没想到自己会做任何模型开发。而到了现在,Cursor 中每一个令人惊叹的时刻,在某种程度上都离不开自定义模型。
Lenny Rachitsky: 进入这个角色之前,你希望自己早就知道的是什么?
Michael Truell: 很多人说招聘要快,但我认为我们一开始实际上招得太慢了。
Lenny Rachitsky: 你们在一年半内从零做到一亿美元年经常性收入,这是历史性的。是否有一个拐点,一切开始真正起飞?
Michael Truell: 增长基本上一直沿着指数曲线走。指数增长在数字很低的时候感觉很慢,一开始并没有一飞冲天的感觉。
Lenny Rachitsky: 你认为成功的秘诀是什么?
Michael Truell: 我觉得是……
嘉宾介绍
Lenny Rachitsky: 今天的嘉宾是 Michael Truell。Michael 是 Anysphere 的联合创始人兼 CEO,也就是 Cursor 背后的公司。如果你与世隔绝还没听说过 Cursor——它是目前领先的 AI 代码编辑器,正处于改变工程师和产品团队构建软件方式的最前沿。它也是有史以来增长最快的产品之一,推出仅 20 个月就达到一亿美元年经常性收入,推出仅两年就达到三亿美元年经常性收入。
Michael 在 AI 领域工作了十年。他在 MIT 学习计算机科学和数学,在 MIT 和 Google 做过 AI 研究,同时也是科技和商业史的学生。正如你即将看到的,Michael 对事物的发展方向有着深刻的思考,对软件构建的未来有着清晰的判断。我们聊了 Cursor 的起源故事、他对”代码之后”会怎样的预测、在构建 Cursor 过程中最反直觉的教训、他对软件工程师前景的看法,以及更多内容。
Michael 很少做播客。他唯一做过的另一档播客是 Lex Fridman 的节目,所以能邀请到 Michael 是真正的荣幸。如果你喜欢这档播客,别忘了在你常用的播客应用或 YouTube 上订阅关注。接下来,为你带来 Michael Truell。
“代码之后”的愿景
Lenny Rachitsky: Michael,非常感谢你来参加节目。欢迎来到播客。
Michael Truell: 谢谢,很高兴来到这里。感谢邀请。
Lenny Rachitsky: 我们之前聊天时,你提到了一个很有趣的说法——“代码之后”会是什么这个想法。能谈谈吗?就你的愿景,从代码走向也许是别的东西,事情会怎样发展。
Michael Truell: 我们的目标是用 Cursor 发明一种全新的编程,一种截然不同的软件构建方式。它浓缩到本质就是,你以尽可能简洁的方式向计算机描述你的意图,真正归结到只是定义你认为软件应该如何运作、应该如何呈现。凭借我们今天拥有的技术,并且随着它的成熟,我们认为可以发明一种比现有方式层次更高、效率更高的软件构建方法,在某些情况下也更容易上手。
这个过程将是逐步远离今天软件构建的模样。我想把它与几种流行的未来软件愿景做个对比——至少有一些愿景,我们并不完全认同。一派人认为未来的软件构建会和今天非常相似,主要还是文本编辑、正式的编程语言,比如 TypeScript、Go、C、Rust。还有另一派人,基本认为你只需要在一个机器人里打字,让它帮你构建东西,然后让它修改正在构建的某些内容,就像聊天机器人、Slack 机器人那样——你在跟你的工程部门对话。
我们认为这两种愿景都有问题。在聊天机器人那一端……我们认为实际情况会比这两种都更出人意料。聊天机器人方式的问题在于,它缺乏很多精确性。如果你想让人类对软件的外观和行为有完全的控制权,就需要让他们以一种比”改一下我应用里的这个”更精确的方式来指向自己想要修改什么——在一个脱离整体的文本框里描述是不够的。而那种什么都不变的版本,我们认为是错的,因为我们认为技术会变得非常、非常、非常好。
代码之后的世界
Michael Truell: 所以,代码之后的世界,我认为它会是这样一种状态:你对软件逻辑有一种表示形式,看起来更接近英语,你写下来的是……你可以想象某种形式上的演进,你可以想象编程语言朝伪代码方向的一种进化。你写下了软件的逻辑,你可以在高层面上编辑它,也可以指向它。它不会再是那种密不透风的几百万行代码,而是会更加简洁,更容易理解,更容易导航。那个把疯狂的、难以理解的符号开始向更人类可读、人类可编辑的方向演进的世界,正是我们正在努力迈向的方向。
Lenny Rachitsky: 这是一个非常深刻的观点。我想确保大家不会错过你在这里说的——你设想的未来,基本上从明年开始事情就会开始转变,人们会逐渐远离看到代码、不得不用 JavaScript 和 Python 的方式去思考代码,而会出现一种抽象层,本质上就是伪代码,用更接近英语的句子来描述代码应该做什么。
Michael Truell: 没错。我们认为最终的方向就是这样,而且我们有一个很坚定的看法:这条路径必须经过现有的专业工程师,它看起来像是代码的一种渐进式远离。而且人类一定仍然坐在驾驶位上,人类对所有软件层面都拥有大量控制权,并且不会放弃这些控制权。同时人类还能非常快速地做出修改,拥有一个快速的迭代循环,而不是在后台放一个超级缓慢、要花几周时间的东西来替你做所有工作。
哪些技能会越来越有价值
Lenny Rachitsky: 这就引出了一个问题——对于那些现在是工程师、或者正在考虑成为工程师的人,以及设计师、产品经理来说,在这个代码之后的世界里,你觉得哪些技能会越来越有价值?
Michael Truell: 我认为品味(taste)会越来越重要。人们往往在软件领域谈论品味时,想到的是视觉方面——流畅的动画、配色、UI、UX 等等视觉设计上的东西。视觉层面确实是定义一款软件的重要组成部分,但如前所述,定义一款软件的另一半是它的逻辑,是这个东西怎么运作。
我们已经有非常出色的工具来定义视觉部分,但一旦涉及到软件运作的逻辑,目前我们最好的表示方式实际上就是代码。你可以用 Figma 大致示意一下,也可以写写笔记来描述,但真正让你有一个可运行的原型的还是代码。所以我认为,越来越多地,做工程师会开始感觉像做逻辑设计师,核心将是指定你的意图——你到底想让一切怎么运作。它会更关注”做什么”,而不是”底层具体怎么做”。
我认为品味会越来越重要。软件工程中有一个方面——我们现在离那个状态还差得很远——网上有很多搞笑的梗,说的是人们过于信任 AI 做工程工作后遭遇的各种磨难,比如做出的应用有明显的缺陷、问题和功能故障。但我认为我们最终会到达这样一个阶段:作为软件工程师,你可以不那么小心谨慎——而现在,小心谨慎是一项极其、极其重要的技能。我们会稍微从谨慎中移开一点,更多地转向品味。
与 Vibe Coding 的关系
Lenny Rachitsky: 这让我想到了 vibe coding——你说不用再那么关注细节、顺着感觉走,是不是就是在描述这个?
Michael Truell: 我认为有关联。我觉得 vibe coding 目前描述的正是这种颇具争议的创作状态——你生成了大量代码,但并不真正理解其中的细节。这种创作状态随后会带来很多问题——因为不了解底层细节,你很快就会到达一个瓶颈,你创造的东西大到你自己已经无法修改了。所以我认为我们感兴趣的一些想法——如何在人们不太理解代码的情况下,让他们继续对所有细节保持控制——我认为这些解决方案对于现在正在 vibe coding 的人来说非常相关。我认为目前我们还无法让有品味的人真正对软件拥有完全的控制权。vibe coding 的另一个问题,也是让品味真正从人身上闪耀出来的障碍,在于你可以创造东西,但其中很多是 AI 在做决策,那些决策难以驾驭,而你没有控制权。
Lenny Rachitsky: 沿着这条线再问一个问题。你刚才抛出了”品味”这个词。你说品味的时候,你指的是什么?
Michael Truell: 我指的是对”应该构建什么”有正确的想法。它将越来越成为这样一种状态:毫不费力地将”我想要构建的精确内容”翻译出来——你想要一切怎么运作、你想要它看起来什么样,然后你就能在计算机上把它做出来。而不再那么需要这个翻译层——你和你的团队脑海中有想构建的东西的图景,然后你必须极其辛苦、极其费力地把它铺展成一种计算机可以执行和解读的格式。所以比起 UI 层面的东西,也许”品味”这个词有点不太准确,它更是关于对”应该构建什么”有正确的想法。
Cursor 的起源故事
Lenny Rachitsky: 太好了。好的。这些问题我之后还会回来聊,但现在我想先把镜头拉回到 Cursor 的起点。我从来没听过这个创始故事,我觉得很多人也不知道这一切是怎么开始的。基本上你们在打造的是人类历史上增长最快的产品之一,它正在改变人们构建产品的方式,改变职业、专业,改变很多东西。这一切是怎么开始的?早期旅程中有什么难忘的时刻吗?
Michael Truell: Cursor 最初有点像是先有了方案再去寻找问题,很大程度上源于对 AI 在未来十年会如何变好的反思。有两个决定性的时刻。一个是使用 Code Pilot 的第一个测试版时感到非常兴奋。那是我们第一次使用一款真正、真正、真正有用的 AI 产品——它不仅仅是有些用处,而且完全不是那种只有演示效果的空中楼阁。
除了是我们用过的第一款真正有用的 AI 产品之外,Code Pilot 也是我们采用过的最有用的开发工具之一,甚至没有之一,这让我们非常兴奋。另一个让我们兴奋的时刻,是一系列来自 OpenAI 和其他地方关于规模化(scaling)的论文,这些论文表明即使没有新的想法,AI 也会变得越来越好,只需要拉动一些简单的杠杆,比如扩大模型的规模,以及扩大输入模型的数据规模。
从机械工程到编程
Michael Truell: 因此,在 2021 年底、2022 年初,我们开始对 AI 产品的可能性感到兴奋——这项技术在未来会逐渐成熟。而当我们环顾四周时,发现很多人在谈论如何制造模型,但似乎没有人真正选定一个知识工作领域,去思考随着 AI 越来越强,这个领域会变成什么样子。这让我们开始了一场构思创意的探索:随着这项技术不断成熟,这些知识工作领域在未来会发生怎样的变化?工作的终态会是什么样子?我们用来完成工作的工具会如何改变?模型又需要在哪些方面变得更强才能支撑这些工作方式的变化?当 scaling 和预训练的收益耗尽后,如何继续推动技术能力的提升?
Cursor 最初走了一段弯路。我们其实做了这么一场宏大的分析,然后决定选一个我们认为相对没有竞争、沉闷乏味、没人关注的领域。因为我们觉得:“编程当然很好,AI 当然会彻底改变编程,但已经有人在做了。“所以最开始有四个月的时间,我们其实在做一个完全不同的方向——帮助自动化和增强机械工程,为机械工程师打造工具。
这个方向从一开始就问题重重。我和我的联合创始人都不是机械工程师。我们有朋友是做机械工程的,但我们对这个领域非常陌生。所以从一开始就有点盲人摸象的感觉。问题还包括:如何将现有的模型真正用在机械工程上?我们的结论是,你必须从一开始就开发自己的模型。而要做到这一点非常棘手,互联网上关于各种工具和零部件的 3D 模型数据少之又少,构建这些 3D 模型的步骤描述更是稀缺,然后从拥有这些数据的源头去获取它们本身也是一件困难的事。
但最终,我们清醒了过来。我们意识到自己对机械工程并没有那么兴奋,那不是我们想要为之奋斗一生的事业。我们重新环顾四周,发现在编程领域,尽管过去了相当一段时间,却并没有发生太大的变化。而且我们感觉,那些正在这个领域耕耘的人可能跟我们之间存在某种脱节——他们对未来一切的走向、对整个软件开发将被这些模型所颠覆的图景,似乎没有足够的雄心。正是这一点,把我们推上了打造 Cursor 的道路。
Lenny Rachitsky: 有意思。首先我很喜欢这一点——人们常常听到的建议是去选择一个无聊的行业,因为没人会去竞争,机会就在那里。有时候这确实奏效,但在这段经历中,你们的结论反而是:“不,要去追逐最热门、最受关注的领域——AI 编程、应用构建。“而且你们成功了。你刚才的说法是,你没有看到足够多的雄心,你认为还有更多事情可以做。这感觉是一个很有意思的启示。即使某个领域看起来像是”太晚了,GitHub 在那里,Code Pilot 已经发布了”,还有其他产品——如果你注意到它们只是没有达到应有的雄心水平,或者没有你那么有雄心,或者你发现了它们方法中的缺陷,那仍然存在巨大的机会。这个总结准确吗?
Michael Truell: 完全准确。其中一部分原因在于,你需要存在可以实现的跨越式突破,你需要有可以去做的事情。而我认为 AI 令人兴奋的地方在于——在很多领域都是如此,在我们的领域尤为明显,后面可以谈谈我们如何思考这个问题、如何应对这个问题——天花板真的非常高。是的,如果你环顾四周,即使取每个领域最好的工具,未来几年仍然有大量工作要做。拥有这样的空间、拥有这样高的天花板,我认为在软件领域中是独特的,至少在 AI 领域这种天花板的高度是独一无二的。
为什么选择 IDE 路线
Lenny Rachitsky: 我们回到 IDE 这个问题。你们当时有几条路可以走,其他公司也在走不同的路线。一种是构建一个供工程师在其中工作的 IDE,并在其中添加 AI 的能力;另一种是做一个完全由 AI 代理驱动的开发产品;还有一种是专注于构建最好的编程模型。是什么让你认定 IDE 这条路是最好的选择?
Michael Truell: 那些从一开始就只做模型的人,做的是端到端的自动化编程。我认为他们试图构建的东西跟我们截然不同——我们关心的是让人类对所构建工具中的所有决策保持掌控。而那些人很大程度上设想的未来是:端到端,整个过程由 AI 完成,也许连所有决策也由 AI 来做。所以,一方面是出于个人的兴趣取向。另一方面,我认为我们始终努力对技术目前所处的位置保持强烈的现实主义态度——我们对 AI 在未来几十年将如何成熟感到非常、非常、非常兴奋,但我觉得人们有时会有一种本能反应:看到 AI 在某个领域展现了神奇的能力,就开始将这些模型拟人化,觉得它在这个领域比聪明人强,那它在那个领域一定也比聪明人强。
但这些模型有巨大的缺陷。而我们从一开始的产品开发流程就是围绕 dogfooding 进行的——每天高强度地使用自己的工具。我们绝不想发布任何对自己没用的东西,而我们有条件这么做,因为我们自己就是我们产品的终端用户。我认为这会让你对技术目前的真实水平产生一种清醒的认知,所以这 definitely 让我们意识到必须让人类坐在驾驶位上,AI 无法包办一切。同时,我们出于个人原因也希望把控制权交给人类——这就让你不会只做一家模型公司,也让你不会只做那种没有人类掌控的端到端自动化产品。
至于为什么选择做一个 IDE,而不是现有编程环境的插件,原因在于我们相信编程将会流经这些模型,实际的编程活动在未来几年会发生很大变化。而现有编程环境提供的可扩展性实在、实在、实在太有限了。所以如果你认为 UI 可能会发生很大变化,如果你认为编程的形式会发生很大变化,你就必然需要对整个应用程序拥有控制权。
Lenny Rachitsky: 我知道你们现在有一个 IDE,这大概也会让你对未来走向有一种偏向。但我很好奇,你认为未来的一个重要组成部分是否也会是那些坐在 Slack 里帮你干活的 AI 工程师?有一天这会融入 Cursor 吗?
Michael Truell: 我觉得你会希望能够相当轻松地在所有这些形态之间切换。有时候你可能想让 AI 自己跑一段时间,然后你把它的成果拉回来,非常快速地和它协作,然后再让它自己去跑。所以这种后台与前台形态之间的切换,我认为你会希望它们在一个地方都能顺畅运行。而我认为后台模式特别适合一类编程任务——就是那种不需要太多描述就能精确说明你要什么、以及正确性标准是什么的任务。
Bug 修复就是一个很好的例子,但这显然不是编程的全部。所以我认为 IDE 的形态会随着时间彻底改变,我们打造自己编辑器的做法,前提假设就是它必须随着时间不断演进。我认为这既包括你可以从不同的界面入口派发任务,比如 Slack、你的 issue tracker 或其他什么工具;也包括你盯着看的那块”玻璃板”本身会发生很大变化。我们主要把 IDE 看作是你构建软件的地方。
编程变管理:AI 时代的工程师角色
Lenny Rachitsky: 我觉得人们在谈论 agent 和那些将替你干活的 AI 工程师时,有一件事说得不够,那就是:我们所有人都在变成工程管理者,手底下管着一堆没那么聪明的下属,你得做大量的 review、审批和需求说明。我想听听你对此的想法——有没有什么办法能让这件事变得更容易?因为这听起来真的很难。任何带过大团队的人都会有这种感觉:“天哪,这些初级员工不停地来找我,一遍又一遍地交出质量不高的工作。“就像,“这什么日子啊,太糟了。”
Michael Truell: 是的。也许你得跟它们做一对一……
Lenny Rachitsky: 太多一对一了。
Michael Truell: 是的。我们看到在 AI 上取得最大成功的客户,实际上在使用方式上仍然相当保守。所以我认为今天最成功的用户确实很依赖像我们的 next edit prediction 这样的功能——你的编码流程是正常的,而系统把你接下来要做的动作预测出来。他们也很依赖把交给 AI 的任务范围缩小。在你用来 review 代码的时间比例固定的情况下,对于来自 agent 或整体来自 AI 的产出,有两条路径:一条是,你可以在前期花大量时间把需求写清楚,AI 去干活,然后你去 review AI 的工作成果,然后就完成了。这就是整个任务。
或者你可以把任务切得很碎。先指定一点,AI 写一点,review 一下,再指定一点,AI 再写一点,再 review。自动补全就处在这个谱系的某个位置上。而我们仍然看到,目前使用这些工具最成功的人,往往就是把任务切得很碎,让事情保持相当可控的状态。
Lenny Rachitsky: 听起来没那么糟糕了。我很高兴这里有解决方案。我想回到你们最初构建 Cursor 的时候。你意识到”它准备好了”的那个节点是什么?有没有一个时刻让你觉得”好吧,是时候把它放出去了,看看会发生什么”?
Cursor 的诞生与早期构建
Michael Truell: 我们刚开始构建 Cursor 的时候,对于一直闭门造车而不对外发布这件事相当警惕。而且一开始,我们其实……Cursor 的第一个版本是完全从零手写的。现在我们以 VS Code 作为基础,就像许多浏览器以 Chromium 作为基础一样,然后在此基础上构建。但一开始我们没有这样做,而是从零构建了 Cursor 的原型,这涉及大量工作。我们必须自己搭建……一个现代代码编辑器包含很多东西,包括对多种语言的支持、在语言之间跳转的导航支持、错误追踪支持等。还有像集成命令行、使用远程服务器、连接远程服务器来查看和运行代码的能力。所以我们就进入了这种疯狂快速建造的模式,从零搭建自己的编辑器,同时还要做 AI 部分。
大概五周之后,我们就已经完全在这个编辑器上生活了,抛弃了之前用的编辑器,开始使用新的。等它到了让我们觉得有点好用的程度,我们就把它交到了其他人手上,经历了一个非常短的 beta 阶段。然后从写下第一行代码算起,大概两三个月内我们就向全世界发布了,我觉得大概三个月左右。这绝对是一种”赶紧把东西放到人们面前,然后快速在公开环境中迭代”的思路。让我们意外的是,我们原以为会在很长一段时间内只为几百人构建。但从一开始就涌现了大量关注,以及大量的反馈。那非常有帮助,我们从中学到了很多。那其实也是我们转向基于 VS Code 而不是继续手写编辑器的原因。很大程度上是被早期用户反馈推动的,之后就一直公开迭代至今。
从 $0 到一亿年经常性收入的增长
Lenny Rachitsky: 我喜欢你轻描淡写你们的增长势头的样子。我记得你们大概在一年、一年半左右的时间里从零做到了一亿美元的年经常性收入,这是历史性的。你觉得这种成功的关键是什么?你刚才谈到了 dogfooding 是其中很重要的一部分。你们三个月就做出来了,这太疯狂了。你觉得你们成功的秘诀是什么?
Michael Truell: 三个月那个版本其实不太好,所以我认为一直以来是一种持续的危机感——这个东西有太多可以改进的地方了。最终目标真的是发明一种全新的编程形式,大量自动化我们今天所知的编码工作。无论 Cursor 发展到什么阶段,我们都觉得自己离那个终极目标非常非常远,总有大量事情要做。很多进展并不在于最初那一下冲刺,而在于这个工具持续的演进,让它不断变得更好。
Lenny Rachitsky: 在那三个月之后有没有一个拐点,让一切真正开始起飞?
Michael Truell: 说实话,一开始感觉相当缓慢,也许这源于我们自己的一些急躁。我觉得整体的增长速度至今仍在让我们感到意外。其中最令人惊讶的事情之一是,增长一直相当稳定地遵循一条指数曲线,就是持续的月环比增长,有时会因为我们发布新产品或其他事情而加速。但一条指数曲线在初期看起来其实相当缓慢,数字真的很低,所以一开始并没有那种一飞冲天的感觉。
Lenny Rachitsky: 在我看来这就像是”做好了,他们就会来”真正应验了。你们就是做了一个自己作为工程师也热爱的优秀产品,放到外面,人们就爱上了它,然后口口相传。
产品聚焦与取舍
Michael Truell: 本质上这一切都只靠我们自己——团队专注于打磨产品,用产品本身的质量来替代那些你可以花时间去做的事情。我们确实也花了很多时间在其他方面,比如组建团队就极其重要,做轮值客服支持也很重要。但有些在创业初期人们通常会去做的事情,我们真的任由那些火烧了很久,尤其是在销售和市场营销方面。
所以就只是专注于产品,先做一个你自己喜欢、团队也喜欢的产品,然后再针对一部分用户去做调整。这听起来可能很简单,但你也知道,要真正做好很难。而且有很多不同的方向可以跑,很多不同的产品方向。我认为保持专注、战略性地选择正确的东西去构建、有效地排列优先级,这些都是棘手的。我觉得这个领域另一个棘手之处在于,它是一种新形式的产品构建——它非常有跨学科色彩,我们处于一家普通软件公司和一家基础模型公司之间的某个位置。我们在为数百万人开发产品,这一方面必须做到卓越;但与此同时,产品质量的另一个重要维度是在科学层面越做越多,在模型层面越做越多——在那些合理的领域。所以把这一部分也做好一直很棘手。整体来说我想指出的是,也许有些事情听起来很简单、很容易描述,但做好它很难,而且有很多不同的方向可以跑。
[广告部分已跳过]
反直觉的认知:自研模型
Lenny Rachitsky: 到目前为止,你在构建 Cursor、构建 AI 产品方面学到的最反直觉的事情是什么?
Michael Truell: 我觉得一件对我们来说很反直觉的事情——前面稍微提过一点——就是我们一开始绝对没预料到自己会做任何模型开发。如前所述,当我们进入这个领域时,有些公司从一开始就专注于从零训练模型。而我们之前算过训练需要多少成本,很清楚那不是我们能做的事。而且这也感觉有点像是把注意力放错了地方,因为当时已经有很多出色的模型,为什么要花大量精力去重复别人已经做过的工作?尤其是在预训练方面——把一个什么都不懂的神经网络拿来,然后教它整个互联网。
所以我们一开始认为自己完全不会做这件事。对我们来说从一开始就很清楚的是,现有的模型有很多它们可以为我们做但还没做的事情,因为没有为它们构建合适的工具。然而事实上,我们做了大量的模型开发,在内部这是我们招聘方向上的一个重点,也组建了一支非常出色的团队。
这在产品质量方面对我们来说也是一个很大的胜利。到了现在,Cursor 中每一个令人惊艳的时刻都以某种方式涉及定制模型。所以这确实是反直觉的、令人惊讶的,而且是一个渐进的过程——最初有一个需要自研模型的使用场景,在那个场景下用任何最大的基础模型都真的不合适,那次尝试极其成功,然后我们转移到另一个使用场景,效果也很好,就从那里一步步推进。在做这种模型开发时,一个有帮助的原则是精心选择切入点,不要试图重新发明轮子,不要试图把精力放在那些最好的基础模型已经做得很好的地方,而是聚焦在它们的弱点上,思考如何补充它们。
Lenny Rachitsky: 我觉得这会让很多听到的人感到惊讶——你们居然有自己的模型。当人们谈论 Cursor 和这个领域的所有参与者时,他们往往会称其为 GPT 套壳——只是坐在 ChatGPT 或 Sonnet 之上。你现在的意思是你们有自己的模型,能聊聊背后的技术栈吗?
Michael Truell: 当然可以。我们确实在很多不同方面使用最大的基础模型,它们是给用户带来 Cursor 体验的重要组件。我们使用自研模型的场景,有时候是为了覆盖那些基础模型因成本或速度原因完全无法服务的使用场景。其中一个例子就是自动补全方面。对于不写代码的人来说这可能有点难以理解,但代码是一种很奇特的工作形式——有时候,你接下来 5 分钟、10 分钟、20 分钟、30 分钟要做的事情,完全可以通过站在你身后看一眼就预测出来。
我拿写作来对比一下。很多人熟悉 Gmail 的自动补全,以及在发短信、写邮件等场景中出现的各种自动补全。它们能提供的帮助很有限,因为通常情况下,光看你之前写了什么,确实很难判断你接下来要写什么。但在代码中就不一样了——有时候你编辑了代码库的某一部分,你就需要在代码库的其他部分做相应改动,而你需要怎么改是完全可以预见的。
自研模型与自动补全
所以 Cursor 的一个核心功能就是这种真正量身定制的自动补全体验——预测你接下来要做的编辑操作,跨越多个文件、文件内的多个位置。让模型在这个用例上表现出色,一方面是速度要求——这些模型必须非常快,需要在 300 毫秒内给出补全结果。另一方面是成本因素——我们每次按键都要运行大量、大量、大量的模型推理,不断调整对你下一步操作的预测。此外,这也是一个非常专门的用例——你需要的模型不是擅长补全下一个 token、一段普通文本序列,而是擅长自动补全一系列 diff——查看代码库中已发生的变化,然后生成接下来将要变化的内容,包括删除和新增等所有操作。我们专门针对这个任务训练模型,取得了巨大成功。
模型协作的输入输出管线
所以这是一个不涉及基础模型的领域,基本是我们自己的东西。我们在应用里对此没有太多标注或品牌宣传,但它是 Cursor 非常核心的一部分。另一个使用自研模型的场景是辅助 Sonnet、Gemini 或 GPT 等模型,它们位于这些大模型的输入端和输出端。在输入端,这些模型在整个代码库中进行搜索,试图找出代码库中应该展示给这些大模型的部分。你可以把它想象成一个专门构建的迷你 Google 搜索,用于找到代码库中与这些大模型相关的部分。
在输出端,我们拿到这些模型建议的变更草图——与你这个代码库相关的变更。然后我们有模型去填充细节——高层次思考由最聪明的模型完成,它们花少量 token 做这件事,然后这些更小、更专业、速度极快的模型,配合一些推理技巧,把这些高层次变更真正转化为完整的代码 diff。所以这对提升那些需要专门任务的场景的质量非常有帮助,对提升速度也非常有帮助——速度对我们来说也是产品质量极其重要的一个维度。
Lenny Rachitsky: 这太有意思了。我之前请了 Kevin Weil 上播客,他是 OpenAI 的 CPO(首席产品官),他称这种方式为模型组合(ensemble of models)——同样的思路——
Michael Truell: 是的。
Lenny Rachitsky: ——利用每个模型最擅长的部分,而且正如你所说,使用更便宜的模型还有成本优势。这些其他模型是基于 Llama 之类的开源模型吗?就是你们接入并在此基础上构建的开源模型?
Michael Truell: 是的。再强调一下,我们非常务实地选择做这件事的方式,不想重复造轮子。所以我们会从现有的最好的预训练模型开始,通常是开源模型,有时也会与那些不对外公开权重的大模型提供商合作。因为我们最不关心的就是逐行读取权重矩阵并从中得到某个输出的能力——我们关心的是训练这些模型的能力,对它们进行后训练(post-training)的能力。所以总体而言,是的,开源模型,有时也会与闭源提供商合作进行调优。
护城河与长期防御性
Lenny Rachitsky: 这就引出了很多 AI 创始人和投资者经常思考的一个话题——护城河(moats),以及 AI 领域的防御性。看起来自研模型是这个领域的一个护城河。考虑到正如你所说,不断有人涌入试图抢占你们的份额,你怎么看待这个领域的长期防御性?
Michael Truell: 我认为确实有办法建立惯性和传统意义上的护城河,但我认为总体而言,我们处于一个必须靠持续构建最好的产品来立足的行业,行业中的每个人都是如此。我真心认为天花板如此之高,以至于无论你建立了什么样的壁垒,都可能被超越。我认为这类似于一些跟正常的软件市场、过去正常的企业市场有点不同的市场。我想到的一个是 1999 年底,或者说 90 年代末到 2000 年代初的搜索引擎市场。我想到的另一个在很多方面类似这个市场的,其实是 70、80、90 年代个人电脑和众多计算机的发展。
是的,在每个这样的市场中,天花板都极高,有可能实现飞跃。你可以在很长一段时间内,把一个聪明人的每一小时、每一美元 R&D 投入都持续转化为价值,有用可做的东西不会枯竭。而且在搜索领域(不是个人电脑那个案例),增加分发量也有助于让产品变得更好,因为你可以根据用户数据和反馈来调优算法、调优学习过程。我认为所有这些动态也存在于我们的市场中。所以我认为,也许对我们这样的人来说令人沮丧的事实,但对世界来说令人惊叹的事实是——我认为存在很多可以超越的空间,还有更多有用的东西可以构建。我们距离 5 年、10 年后能竞争的水平还很远,保持这种势头是我们的责任。
Lenny Rachitsky: 所以我听到的是,这听起来更像是一种消费级的护城河——就是持续做最好的产品让人们愿意留下来——而不是通过制造锁定之类的方式,比如 Salesforce 那样——整个公司签了合同,你就必须用这个产品。
Michael Truell: 是的。我觉得重要的是要注意,如果你处于一个很快就用完了有用可做之事的领域,那这不是一个好的处境。但如果你处于这样一个领域——大量投资,以及越来越多优秀的人朝着正确方向努力,能持续给你带来价值——那你就能获得 R&D 的规模经济,深入沿着正确方向打磨技术,达到一个具有防御性的位置。但确实,这有消费级产品的倾向,我真心认为关键就是构建最好的产品。
市场格局:一家独大还是百花齐放
Lenny Rachitsky: 你认为未来这个领域会有一个赢家,还是一个多产品并存的格局?
Michael Truell: 我认为这个市场极其庞大。你之前问过 IDE 的事情。我觉得一些思考这个领域的人有一个误区——他们回顾了过去 10 年的 IDE 市场,然后说”谁在编辑器上赚到钱了?“这是一个极度碎片化的市场,每个人各有各的东西、各有各的配置,只有一家公司真正靠做优秀的编辑器赚到了钱,但那家公司规模也就那样。于是他们得出的结论是,未来也会是这个样子。但我认为人们忽略的是,在 2010 年代为程序员做编辑器,你能做的事情就那么多,而那家靠编辑器赚钱的公司做的是诸如让代码库导航更方便、做一些错误检查和类型检查、提供好的调试工具之类的事。
市场规模与赢家格局
Michael Truell: 这些东西都非常有用,但我认为能为程序员构建的东西——为许多不同领域的知识工作者能构建的东西——可以走得很远、很深。我们所有人面前的核心问题,是大量琐碎工作和知识工作的自动化,是真正把知识工作的方方面面都推向更高层次、更高效率。
所以说了这么多,我想表达的是,我认为我们所处的市场真的非常非常庞大。我认为它比人们过去为开发者构建工具时所意识到的要大得多。我认为会有很多不同的解决方案。我认为会有一家公司——是否能是我们还不确定——但我确实认为会有一家公司构建出通用工具,构建出几乎全世界所有的软件,这将是一门极其具有时代意义的大生意。但我也认为,在这个市场里你可以占据一些细分领域,为特定的市场群体或软件开发周期中非常特定的环节做些事情。但当通用编程从仅仅编写形式化编程语言转向某种层次高得多的东西时,这就是你购买和使用的那个应用。我认为在那个领域一般只会有一个赢家,而且会是一门非常大的生意。
微软与 Copilot 的处境
Lenny Rachitsky: 有意思。顺着这个思路,有趣的是,微软其实最初处在这个领域的中心,拥有出色的产品、出色的分发渠道,你也说过 Copilot 是让你跨过”哇,这里可能真的有大事”这个门槛的东西。但现在感觉他们并没有在赢,反而感觉他们在落后。你怎么看这件事?
Michael Truell: 我认为 Copilot 至今未能达到一些人对它的预期,有一些具体的历史原因,然后也有一些结构性原因。我认为结构性原因是——先说清楚,微软在 Copilot 这个案例上显然是我们工作的重要灵感来源,总体而言我认为他们做了很多了不起的事情,我们自己也在用很多微软的产品——但我认为这个市场对在位者并不太友好。一个对在位者友好的市场,可能是那种能做的事情就那么多、很快就变得同质化,你可以把它和其他产品打包销售,不同产品之间的投资回报率差距很小的市场。在那种情况下,也许没必要买创新方案,买那个和其他东西打包在一起的就行了。
另一个对在位者特别有利的市场结构,可能是一开始你的东西就都在一个地方,切换成本极其痛苦,无论好坏。但我觉得在我们的领域,你可以试用不同的工具,可以自己判断哪个产品更好。这对在位者不太友好,而对你认为会拥有最具创新性产品的一方更友好。至于具体的历史原因,据我了解,最初开发 Copilot 第一版的那个团队的人基本上都已经离开了,去了其他地方做其他事情。我认为在协调所有可能参与这类产品的不同部门和各方之间,也有一定困难。
新用户的 Cursor 使用建议
Lenny Rachitsky: 我想回到 Cursor 的话题。我喜欢问每个构建这类工具的人一个问题:如果你能坐在每个第一次使用 Cursor 的新用户旁边,在他们耳边低语几条建议,帮助他们更成功、最大化地用好 Cursor,你会给出哪一两条建议?
Michael Truell: 我认为现在——我们也希望在产品层面解决这个问题——用好 Cursor 的关键很大程度上在于对模型能力有一种品味,既要了解模型能处理多复杂的任务,也要了解你需要给模型多少说明;同时对模型的质量、它在哪里有缺陷、能做什么不能做什么有一种品味。目前我们在产品中并没有很好地教育用户了解这些,也没有给用户一些明确的操作边界和指引。
但要培养这种品味,我会给两条建议。第一条,如前所述,不要倾向于一次性告诉模型”这是我想要你做的全部”,然后看输出,接着要么失望要么整个接受一个大型任务。相反,我会把事情拆成小块,你可以花基本相同的时间来描述需求,只是拆得更碎。所以你描述一点,得到一点成果,再描述一点,再得到一点成果,而不是写一大段话告诉模型具体该做什么。我认为现在这样做多少有点是灾难的配方。
所以要倾向于把事情拆碎。同时——也许在副项目上做而不是在专业工作上做——我会鼓励人们,尤其是习惯了现有软件开发工作流的开发者,有意识地去摔摔跟头,在一个安全的环境中(比如副项目)去尝试发现这些模型的极限,大胆地把 AI 用到极致。因为我们经常遇到一些人,他们还没有真正给 AI 一个公平的机会,就低估了它的能力。所以总体上倾向于把事情拆小,但要发现你能在多大程度上放手,就在安全环境里刻意去试探极限,培养一种感觉——你可能会对模型在某些地方没有崩溃感到惊讶。
培养对模型能力的直觉
Lenny Rachitsky: 我本质上听到的是,建立一种对模型能做什么、能把一个想法推进多远的直觉,而不是仅仅一步步引导它。而且我猜每次有新模型发布时你都需要重建这种直觉——比如我不知道,4.0 出来的时候你得重新来一遍。这个理解大致对吗?
Michael Truell: 是的。过去几年里,这种变化没有人们最初接触一些大型模型时那么大。这也是我们希望能为用户解决得更好的问题,减轻他们的负担。但这些模型每一个都有略微不同的特性和不同的”个性”。
Lenny Rachitsky: 顺着这个思路,人们一直在争论 Cursor 这类工具到底是更能帮助初级工程师还是高级工程师?是让高级工程师变成十倍工程师,还是让初级工程师更接近高级工程师?你认为今天谁从 Cursor 中受益最多?
Michael Truell: 我觉得两方面都有。这两个群体都以重大方式从中受益。要说谁受益更多,排名有点难。我会说,他们各自陷入的”反模式”不同。初级工程师我们看到的倾向是一刀切地全面依赖,什么都交给 AI,而我们目前还不到那个阶段——在一个专业工具里、与几十上百人协作、在一个长期维护的代码库中,还不能完全端到端地做到这一点。而高级工程师……对很多人来说是这样,当然并非所有人,而且我们其实经常……这些工具被采纳的方式之一是,公司内部有开发者体验团队,这些团队通常由非常资深的人组成,因为他们的工作往往是为组织内其他工程师构建工具、提升效率。
我们也看到一些非常前沿的、在第一线全力尝试采用这项技术的人。但总体而言,我会说,作为一个群体,高级工程师平均来说低估了 AI 能为他们做什么,倾向于固守已有的工作流程。所以相对排名确实有点难说,我觉得他们各自陷入不同的反模式,但总体而言,双方都能从这些工具中获得巨大的收益。
Lenny Rachitsky: 这完全说得通。我喜欢这种两端光谱的描述——一端期望过高,一端期望不足。就像金发姑娘的寓言一样。
Michael Truell: 对。
Lenny Rachitsky: 好的。
Michael Truell: 也许那种资深但还没到 staff 级别的,正好在中间的人。
回望创业初期
Lenny Rachitsky: 有意思。好,还剩几个问题。有什么是你希望在开始这个角色之前就知道的事情?如果你能回到 Cursor 刚起步时的 Michael——其实也没过多久——给他一些建议,你会告诉他什么?
Michael Truell: 这个问题的难处在于,感觉太多来之不易的知识是隐性的,不太容易用语言传达。生活中有一个令人沮丧的事实是,在人类努力的某些领域,你确实需要摔个跟头才能学到正确的东西,要么你就得待在一个在该领域表现出色的典范人物身边。我们在招聘方面就深有体会。我觉得我们其实……我们在招聘方面试图做到极其耐心。
对我们来说非常重要的一点是——无论出于个人原因,还是我认为实际上出于公司战略考虑——拥有一群世界级的工程师和研究员来和我们一起打造 Cursor,是至关重要的。此外,还要找到合适的人——一种智力好奇心和实验精神的特定组合,因为我们需要构建太多新东西;同时还需要一种智识上的诚实,也许还有一种微观层面的悲观和直言不讳,因为噪音太多了……尤其是随着公司成长、业务壮大,保持清醒冷静的头脑也变得极其重要。
把对的人引入公司,这也许是除了打造产品之外,我们最最用心的事情。正因如此,我们实际上等了很久才扩充团队。很多人说招人太快,我觉得我们初期其实是招得太慢了。我认为这是可以改善的,我们本可以做得更好。
我们最终找到的、对我们非常有效的招聘方式——其实并不算新颖——就是去追求我们认为真正世界级的人才,有时候花好几年时间去招募他们。这个方法最终奏效了,但我们一开始其实并不擅长。所以我觉得有很多来之不易的经验教训:关于什么样的人是合适的画像,谁真正适合那个团队,优秀是什么样的,然后是如何与对方沟通这个机会,如何在对方完全没在找工作的情况下让他们兴奋起来。这里面有太多关于如何做好这件事的经验需要学习,而我们花了一些时间才掌握。
Lenny Rachitsky: 对于现在正在招人的团队,有哪些经验教训?你错过了什么或学到了什么?
Michael Truell: 首先,我觉得我们一开始可能过于偏重某个模板——寻找知名院校毕业、非常年轻、在那些知名院校环境中做过高含金量事情的人。而实际上,我们很幸运早期就找到了一些非常优秀、愿意和我们一起做这件事的人,他们其实是职业生涯更晚期的阶段。我觉得我们花了不少时间在一个可能不太对的画像上,其中一部分是资历问题,一部分也是兴趣和经验方面的问题。我们也招到了一些非常非常优秀且很年轻的人,但他们在某些情况下可能不太像是标准模板出来的。
另一个经验是,我们的面试流程在不断演进。现在,我们有一套量身定制的面试题,而且我们面试方式的核心之一是,我们让候选人来公司待两天,和我们一起做一个项目——一个工作测试项目。这个方式效果非常好,越来越多公司在采用这种方式。如何了解别人感兴趣什么,如何展现我们最好的一面,在对方完全没在找工作的时候让他们了解这个机会、展开那些对话——我们在这些方面确实随着时间的推移做得越来越好。
Lenny Rachitsky: 你有最喜欢的面试问题吗?
Michael Truell: 我觉得这个两天工作测试——我们本以为它过了几个人之后就无法扩展了——却出人意料地延续了下来。它的好处在于,它让一个人像真实项目一样端到端地完成。这不是我们会用的工作成果,是一组预先准备好的项目列表。但它让你能看到两天真实的产出,而且不需要耗费其他团队大量时间。你可以把原本半天或一天 onsite 面试的时间分散到两天里,给候选人充裕的时间去做他们的项目,这样反而有助于规模化。
它还能起到一种”你想不想和这个人待在一起”的测试效果,因为你确实要和这个人相处两天,一起吃好几顿饭。我们没想到这个方式会留下来,但它对我们的招聘流程变得极其重要,而且在公司非常早期的阶段,对激发候选人的热情也至关重要。因为在人们使用产品、了解产品之前,当产品还比较初级的时候,你唯一能打动人的就是一群让人觉得特别、想要共事的团队成员。这两天给了我们机会让候选人认识我们,在某些情况下,希望说服他们愿意和我们一起干。这个方式是意料之外的。不完全是面试问题,但有点像一种前置面试。
Lenny Rachitsky: 终极面试题。那为了说清楚你描述的内容,你给他们一个任务,比如”在我们的实际代码库里构建这个功能,和团队一起编码并发布”。大概是这样吗?
团队规模与构成
Michael Truell: 对。我们不会使用真正的 IP,不是完全端到端的正式工作,而是模拟的……但经常是在我们的真实代码库里,“这是一个真实的迷你两天项目。你要端到端地完成它。” 大部分时间让候选人自己动手,也有协作的部分。而且我们是一家比较”封闭”的公司,几乎所有情况下,候选人其实就是和我们坐在同一个办公室里。
Lenny Rachitsky: 你刚才说这个方式一直沿用到现在,那你们现在团队有多大了?
Michael Truell: 我们马上就到 60 人了。
Lenny Rachitsky: 对于你们的规模和影响力来说,这太小了。我原以为会比这大很多。
Michael Truell: 是的。
Lenny Rachitsky: 我猜其中大部分是工程师?
Michael Truell: 是的。需要说明的是,摆在我们面前的一项重要工作是建立一个更大、更优秀的团队,能够持续改进产品,提升我们为客户提供的服务。所以我们并不打算长期保持这么小的规模,也不希望如此。但这个数字之所以小,部分原因是公司内部工程师、研究人员和设计师的占比非常高。许多软件公司如果有大约 40 名工程师,总人数就会超过 100 人,因为有大量的运营工作,而且很多公司从一开始就是以销售为主导的,这非常耗费人力。而我们起步时极其精简,以产品为主导,现在服务于大量的市场客户,在这方面的体系也搭建起来了,但还有很多事情要做。
在 AI 热潮中保持专注
Lenny Rachitsky: 我想问你一个问题。AI 领域现在发生了太多事情,每隔……有各种 newsletter,很多 newsletter,它们唯一的功能就是每天告诉你 AI 领域发生了什么。你经营着一家处于这个行业中心——白热中心的公司,你怎么保持专注?你怎么帮助团队保持专注、埋头苦干、持续构建,而不被那些闪亮的东西分心?
Michael Truell: 我觉得招聘在其中起到了很大作用,如果你招到了态度正确的人。所有这些话都要加个星号——我认为我们在这方面做得不错,但我认为我们也可以做得更好,这也是公司内部应该更多讨论的话题。不过我认为,招聘具有正确倾向的人——那些不太关注外部认可、更专注于构建真正优秀的产品、更专注于做出高质量工作的人,以及那些总体上比较沉稳的人——也许情绪高点不会太高,低点也不会太低。我认为招聘可以帮你解决很多问题。我觉得这其实是整个公司的一个认知:对于任何……你需要流程,需要层级架构,需要很多东西,但对于你引入公司的任何一种组织工具,你想要通过它获得的结果——你其实可以通过招聘具备你期望的那种行为的人,在没有那种组织工具的情况下也走得很远。
一个具体的例子是,我们在工程方面至今没有太多流程也能运转。我觉得我们需要再增加一些流程,但就我们目前的规模来说,不需要太多。这靠的是招聘真正优秀的人。一是招沉稳的人。二是反复讨论这个问题。三是以身作则。对我们个人而言,我们从 2021、2022 年就开始专业地做这件事,一直从事 AI 相关工作,亲眼目睹了各种技术和理念的来来去去。如果你把自己带回到 2021 年末、2022 年初,那时候是 GPT-3 的时代,InstructGPT 还不存在,没有 DALL·E,没有 Stable Diffusion。然后我们经历了所有这些图像技术的出现,ChatGPT 的崛起,GPT-4,所有这些新模型,各种不同模态,所有视频相关的技术,但其中只有极少数真正影响了我们的业务。
所以我觉得我们已经建立了一定的”免疫系统”,知道当某个事件出现时,它是否真的会对我们产生重要影响。这种动态——大量的喧嚣,但真正重要的可能只有少数几件事——我觉得在 AI 领域过去十年中也有类似的映射。学术界发表了海量的深度学习论文、海量的 AI 论文,但奇妙的是,AI 的进步很大程度上可以归功于一些非常简单、优雅且经久不衰的想法,而绝大多数被提出的想法并没有持久的影响力,也没有产生太大影响。这种动态与深度学习作为一个领域的整体演进有几分相似。
人们对 AI 最大的误解
Lenny Rachitsky: 最后一个问题。你认为人们对 AI 的发展方向、对构建方式、对世界将如何改变,最大的误解或尚未完全理解的是什么?
Michael Truell: 人们仍然有点过于偏向光谱的两端——要么认为这一切都会非常快地发生,要么认为这一切全是吹嘘、炒作和骗局。我认为我们正处于一场将产生极其深远影响的技术变革之中。我认为它将比互联网更具影响力,比计算机问世以来我们见过的任何技术变革都更具影响力。我认为这需要时间,这将是一个持续数十年的过程,许多不同的群体都将在推动其前进中发挥重要作用。
要达到一个计算机能够越来越多、越来越多地为我们做事的世界,有各种独立的问题需要逐一攻克,需要在这些问题上取得进展。其中一些是科学层面的——让这些模型理解不同类型的数据、变得更快、更便宜、更智能、适应我们关心的模态、在现实世界中采取行动。还有一些是关于我们如何与它们协作,人类在计算机上应该看到和控制的体验是什么,如何与这些东西共事。
但我认为这需要几十年的时间。将会有大量了不起的工作要做。另外,我认为一种将特别重要的模式——不是在为自己说话——就是在一个特定的知识工作领域进行自动化和增强的公司,既构建底层技术,整合来自各供应商的最佳成果,有时也自主研发,同时又构建面向用户的产品体验。我认为做这件事的人……我们在软件领域尝试这样做,其他人在其他领域做这件事,这些人将产生极其、极其深远的影响。不仅在于用户最终看到的价值,而且我认为随着他们达到一定规模,他们对于推动技术进步也将非常重要,因为我认为他们中最大的赢家将能够建立非常非常庞大的业务。所以,我很期待看到其他领域出现类似的公司。
招聘信息
Lenny Rachitsky: 我知道你们在招人。对于那些感兴趣、想说”嘿,我想去那里工作,参与构建这类东西”的人,你们目前在招什么样的岗位?有没有什么你们特别想尽快招到的角色?好奇的人应该知道些什么?
Michael Truell: 这个团队需要做的事情太多了,很多我们目前还无法胜任。总体来说,首先,如果你觉得我们没有某个岗位,也许你应该主动联系我们——实际情况可能并非如此。也许我们反而能从你身上学到东西,然后发现我们需要一些之前没意识到的东西。但总的来说,我认为我们今年最重要的两件事是:做出这个领域最好的产品,然后让它增长。我们现在基本处于跑马圈地的阶段,全世界几乎所有人要么没有使用我们这类工具,要么使用的是一个发展速度可能较慢的工具。所以增长 Cursor 也是一个大目标。我会说,我们一直在寻找优秀的人才……优秀的工程师、设计师、研究人员,但商业各个方向的人我们也都在找。
Lenny Rachitsky: 既然你提到了工程师,我忍不住想问这个问题——大家都在说”AI 要替我们写所有代码了”,但每家公司仍在疯狂招工程师。所有的基础模型公司,都有大量空缺岗位。
Michael Truell: 没错。我们可不是那种到处鼓吹”大家都可以学会编程”的人。
Lenny Rachitsky: 你觉得工程岗位会不会出现一个拐点,开始放缓增长?我知道这是个很大的问题,但……你觉得这些公司对工程师的需求会越来越大,还是说终有一天满世界都是 Cursor 的 agent 在替我们写代码?
工程师的未来需求
Michael Truell: 我再说一遍,我们的观点是,中间会有一段漫长的过渡期——不会一跃跳到那种你只需要退后一步、把你所有需求说出来,工程部门就帮你搞定的状态。我们非常希望从编程的现状出发逐步演进,我们希望人类始终坐在驾驶位上。而且我们认为,即使在最终状态下,让人们掌控一切仍然非常重要,你需要专业人士来做这件事,来决定软件应该是什么样子。
所以我认为,是的,工程师绝对是需要的。工程师将能够做到比现在多得多的事情。我认为对软件的需求是非常持久的——这不算什么新鲜观点——但我觉得想想现在的情况就很离谱:构建一些相当简单、容易描述的东西——在外人看来应该很简单——却需要耗费巨大的成本和人力,而目前要做好这些事情实在太难了。
现在所有存在的东西,其成本和需求都由当前的水平所决定。如果你能把成本降低一个数量级,我认为我们会有大量的、大量的、更多的东西可以在电脑上做,会有多得多的工具。我有过这种亲身感受……我早期的工作之一实际上是在一家生物技术公司上班,为他们构建内部工具。市面上现成的工具糟糕透顶,完全不适合他们的使用场景。而我当时在构建的内部工具,那边的需求量确实巨大,远远超过了我任职期间能构建的范围。
在电脑上做事的物理条件太好了——你应该基本上能够随心所欲地移动一切、做你想做的一切。但仍然有太多的摩擦。我认为对软件的需求远远超过我们今天能构建的数量——现在做个简单的生产力软件成本堪比一部大片。所以我认为,在很长的未来里,对工程师的需求实际上会更大。
最后的话
Lenny Rachitsky: 还有什么我们没聊到的你想提的吗?有没有什么最后的金玉良言想留给听众的?你也可以说没有,因为我们已经聊了很多了。
Michael Truell: 我们花了很多心思思考如何组建一个团队,既能不断做出新东西,又能持续改进现有的东西。我认为如果我们成功了,IDE 必须发生巨大的变化,未来的样子也必须发生巨大的变化。如果你环顾四周,在我们尊敬的公司中,确实有一些公司能够持续驾驭一波又一波的跨越式创新,不断推动前沿。但这样的公司也很少见,这是一件很难做到的事。所以,一方面是持续思考这个问题,在我们的状态好的时候从第一性原理出发进行反思;另一方面也是深入研究过去那些伟大的先例——这也是我们非常重视的事情。
Lenny Rachitsky: 是的。是的。在开始录制之前,你身后摆了好多书,我就问”那边是什么?“是一本关于某个老牌计算机公司的历史书,在很多方面都很有影响力,但我之前从没听说过。我觉得这很能说明你的特点——很多创新的源泉就是研究过去、研究历史,看什么有效、什么无效。
好的。如果有人想联系你们、可能想应聘的话,在哪里能找到你们?你说过可能有些岗位他们甚至都不知道有,去哪里看,然后听众怎么能帮到你们?
Michael Truell: 好的。如果有人对做这些东西感兴趣,非常乐意聊聊。他们可以去 cursor.com,既能找到产品,也能找到联系我们的方式。
Lenny Rachitsky: 简单明了。Michael,非常感谢你能来。这次对话太棒了。
Michael Truell: 非常愉快。谢谢。
Lenny Rachitsky: 大家再见。
感谢大家的收听。如果你觉得这期节目有价值,可以在 Apple Podcasts、Spotify 或你喜欢的播客应用上订阅。也请考虑给我们打分或留下评论,这真的能帮助其他听众找到这个播客。你可以在 lennyspodcast.com 找到所有往期节目或了解更多关于这个节目的信息。下期再见。
术语表
| 原文 | 中文 |
|---|---|
| ARR (Annual Recurring Revenue) | 年经常性收入 |
| Chromium | Chromium(保持原文,开源浏览器引擎项目) |
| Code Pilot | Code Pilot(保持原文,可能指 GitHub Copilot 的早期版本) |
| Cursor | Cursor(保持原文,知名 AI 代码编辑器) |
| DALL·E | DALL·E(保持原文,OpenAI 的图像生成模型) |
| deep learning | 深度学习 |
| dogfooding | dogfooding(保持原文,指团队使用自己开发的产品) |
| end-to-end automation | 端到端自动化 |
| ensemble of models | 模型组合(ensemble of models) |
| Figma | Figma(保持原文,知名设计工具) |
| IDE (Integrated Development Environment) | IDE(集成开发环境,保持原文缩写) |
| InstructGPT | InstructGPT(保持原文,OpenAI 的指令微调模型) |
| issue tracker | issue tracker(保持原文,指问题追踪系统) |
| Kevin Weil | OpenAI CPO(首席产品官),播客嘉宾 |
| Lenny Rachitsky | 播客主持人、newsletter 作者 |
| Llama | Llama(Meta 的开源大语言模型) |
| Michael Truell | Anysphere 联合创始人兼 CEO,Cursor 背后公司 |
| moats | 护城河(moats) |
| next edit prediction | next edit prediction(Cursor 的一项功能,预测程序员下一步的编辑操作) |
| plug-in | 插件 |
| post-training | 后训练(post-training) |
| Salesforce | Salesforce(保持原文,知名企业软件公司) |
| scaling laws | 规模化定律 |
| Stable Diffusion | Stable Diffusion(保持原文,开源图像生成模型) |
| taste | 品味(指对”应该构建什么”的正确判断力) |
| vibe coding | vibe coding(保持原文,指一种依赖 AI 生成代码、不太关注底层细节的编程风格) |
此文档由 AI 分片翻译(translate_long_document)
The rise of Cursor: The $300M ARR AI tool that engineers can’t stop using | Michael Truell
Preview of the Episode
Michael Truell: … our goal with Cursor is to invent a new type of programming, a very different way to build software. So a world kind of after code, I think that more and more being an engineer will start to feel like being a logic designer, and really, it will be about specifying your intent for how exactly you want everything to work.
Introducing the Guest
Lenny Rachitsky: What is the most counter-intuitive thing you’ve learned so far about building Cursor?
Michael Truell: We definitely didn’t expect to be doing any of our own model development. And at this point, every magic moment in Cursor involves a custom model in some way.
The “Post-Code” Vision
Lenny Rachitsky: What’s something that you wish you knew before you got into this role?
A World After Code
Michael Truell: Many people you hear hire too fast, I think we actually hired too slow to begin with.
Skills of Growing Value
Lenny Rachitsky: You guys went from $0 to 100 million ARR in a year and a half, which is historic. Was there an inflection point where things just started to really take off?
Michael Truell: The growth has been fairly just consistent on an exponential. And exponential to begin with feels fairly slow when the numbers are really low, and it didn’t really show off to the races to begin with.
Connection to Vibe Coding
Lenny Rachitsky: What do you think is the secret to your success?
Michael Truell: I think it’s been…
The Cursor Origin Story
Lenny Rachitsky: Today, my guest is Michael Truell. Michael is co-founder and CEO of Anysphere, the company behind Cursor. If you’ve been living under a rock and haven’t heard of Cursor, it is the leading AI code editor, and is at the very forefront of changing how engineers and product teams build software. It’s also one of the fastest growing products of all time, hitting 100 million ARR just 20 months after launching, and then 300 million ARR just two years since launch.
Michael’s been working on AI for 10 years. He studied computer science and math at MIT, did AI research at MIT and Google, and is a student of tech and business history. As you’ll soon see, Michael thinks deeply about where things are heading, and what the future of building software looks like. We chat about the origin story of Cursor, his prediction of what happens after code, his biggest counter-intuitive lessons from building Cursor, where he sees things going for software engineers, and so much more.
Michael does not do many podcasts. The only other podcast he’s ever done is Lex Fridman, so it was a true honor to have Michael on. If you enjoy this podcast, don’t forget to subscribe and follow it in your favorite podcasting app or YouTube. Also, if you become an annual subscriber of my newsletter, you get a year free of Perplexity, Linear, Superhuman, Notion, and Granola. Check it out at lennysnewsletter.com, and click bundle. With that, I bring you Michael Truell.
Michael, thank you so much for being here. Welcome to the podcast.
From Mechanical Engineering to Coding
Michael Truell: Thank you. It’s great to be here. Thank you for having me.
Why Choose the IDE Path
Lenny Rachitsky: When we were chatting earlier, you had this really interesting phrase, this idea of what comes after code. Talk about that, just the vision you have of where you think things are going in terms of moving from code to maybe something else.
Michael Truell: Our goal with Cursor is to invent sort of a new type of programming, a very different way to build software, that’s kind of just distilled down into you describing the intent to the computer for what you want in the most concise way possible, and really distilled down to just defining how you think the software should work, and how you think it should look. With the technology that we have today, and as it matures, we think you can get to a place where you can invent a new method of building software that’s [inaudible 00:05:16] higher level, and more productive, in some cases, more accessible too.
And that process will be a gradual moving away from what building software looks like today. I want to contrast it with maybe the vision of what software looks like in the future that I think… A couple of visions that are in a popular consciousness that we at least have some disagreement with. One is, there’s a group of people who think that software building in the future is going to look very much like it does today, which mostly means text editing, formal programming languages, like TypeScript, and Go, and C, and Rust. And then there’s another group that kind of thinks you’re just going to type into a bot, and you’re going to ask it to build you something, and then you’re going to ask it to change something about what you’re building, and it’s kind of like this chatbot, Slackbot style where you’re talking to your engineering department.
And we think that there are problems with both of those visions. I think that on the chatbot style end of things… And we think it’s going to look weirder than both. The problem with the chatbot style end of things is that lacks a lot of precision. If you want humans to have complete control over what the software looks like, and how it works, you need to let them gesture at what they want to be changed in a form factor that’s more precise than just, “Change this about my app.” In a text box, removed from the whole thing. And then the version of the world where nothing changes we think is wrong, because we think the technology is going to get much, much, much better.
And so a world after code, I think that it looks like a world where you have a representation of the logic of your software that does look more like English, you have written down… You can imagine in [inaudible 00:07:08] form, you can imagine in kind of an evolution of programming language towards pseudocode. You have written down the logic of the software, and you can edit that at a high level, and you can point at that. And it won’t be the impenetrable millions of lines of code, it’ll instead be something that’s much Terser, and easier to understand, easier to navigate. But that world where the kind of crazy, hard to understand symbols start to evolve towards something that’s a little bit more human-readable, and human-editable, is one that we’re working towards.
Engineers as Managers in the AI Era
Lenny Rachitsky: This is a profound point. I want to make sure people don’t miss what you’re saying here, which is that what you’re envisioning in the next year essentially is kind of when things start to shift, is, people move away from even seeing code, having to think in code in JavaScript and Python, and there’s this abstraction that will appear, essentially pseudocode, describing what the code should be doing more in English sentences.
Building Cursor in the Early Days
Michael Truell: Yep. We think it ends up looking like that, and we’re very opinionated that that path goes through existing professional engineers, and it looks like this evolution away from code. And it definitely looks like the human still being in the driver’s seat, and the human having both a ton of control over all aspects of the software and not giving that up. And then also the human having the ability to make changes very quickly, having a fast duration loop and not just having something in the background that’s super slow and takes weeks, go do all your work for you.
Growing From 100M ARR
Lenny Rachitsky: This begs the question for people that are currently engineers, or thinking about becoming engineers, or designers, or product manager, what skills do you think will be more and more valuable in this world of what comes after code?
Product Focus and Trade-offs
Michael Truell: I think taste will be increasingly more valuable. And I think often when people think about tastes in the realm of software, they think about visuals, or taste over smooth animations, and coloring things, UI, UX, et cetera on the visual design of things. And the visual side of things is an important part of defining a piece of software, but then, as mentioned before, I think that the other half of defining a piece of software is the logic of it, and how the thing works.
And we have amazing tools for specing out the visuals of things, and then when you get into the logic of how a piece of software works, really, the best representation we have of that is code right now. You can kind of gesture at it with Figma, and you can gesture at it with writing down notes, but it’s when you have an actual working prototype. And so I think that more and more, being an engineer will start to feel like being a logic designer, and really, it will be about specifying your intent for how exactly you want everything to work. It’d be more about the whats, and a little bit less about how exactly you’re going to do things under the hood.
I think taste will be increasingly important. I think one aspect of software engineering, and we’re very far from this right now, and there are lots of funny memes going around the internet about some of the trials and tribulations people can run into if they trust AI for too many things that comes to engineering, around building apps that have glaring deficiencies, and problems, and functionality issues. But I think we will get to a place where you’ll be able to be less careful as a software engineer, which, right now, is an incredibly, incredibly important skill. We’ll move a little bit from carefulness, and a little bit more towards taste.
Counterintuitive: Building Custom Models
Lenny Rachitsky: This makes me think of vibe coding, is that kind of what you’re describing when you talk about not having to think about the details as much, and just kind of going with the flow?
Michael Truell: I think it’s related. I think that vibe coding right now describes exactly this state of creation that is pretty controversial, where you’re generating a lot of coding, you aren’t really understanding the details. That is a state of creation that then has lots of problems, you don’t really… By not understanding the details under the hood right now, you then very quickly get to a place where you’re kind of limited at a certain point, where you create something that’s big enough that you can’t change. And so I think some of the ideas that we’re interested around, how do you give people continued control over all the details when they don’t really understand the code? I think that solutions there are very relevant to the people who are vibe coding right now. I think that right now, we lack the ability to let the tastemakers actually have complete control over the software. One of the issues also with vibe coding, and letting taste really shine through from people is, you can create stuff, but a lot of it the AI making decisions that are unwieldy and you don’t have to control over.
Model Collaboration Input/Output Pipeline
Lenny Rachitsky: One more question along these lines. You threw out this word taste. When you say taste, what are you thinking?
Michael Truell: I’m thinking having the right idea for what should be built. It will become more and more about effortless translation of, here’s exactly what you want built, here’s how you want everything to work, here’s how you want it to look. And then you’ll be able to make that on a computer, and it will less be about this kind of translation layer of, you and your team have a picture of what you’d want to build, and then you have to really painstakingly, labor-intensive, lay out that into a format that a computer can then execute and interpret. I think less than the UI side of things, maybe taste is a little bit of a misnomer, but just about having the right idea for what should be built.
Moats and Long-Term Defensibility
Lenny Rachitsky: Awesome. Okay. I’m going to come back to these topics, but I want to actually zoom us back out to the beginnings of Cursor. I have never heard the origin story, I don’t think many people know how this whole thing started. Basically you guys are building one of the fastest growing products in the history of the world, it’s changing the way people build products, it’s changing careers, professions, it’s changing so much. How did it all begin? Any memorable moments along the journey of the early days?
Michael Truell: Cursor kind of started as a solution search of a problem, and a little bit where it very much came from reflecting on how AI was going to get better over the course of the next 10 years. There were kind of two defining moments, one was being really excited by using the first beta version of Code Pilot, actually. This was the first time we had used an AI product that was really, really, really useful, and was actually just useful at all, and wasn’t just a vaporware kind of demo thing.
And in addition to being the first AI product that we’d use that was useful, Code Pilot was also one of the most useful, if not the most useful dev tool we’d ever adopted, and that got us really excited. Another moment that got us really excited was the series of scaling on papers coming out of OpenAI and other places that showed that even if we had no new ideas, AI was going to get better and better just by pulling on simple levers, like scaling up the models, and also scaling up the data that was going into the models.
And so at the end of 2021, beginning of 2022, this got us excited about how AI products were now possible, this technology was going to mature into the future. And it felt like when we looked around, there were lots of people talking about making models, and it felt like people weren’t really picking an area of knowledge work and thinking about what it was going to look like as AI got better and better. And that set us on the path to an idea generation exercise, it was like, “How are these areas of knowledge work going to change in the future as this tech gets more mature? What is the end state of the work going to look like? How are the tools that we use to do that work going to change? How are the models going to need to get better to support changes in the work? And once scaling and pre-training ran out, how are you going to keep pushing for technological capabilities?”
And the misstep at the beginning of Cursor is we actually worked on… We sort of did this whole grand exercise, and we decided to work on an area of knowledge work that we thought would be relatively uncompetitive, and sleepy, and boring, and no one would be looking at it, because we thought, “Oh, coding’s great, coding’s totally going to change with this AI, but people are already doing that.” So there was a period of four months to begin with, where we were actually working on a very different idea, which was helping to automate and augment mechanical engineering, and building tools for mechanical engineers.
There were problems from the get-go in that. Me and my co-founders, we weren’t mechanical engineers. We had friends who were mechanical engineers, but we were very much unfamiliar with the field. So there was a little bit of a blind man and the elephant problem from the get-go. There were problems around, how would you actually take the models that exist to today and make them useful for mechanical engineering? The way we netted out is, you need to actually develop your own models from the get-go. And the way we did that was tricky, and there’s not a lot of data on the internet of 3D models of different tools and parts, and the steps that I expect to build up to those 3D models, and then getting them from the sources that have them is also a tricky process too.
But eventually what happened was, we came to our senses, we realized we’re not super excited about mechanical engineering, it’s not the thing we want to dedicate our lives to. And we looked around, and in the area of programming, it felt like despite a decent amount of time ensuing, not much has changed, and it felt like the people that were working on the space maybe had a disconnect with us, and it felt like they weren’t being sufficiently ambitious about where everything was going to go in the future, and how all of software creation was going to blow through these models. And that’s what set us off on the path to building Cursor.
Market Landscape: One Winner or Many
Lenny Rachitsky: Okay. So interesting. Okay, so first of all, I love that… This is advice that you often hear of go after a boring industry because no one’s going to be there, and there’s opportunity. And sometimes it works, but I love that in this journey, it’s like, “No, actually, go after the hottest, most popular space, AI coding, app building.” And it worked out. And the way you phrased it just now is, you didn’t see enough ambition potentially, that you thought there was more to be done. So it feels like that’s an interesting lesson. Even if something looks like, “Okay, it’s too late, there’s GitHub, Code Pilot’s out there.” Some other products. If you notice that they’re just not as ambitious as they could be, or as you are, or you see almost a flaw in their approach, that there’s still a big opportunity. Does that resonate?
Market Size and Winning Dynamics
Michael Truell: That totally resonates. A part of it is, you need there to be leapfrogs that can happen, you need there to be things that you can do. And I think the exciting thing about AI is, in a bunch of places, and I think this is very much still true of our space, and can talk about how we think about that and how we deal with that, but I think that just the ceiling is really high. And yes, if you look around, probably even if you take the best tool, any of these fields, there should be a lot more that needs to be done over the next few years. Having that space, having that high ceiling, I think is unique amongst areas of software, at least the degree to which it is high with AI.
Microsoft and Copilot’s Position
Lenny Rachitsky: Let’s come back to the IDE questions. So there’s a few routes you could have taken, and other companies are doing different routes. So there’s building an IDE for engineers to work within and adding AI magic to it, there’s another route of just a full AI agentic dev product, and then there’s just a model that is very good at coding, and focusing on building the best possible coding model. What made you decide and see that the IDE path was the best route?
Michael Truell: The folks who were from the get-go working on just a model were working on end-to-end automation programming. I think they were trying to build something very different from us, which is, we care about giving humans control over all of the decisions in the end tool that they’re building. And I think those folks were very much thinking of a future where end-to-end, the whole thing is done by AI, and maybe the AI is making all the decisions too. And so, one, there was a personal interest component. Two, I think that always, we’ve tried to be intense realists about where the technology is today, very, very, very excited about how AI is going to mature over the course of many decades. But I think that sometimes people… There’s an instinct to see AI do magical things in one area, and then kind of anthropomorphize these models, and think it’s better than a smart person here, and so it must be better than a smart person there.
But these things have massive issues, and we… From the very start, our product development process was really about dogfooding, and using the tool intensely every day. And we never wanted to ship anything that wasn’t useful to us, and we had the benefit of doing that because we were the end users part of our product. And I think that that instills a realism in you around where the tech is right now, and so that definitely made us think that we need the humans to be in the driver’s seat, the AI cannot do everything. We’re also interested in giving humans that control too for personal reasons, and so that gets you away from just your model company that also gets you away from just this end-end stuff without the human having control.
And then the way you get to an IDE versus maybe a plug-in to an existing coding environment is the belief that programming is going to flow through these models, and the active programming is going to change a lot over the course of the next few years. And that the extensibility that existing coding environments have is so, so, so limited, so if you think that the UIs may change a lot, if you think that the form factor programming is going to change a lot, necessarily need to have control over the entire application.
Advice for New Cursor Users
Lenny Rachitsky: I know that you guys today have an IDE, and that’s probably the bias you have of this is maybe where the future is heading, but I’m just curious, do you think a big part of the future is also going to be AI engineers that are just sitting in Slack and just doing things for you? Is that something that fits into Cursor one day?
Michael Truell: I think you’ll want the ability to move between all of these things fairly effortlessly, and sometimes I think you will want to have the thing kind of go spin off on its own for a while, and then I think you’ll want the ability to pull in the AI’s work, and then work with it very, very, very quickly, and then maybe have it go spin off again. And so these kind of background versus foreground form factors, I think you want that all to work well in one place. And I think the background stuff, there’s a segment of programming that it’s especially useful for, which is type of programming tasks where it’s very easy to specify exactly what you want without much description, and exactly what correctness looks like without much description.
Bug fixes are a great example of that, but it’s definitely not all of programming. So I think that what the IDE is will totally change over time, and our approach to having our own editor was premised on, it’s going to have to evolve over time. And I think that that will both include, you can spin off things from different surface areas like Slack, or your issue tracker, or whatever it is, and I think that will also include the pane of glass that you’re staring at is going to change a lot. We just mostly think of an IDE as the place where you are building software.
Developing Intuition for AI Models
Lenny Rachitsky: I think something people don’t talk enough about with talking about agents and all these AI engineers that are going to be doing all this stuff for you, is basically we’re all becoming engineering managers, with a lot of reports that are just not that smart, and you have to do a lot of reviewing, and approving, and specifying. I guess thoughts on that, and is there anything you could do to make that easier? Because that sounds really hard. Anyone that has had a large team, being like, “Oh my god, all these junior people just checking in with me doing not high quality work over and over.” It’s just like, “What a life. It’s going to suck.”
Michael Truell: Yeah. Maybe you [inaudible 00:23:12] one-on-ones with [inaudible 00:23:15].
Reflecting on the Early Days
Lenny Rachitsky: So many one-on-ones.
Team Size and Composition
Michael Truell: Yeah. So the customers we’ve seen have most success with AI I think are still fairly conservative about some of the ways in which they use this stuff. And so I do think today, the most successful customers really lean on things like our next edit prediction, where your coding is normal, and making the next into actions you’re going to do. And then they also really lean on scoping down the stuff that you’re going to hand off to the bot, and for a fixed percent of your time spent reviewing code, from an agent, or from an AI overall, you could… There’s two patterns. One is, you could spend a bunch of time specifying things up front, the AI goes and works, and then you then go and review the AI’s work, and then you’re done. That’s the whole task.
Or you can really chop things up. So you can specify a little bit, AI writes something, review, specify a little bit, AI writes something, review. Autocompletes all in the way of that spectrum. And still we see often the most successful people using these tools are chopping things up right now, and keeping things fairly [inaudible 00:24:28].
Staying Focused Amid AI Hype
Lenny Rachitsky: That sounds less terrible. I’m glad there’s a solution here. I want to go back to you guys building Cursor for the first time. What was the point where you realized this is ready? What was a moment of, “Okay, I think this is time to put it out there, and see what happens”?
Michael Truell: So when we started building Cursor, we were fairly paranoid about spinning for a while, without releasing to the world. And so to begin with too, we actually… The first version of Cursor was hand-rolled. Now we use VS Code as a base, like many browsers use Chromium as a base, and hit foot off of that. To begin with, we didn’t, and built the prototype of Cursor from scratch, and that involved a lot of work. We had to build our own… There were a lot of things that go into a modern code editor, including support for many different languages, and navigation support for moving amongst the language, error tracking support for things. There’s things like an integrated command line, the ability to use remote servers, the ability to connect to remote servers to view and run code. And so we kind of just went on this blitz of building things incredibly quickly, building our own editor from scratch, and then also the AI components.
It was after maybe five weeks that we were living on the editor full-time, and had thrown away our previous editor, and we’re using a new one. And then once it got to a point where we found it a bit useful, then we put it in other people’s hands, and had this very short beta period. And then we launched it out to the world within a couple of months from the first line of code, I think it was probably three months. And it was definitely a, “Let’s just get this out to people and build in public quickly.” The thing that took us by surprise is we thought we would be building for a couple hundred people for a long time. And from the get-go, there was an immediate rush of interest, and a lot of feedback too. That was super helpful, we learned from that. That’s actually why we switched to being based off of VS Code instead of just this hand-rolled thing. A lot of that was motivated by the initial user feedback, and then had been iterating in public from there.
The Biggest Misconception About AI
Lenny Rachitsky: I like how you understated the traction that you got. I think you guys went from $0 to 100 million ARR in a year, year and a half or something like that, which is historic. What do you think was the key to success of something like this? You just talked about dogfooding being a big part of it. You built it in three months, that’s insane. What do you think is the secret to your success?
Michael Truell: The three-month version wasn’t very good, and so I think it’s been a sustained paranoia about, there are all of these ways in which this thing could get better. The end goal is really to invent a very new form of programming that involves automating a lot of coding, as we know today. And no matter where we are with Cursor, it feels like we’re very, very far away from that end goal, there’s always a lot to do. A lot of it hasn’t been over rotated on that initial push, but instead is the continued evolution of the tool, and just making the tool consistently better.
Cursor Job Openings
Lenny Rachitsky: Was there an inflection point after those three months where things just started to really take off?
Future Demand for Engineers
Michael Truell: To be honest, it felt fairly slow to begin with, and maybe it comes from some impatience on our part. I think there’s the overall speed of the growth which continues to take us by surprise. I think one of the things that has been most surprising too is that the growth has been fairly just consistent on an exponential, of just consistent month-over-month growth, accelerated at times by launches on our part and other things. But an exponential to begin with feels fairly slow and the numbers are really low, and so it didn’t really feel off to the races to begin with.
Some Final Thoughts
Lenny Rachitsky: To me this sounds like build it and they will come actually working. You guys just built an awesome product that you loved yourselves as engineers, you put it out, people just loved it, told everyone about it.
Michael Truell: It being essentially all just us, the team working on the product, and making the product good in lieu of other things one could spend one’s time on. We definitely spent time on tons of other things, for instance, building the team was incredibly important, and doing things like support rotations are very important. But some of the normal things that people would maybe reach for in building the company early on, we really let those fires burn for a long time, especially when it came to things like sales and marketing.
And so just working on the product, and building a product that you like first, your team likes, and then also then adjusting it for some set of users, that can kind of sound simple, but then, as you know, it’s hard to do that well. And there are a bunch of different directions one could have run in, a bunch of different product directions.
I think focus, and strategically picking the right things to build, and prioritizing effectively is tricky. I think another thing that’s tricky about this domain is, it’s kind of a new form of product building, where it’s very interdisciplinary in that we are something in between a normal software company and then a foundation model company, in that we’re developing a product for millions of people, and that side of things has to be excellent, but then also one important dimension of product quality is doing more and more on the science, and doing more and more on the model side of things in places where it makes sense. And so that element of things doing that well too has been tricky. The overall thing would note is maybe some of these things sound simple to specify, but doing them well is hard, and they’re a lot of different way you can run in.
Lenny Rachitsky: I’m excited to have Andrew Luo joining us today. Andrew is CEO of OneSchema, one of our podcast sponsors. Welcome, Andrew.
Speaker 3 (00:30:38): Thanks for having me, Lenny. Great to be here.
So what is new with OneSchema? I know that you work with some of my favorite companies, like Ramp, and [inaudible 00:30:46], and Watershed. I heard you guys launched a new data intake product that automates the hours of manual work that teams spent importing, and mapping, and integrating CSV in Excel files?
Speaker 3 (00:30:55): Yes. So we just launched the 2.0 of OneSchema FileFeeds. We’ve rebuilt it from the ground up with AI. We saw so many customers coming to us with teams of data engineers that struggled with the manual work required to clean messy spreadsheets. FileFeeds 2.0 allows non-technical teams to automate the process of transforming CSV and Excel files with just a simple prompt. We support all of the trickiest file integrations, SFTP, S3, and even email.
I can tell you that if my team had to build integrations like this, how nice would it be to take this off our roadmap and instead use something like OneSchema.
Speaker 3 (00:31:30): Absolutely, Lenny. We’ve heard so many horror stories of outages from even just a single bad record, in transactions, employee files, purchase orders, you name it. Debugging these issues is often like finding a needle in a haystack. OneSchema stops any bad data from entering your system, and automatically validates your files, generating error reports with the exact issues in all bad files.
I know that importing incorrect data can cause all kinds of pain for your customers and quickly lose their trust. Andrew, thank you so much for joining me. If you want to learn more, head on over to oneschema.co., that’s oneschema.co.
What is the most counterintuitive thing you’ve learned so far about building Cursor, building AI products?
Michael Truell: I think one thing that’s been counterintuitive for us, [inaudible 00:32:14] added a little bit before, but is, we definitely didn’t expect to be doing any of our own model development when we started. As mentioned, when we got into this, there were companies that were immediately from the get-go going and just focusing on training model from scratch. And we had done the calculation for what it to train before, and just knew that that was not [inaudible 00:32:36] going to be able to do. And also felt a bit like focusing one’s attention in the wrong area, because there were lots of amazing models out there, and why develop all this work to replicate what other players had done. Especially on the pre-training side of things, taking a neural network that knows nothing, and then teaching it the whole internet.
And so we thought we weren’t going to be doing that at all, and it seems clear to us from the start that the existing models, there were lots of things that they could be doing for us that they weren’t doing, because there wasn’t the right tool built for them. In fact though, we do a ton of model development, and internally, it’s a big focus for us on the hiring front, and have assembled a fantastic team there.
And it’s also been a big win on the product quality side of things for us. And at this point, every magic moment in Cursor involves a custom model in some way. So that was definitely counterintuitive, and surprising, and it’s been a gradual thing, where there was an initial use case for training our own model, where it really didn’t make sense to use any of the biggest foundation models. That was incredibly successful, moved to another use case that worked really well, and had been going from there. And one of the helpful things in doing this sort of model development is picking your spots carefully, not trying to reinvent the wheel, not trying to focus on places, and maybe where the best foundation models are excellent, but instead kind of focusing on their weaknesses, and how you can complement them.
Lenny Rachitsky: I think this is going to be surprising to a lot of people hearing that you have your own models. When people talk about Cursor and all the folks in the space, they would kind of call them GPT wrappers, they’re just sitting on top of ChatGPT or Sonnet. What you’re saying is that you have your own models, talk about just the stack behind the scenes.
Michael Truell: Yeah, of course. So we definitely use the biggest foundation models a bunch of different ways, they’re really important components of bringing the Cursor experience to people. The places where we use our own models, so sometimes it’s to survey a use case that a foundation model wouldn’t be able to serve at all for cost or speed reasons. And so one example of that is the autocomplete side of things. And so this can be a little bit tricky for people who don’t code to understand, but code is this weird form of work, where sometimes, really, the next 5, 10, 20, 30 minutes of your work is entirely predictable from looking over your shoulder.
And I would contrast this with writing. So writing, lots of people are familiar with Gmail’s autocomplete, and the different forms of autocomplete that show up when you’re trying to post text messages, or emails, or things like that. They can only be so helpful, because often, it’s just really not clear what you’re going to be writing just by looking at what you’ve written before. But in code sometimes, when you edit a part of a code base, you’re going to need to change things, and in other parts of code base, and it’s entirely clear how you’re going to need to change things.
So one core part of Cursor is this really suit to autocomplete experience, where you predict the next set of that you’re going to be doing across multiple files, across multiple places within a file. And making models good at that use case, one, there’s a speed component of, those models need to be really fast, they need to give you a completion within 300 milliseconds. There’s also this cost component of, we’re running tons, and tons, and tons of molecules, every keystroke, we need to be changing our prediction for what you’re going to do next. And then it’s also this really specialty use case of, you need models that are really good, not at completing the next token, just a generic tech sequence, but are really good at autocompleting a series of diffs, looking at what’s changed within a code base, and then creating the next set of things that are going to change, both deleted and added and all of that, and we found a ton of success in training models specifically for that task.
So that’s a place where no foundation models are involved, it’s kind of our own thing. We don’t have a lot of labeling or branding about this in the app, power is a very core part of Cursor. And then another set of places where a user own models are to help things like Sonnet, or Gemini, or GPT, and those sit both on the inputs of those big models, and on the output. On the input side of things, those models are searching throughout a code base, try to figure out the parts of a code base to show to one of these big models. You can kind of think about this as a mini Google search that’s specifically built for finding the relevant parts of the code base to show one of these big models.
And then on the output side of things, we take the sketches of the changes that these models are suggesting, you make with that code base. And then we have models that then fill in the details of, the high level thinking is done by the smartest models, they spend a few tokens on doing that, and then these smaller specialty incredibly fast models, coupled with some inference tricks, then take those high level changes and turn them actually into full code diffs. And so it’s been super helpful for pushing on quality in places where you need a specialty task, and it’s been super helpful for pushing on speed, which is such an important dimension of product quality for us too.
Lenny Rachitsky: This is so interesting. I just had Kevin Weil on the podcast, CPO of OpenAI, and he calls this the ensemble of models, that’s the same way-
Michael Truell: Yes.
Lenny Rachitsky: … they work, to use the best feature of each one, and to your point, the cost advantages of using cheaper models. These other models, are they based on Llama and things like that, just open source models that you guys plug into and build on?
Michael Truell: Yeah. So again, we try to be very pragmatic about the place that we’re going to do this work, and we don’t want to reinvent the wheel. And so starting from the very best pre-trained models that exist out there, often open source ones, sometimes in collaboration with these big model providers that don’t share their weights out into the world, because the thing we care about last is the ability to read line by line, the matrix of weights that then go to give you a certain output. We just care about the ability to train these things, to post-train them. And so by and large, yes, open source models, sometimes working with the closed source providers too to tune things.
Lenny Rachitsky: This leads to a discussion that a lot of AI founders always think about and investors, which is moats, and defensibility in AI. So it feels like one is custom models, is a moat in the space. How do you just think about long-term defensibility in the space, knowing there’s other folks, as you said, launching constantly trying to eat your lunch?
Michael Truell: I think that there are ways to build in inertia and traditional moats, but I think by and large, we’re in a space where it is incumbent on us to continue to try to build the best thing, and everyone in this industry. And I truly just think that the ceiling is so high that no matter what entrenchment you build, you can be leapfrogged. And I think that this resembles markets that are maybe a little bit different from normal software markets, normal enterprise markets of the past. I think one that comes to mind is the market for search engines at the end of 1999, or at the end of the ’90s and beginning of the 2000s. I think another market that comes to mind that resembles this market in many ways, it’s actually just the development of the peripheral computer and many computers in the ’70s, ’80s, ’90s.
And I think that, yes, in each of those markets, the ceiling was incredibly high, it was possible to swish. You could keep getting value for the incremental hour of a smart person’s time, the incremental R&D dollar for a really long time, you wouldn’t run out of useful things to build. And then in search in particular, not on the computer case, adding distribution was helpful for making the product better too, in that you could tune the algorithms, you could tune the learning based off of the data and the feedback you’re getting from users. And I think that all of those dynamics exist in our market too. And so I think maybe the sad truth for people like us, but then the amazing truth for the world is, I think that there are many leapfrogs that exist, there’s more useful things to build. We’re a long way away from where we can compete in 5, 10 years, and it’s incumbent in our state to keep that going.
Lenny Rachitsky: So what I’m hearing, this sounds like a lot more like a consumer sort of moat, where it’s just, be the best thing consistently so that people stick with you versus creating lock-in and things like that, where they’re just… Like Salesforce, where it’s just contracts with the entire company, and you have to use this product.
Michael Truell: Yeah. I think the important thing to note is, if you’re in a space where you run out of useful things to do very quickly, then that’s not a great situation to be in. But if you’re in a place where big investments, and having more and more great people working on the right path can keep giving you value, then you can get these economies of scale of R&D, and you can deeply work on the technology in the right direction, and get to a place where that is defensible. But yes, it is… I think there’s a consumer-like tendency to it, and I really think it’s just about building the best thing possible.
Lenny Rachitsky: Do you think in the future there’s one winner in this space, or do you think it’s going to be a world of a number of products like this?
Michael Truell: I think the market is just so very big. You asked about the IDE thing early on, and one thing that I think a trip of some people that were thinking about the space is, they looked at the IDE market of the past 10 years, and they said, “Who’s making money off of the editors?” It’s this super fragmented space where everyone kind of has their own thing, with their own figuration, and there’s one company that actually makes money off making great editors, but that company is only so big. And then the conclusion was, it was going to look like that in the future. And I think that the thing that people missed was that there was only so much you could do building an editor in the 2010s for coders, and the company that made money off of editors was doing things like making it easy to navigate around a code base, and doing some error checking and type checking for things, and having good debugging tools.
Which were all very useful, but I think that the set of things you can build for programmers, I think the set of things you can build for knowledge workers in many different areas just goes very far and very deep. The problem in front of all of us is the automation of a lot of busy work and knowledge work, and really changing all the areas of knowledge work in front of us to be much higher level and more productive.
So that was a long-winded way to say, I think the market’s really, really big that we’re in. I think it’s much bigger than people have realized than the other building tools for developers in the past. And I think that there will be a bunch of different solutions. I think that there will be one company, to be determined if it’s going to be us, but I do think that there will be one company that builds the general tool that builds almost all the world’s software, and that will be a very, very generationally big business. But I think that there will be kind of niches you can occupy in doing something for a particular segment of the market, or for a very particular part of the software development life cycle. But the general programming shifts from just writing formal programming languages to something way higher level. This is the application you purchase and use to do that. I think that there will be generally one winner there, and it will be a very big business.
Lenny Rachitsky: Juicy. Along those lines, it’s interesting that Microsoft was actually at the center of this first, with an amazing product, amazing distribution, Copilot you said was the thing that got you over the hump of, “Wow, there could be something really big here.” And it doesn’t feel like they’re winning, it feels like they’re falling behind. What do you think happened there?
Michael Truell: I think that there are specific historical reasons why Copilot might not have lived up… So far have lived up to the expectations that some people have for it, and then I think that there are structural reasons. I think the structural reason is… And to be clear, Microsoft, in the Copilot case, obviously a big inspiration for our work, and in general, I think they do lots of awesome things, and we’re users of many Microsoft products, but I think that this is a market that’s not super friendly to incumbents, in that a market that’s friendly to incumbents might be one where there’s only so much to do, it kind of gets commoditized fairly quickly, and you can bundle that in with other products, and where the ROI between different products is quite small. And in that case, perhaps it doesn’t make sense to buy the innovative solution, it makes sense to just kind of buy the thing that’s bundled in with other stuff.
Another market that might be particularly helpful for incumbents is one where there’s… From the get-go, you have your stuff in one place, and it’s really, really excruciatingly hard to switch, and for better or for worse. I think in our case, you can try out different tools, and you can decide which product you think is better. And so that’s not super friendly to incumbents, and that’s more friendly to whoever you think is going to have the most innovative product. And then the specific historical reasons, as I understand them are the group of people that worked on the first version of Copilot have, by and large, gone on to do other things at other places. I think it’s been a little hard to coordinate among all the different departments and parties that might be involved in making something like this.
Lenny Rachitsky: I want to come back to Cursor. A question I like to ask everyone that’s building a tool like this, if you could sit next to every new user that uses Cursor for the first time, just whisper a couple tips in their ear to be more successful, most successful with Cursor, what would be 1 or 2 tips?
Michael Truell: I think right now, and we’d want to fix this at a product level, a lot of being successful with Cursor is kind of having a taste for what the models can do, both what complexity of a task they can handle, and how much you need to specify things to that model, but having a taste for the quality of the model, and where its gaps exist, and what it can do and what it can’t. And right now, we don’t do a good job in the product of educating people around that, and maybe giving people some swim lanes, giving people some guidelines.
But to develop that taste, would give two tips. So one is, as mentioned before, would bias less toward, trying in one go to tell the model, “Hey, here’s exactly what I want you to do.” Then seeing the output, and then either being disappointed or accepting the entire thing for an entire big task. Instead what I would do is I would chop things up into bits, and you can spend basically the same amount of time specifying things overall, but chopped up more. So you’re specifying a little bit, you’re getting a little bit of work, you’re specifying a little bit, getting a little bit of work, and not doing as much the, “Let’s write a giant thing telling the model exactly what to do.” I think that will be a little bit of a recipe for disaster right now.
And so biasing toward chopping things up. At the same time, and it might make sense to do this on a side project and not on your professional work, I would encourage people to, especially developers who are used to existing workflows for building software, I would encourage people to explicitly try to fall on their face, and try to discover the limits of what these models can do by being ambitious in a safe environment, like perhaps a side project, and trying to kind of go around town, use AI to the fullest. Because a lot of the time, we run into people who haven’t given the AI yet a fair shake, and are underestimating its abilities. So generally biasing towards chopping things up and making things smaller, but to discover the limits of what you can do there, explicitly just try to go for broke in a safe environment, and get a taste for… You might be surprised in some of the places where the model doesn’t break.
Lenny Rachitsky: What I’m essentially hearing is build a gut feeling of what the model can do, and how far it can take an idea versus just kind of guiding it along. And I bet that you need to rebuild this gut every time there’s a new model launch, when it’s on… I don’t know, 4.0 comes out, you have to do this again. Is that generally right?
Michael Truell: Yes. For the past few years, it hasn’t been as big as I think the first experience people have had with some of these big models. This is also a problem we would hope to solve much better just for users, and take the burden off of them. But each of these things have slightly different quirks and different personalities.
Lenny Rachitsky: Along these lines, something that people are always debating tools like Cursor, are they more helpful to junior engineers, or are they more helpful to senior engineers? Do they make senior engineers 10X better? Do they make junior engineers more like senior engineers? Who do you think benefits most today from Cursor?
Michael Truell: I think across the board. Both of these cohorts benefit in big ways. It’s a little hard to say on the relative ranking. I will say, they fall into different anti-patterns. The junior engineers we see going a little too wholesale, relying on AI for everything, and we’re not yet in a place where you can kind of do that end-to-end on a professional tool, working with tens, hundreds of other people within a long-lived code base. And then the senior engineers… For many folks, it’s not true for all, and we actually often… One of the ways these tools are adopted is, there’s developer experience teams within companies, often those are staffed by incredibly senior people, because often, those are people who are building tools to make the rest of the engineers within an organization more productive.
And we’ve seen some very, very boundary pushing kind of… We’ve seen people who are on the front lines of really trying to adopt the technology as much as possible there. But by and large, I would say on average, as a group, the senior engineers underrate what AI can do for them, and stick to their existing workflows. And so the relative ranking is a little hard, I think they fall into different anti-patterns, but they both, by and large, yet get big benefits with these tools.
Lenny Rachitsky: That makes absolute sense. I love that it’s two ends of the spectrum, expect too much, don’t expect enough. It’s like the three bears allegory.
Michael Truell: Yeah.
Lenny Rachitsky: Yeah. Okay.
Michael Truell: Yeah. Maybe the sort of senior, but not staff, right in the middle.
Lenny Rachitsky: Interesting. Okay. Just a couple more questions. What’s something that you wish you knew before you got into this role? If you could go back to Michael at the beginning of Cursor, which was not that long ago, and you could give him some advice, what’s something that you would tell him?
Michael Truell: The tough thing with this is, it feels like so much of the hard-won knowledge is tacit, and a bit hard to communicate verbally. And the sad fact of life feels like for some areas of human endeavor, you kind of do need to fall on your face to… Either need to fall on your face to learn the correct thing, or you need to be around someone who’s a great example of excellence in the thing. And one area where we have felt this is hiring. I think that we actually were… So we tried to be incredibly patient on the hiring front.
It was really important to us that, both for personal reasons and also for, I think actually for the company’s strategy, having a world-class group of engineers and researchers to work on Cursor with us was going to be incredibly important. Also, getting people who fit… A certain mix of intellectual curiosity and experimentation, because there can be so many new things we need to build. And then also an intellectual honesty, and maybe micro-pessimism, bluntness, because if all the noise, and… Especially as the company’s grown, and the business has grown, keeping a level head I think is incredibly important too.
But getting the right group of people into the company was the thing that maybe more than anything else, apart from building the product, we really, really fussed over. We actually waited a long time to grow the team because of that. And I think that many people you hear hired too fast, think we actually hired too slow to begin with. I think it could have been remedied, I think we could have been better at it.
And the method of recruiting that we ended up eventually falling into and working really well for us, which isn’t that novel, of going after people that we think are really world-class, and recruiting them over the course of, in some cases, many years, ended up working for us in the end, but I don’t think we were very good at it to begin with. And so I think that there were hard-won lessons around both who was the right profile, who actually made sense in that team, what did greatness look like, and then how to talk with someone about the opportunity, and get them excited if they really weren’t looking for anything. There were lots of learnings there about how to do that well, and that took us a bit of time.
Lenny Rachitsky: What are some of those learnings for folks that are hiring right now? What’s something you missed or learned?
Michael Truell: I think to start with, maybe we actually biased a little bit too much towards looking for people who fit the archetype of well-known school, very young, had done the things that were high credential in those well-known school environments. And actually, I think found… Were lucky early on to find fantastic people who are willing to do this with us who were later careered. I think we should kind of spent a bunch of time on maybe a little bit the wrong profile to begin with, and part of that was a seniority thing. Part of that was kind of an interest and experience thing too, we have hired people who are excellent, excellent, excellent and very young, but they maybe look in some cases slightly different from being straight out of central casting.
Another lesson is just, we very much evolved our interview loop, and so now, we have a hand-rolled set of interview questions, and then core our… Core to how we interview too, is actually, we have people onsite for two days, and do a project with us, a work test project. And that has worked really well, that increasingly you’re finding that. I think how to learn about what people are interested in, and put our best foot forward, and letting them know about the opportunity when they’re really not looking for anything, and have those conversations. There’s definitely been… Gotten better at that over time.
Lenny Rachitsky: Do you have a favorite interview question that you like to ask?
Michael Truell: I think this two-day work test which we thought would not scale past a few people has had surprising staying power. And the great thing about it is, it lets someone go end-to-end on it like a real project. It’s not work that we use, it’s canned list of projects. But it gives you two days of seeing a real work product, and it doesn’t have to be incredibly time-enhancing other teams from time. You can take the time you would spend in a half day or one day onsite, and you kind of spread it out over those two days, and give someone a lot of time to do work on their projects, and so that can actually help it scale.
It helps to enforce, do you want to be around this person type test, because you are around this person for two days, a bunch of meals with them. We didn’t expect that one to stick around, but that has been really, really important to our value to process, and then also important to getting people excited at, especially the very early stages of the company. Because before, people are using the product, and know about it. And when the product is comparatively not very good, really, the only thing you have going for you is a team of people that some people find special and want to be around. And the two days would give us a chance to just have this person meet us, and in some cases, hopefully get convinced that they want to throw in with us. That one was unexpected. Not exactly an interview question, but kind of like a forward interview.
Lenny Rachitsky: The ultimate interview question. So just to be very clear about what you’re describing, you give them an assignment, like, “Build this feature in our actual code base, work with the team to code it and ship it.” Is that roughly right?
Michael Truell: Yes. So we don’t use the IP, not shift end-to-end, but it’s like a mock… Very often in our code base, “Here’s a real mini two-day project. You’re going to do it end-to-end.” Largely being left alone, there’s collaboration too. And then we’re a pretty imprisoned company, in almost all cases, it’s actually just sitting in office with us too.
Lenny Rachitsky: And you’ve been saying that this has scaled to even today, so how big are you guys at this point?
Michael Truell: So we are going on 60 people.
Lenny Rachitsky: So small for the scale and impact. I was thinking it’d be a lot larger than that.
Michael Truell: Yeah.
Lenny Rachitsky: And I imagine the largest percent is engineers?
Michael Truell: Yeah. To be clear, a big part of the work ahead of us is building a group of people that is bigger, and awesome, and can continue to make the product better, and the service we give to customers better. And so you don’t plan to stay that small for longer, wouldn’t hope so. But part of the reason that that number is small is, the percentage of engineering and research and design is very high within the company, and so many software companies when they have roughly 40 engineers would be over 100 people, because there’s lots of operational work, and often, they’re very, very sales-led from the get-go, and that’s just quite labor-intensive. And here, we started from a place of being incredibly lean in product-led, and we now serve lots of our market customers, and it built that out, but there’s much more to do there.
Lenny Rachitsky: A question I wanted to ask you, there’s so much happening in AI, there’s things launching every… There’s newsletters, many newsletters, whose entire function is to tell you what is happening in AI every single day. Running a company that’s at the center, the white-hot center of this space, how do you stay focused, and how do you help your team stay focused, and heads down, and just build and not get distracted by all these shiny things?
Michael Truell: I think hiring is a big part of it, and if you get people with the right attitude. All of this should be asterisked in, I think we’re doing well there, I think that we’d probably be doing better there too, and it’s something that we should probably talk even more about as a company. But I think that hiring people with the right disposition, people who are less focused on external validation, more focused on building something really great, more focused on doing really high quality work, and people who are just generally level-headed, and maybe the highs aren’t very high, the lows aren’t very low. I think hiring can get you through a lot here, and I think that’s actually a learning throughout the company, is that for any… You need process, you need hierarchy, you need lots of things, but for any kind of organizational tool that you’re introducing into a company, the result you’re looking to get from that tool also… You can go pretty far on hiring people with the right behaviors that you want to resolve from that for organizational thing.
And the specific example that comes to mind is, we’ve been able to get away with not a ton of process yet on the engineering front, and I think we need a little bit more process, but for our size, not a ton of process, by hiring people who I think are really excellent. One is hiring people that are level-headed. I think two is just talking about it a lot. I think three is hopefully leading by example. And for us personally, we’ve since 2021, 2022 been professionally working on this, and been working on AI, and we’ve just seen a sea change of the comings and goings of various technologies and ideas of… If you’re to transport yourself back to end of 2021, beginning of 2022, this is GPT-3, Instruct GPT doesn’t exist, there’s no Dolly, there’s no stable diffusion. And then we’ve gone through all of those image technologies existing, ChatGPT and that rise, and GPT-4, all of these new models, all these different modalities, all the video stuff, and only a very small number of these things really kind of affects the business.
So I think we’ve kind of just built up a little bit of an immune system, and know when an event comes around that actually is really going to matter for us. This dynamic too of there being lots, and lots, and lots of chatter, but then maybe only a few things that really matter, I think has been mirrored in AI over the last decade, where there have been so many papers on deep learning in academia, so many papers on AI in academia, then the amazing thing is there are really a lot of… A lot the progress of AI can be attributed to some very simple elegant ideas that have stayed around, and the vast majority of ideas that have been put out there haven’t had staying power, and haven’t mattered a ton. And so the dynamic is a little bit mirrored in the evolution of deep learning as a field overall.
Lenny Rachitsky: Last question. What do you think people still most misunderstand, or maybe don’t fully grasp about where things are heading with AI in building in the way the world will change?
Michael Truell: People are still a little bit occupied too much, either end of a spectrum of it’s all going to happen very fast, and this is all bluster, and hype, and snake well, and I think we’re in the middle of a technology shift that’s going to be incredibly consequential. I think it’s going to be more consequential than the internet, I think it’s going to be more consequential than any shift in tech that we’ve seen since the advent of computers. And I think it’s going to take a while, and I think it’s going to be a multi-decade thing, and I think many different groups will be consequential in pushing it forward.
And to get to a world where computers can increasingly do more, and more, and more for us, there’s all of these independent problems that need to be knocked down, and progress needs to be made on them, and some of those are on the science side of things of getting these models to understand different types of data, be faster, cheaper, smarter, conform to the modalities that we care about, take actions in the real world. And then some of it’s on how we’re going to work with them, and what’s the experience that a human should actually be seeing and controlling on a computer, and working with these things.
But I think it’s going to take decades. I think that there’s going to be lots of amazing work to do. I think that also, one of the most… A pattern of a group that I think will be especially important here, not to talk our own book, but I think is the company that works on automating and augmenting a particular area of knowledge work, builds both the technology under the surface for that, integrating the best parts from providers, sometimes doing it in-house, and then also builds the product experience for that. I think people who do that, and… We’re trying to do it in software, people do that in other areas, I think those folks will be really, really, really consequential. Not just for the end value that users see, but then I think as they get to scale, they’ll be really important for pushing forward the technology, because I think they’ll be able to build… The most successful of them will be able to build very, very big businesses. So, excited to see the rise of other companies like that in other areas.
Lenny Rachitsky: I know you guys are hiring. For folks that are interested in, “Hey, I want to go work here, and build this sort of stuff.” What kind of roles are you looking for right now? Anyone specifically you’re trying… Any roles you’re most excited about filling ASAP? What should people know if they’re curious?
Michael Truell: There are so many things that this group of people need to do that we are not get equipped to do. Generic across the board, first of all, and so if you don’t think we have a role for something, maybe you should reach out, that won’t actually be the case. And maybe we can actually learn from you, and decide that we need something that we weren’t yet aware of. But by and large, I think that two of the most important things for us to do this year are have the best product in the space, and then grow it. And we’re kind of in this land grab mode, where almost everyone in the world is either using no tool like ours, or they’re using one that’s maybe developing less quickly. So growing Cursor too is a big goal, and I would say, especially always on the hunt for folks who… Excellent engineers, designers, researchers, but then folks all across the business side too.
Lenny Rachitsky: I can’t help but ask this question now that you talk about engineers, there’s this question of just, “AI’s going to write all our code.” But everyone’s still hiring engineers like crazy. All the foundational models, so many open roles.
Michael Truell: Yeah. We’re not out there tooting the horn of, people can learn to code.
Lenny Rachitsky: Do you think there’s going to be an inflection point of engineering roles start to slow down? I know this is a big question, but just… Do you see engineers being more and more needed across all these companies, or do you think at some point there’s all these Cursor agents running building for us?
Michael Truell: Again, we have the view that there’s this both long messy middle of it not jumping to a, just you step back, and you ask for all your stuff to be done, and you have your engineering department. And very much, you want to evolve from programming as it exists today, we want humans to be in the driver’s seat, and we think even in the end state, that’s giving folks control over everything is really important, and you will need professionals to do that, and decide what the software looks like.
So both I think that, yes, engineers are definitely needed. I think that engineers will be able to do much more. I think the demand for software is very lasting, which is not the most novel thing, but I think it’s kind of crazy to think about how expensive and labor-intensive it is to build things that are pretty simple and easy to specify, or it would look like it to the outside observer, and just how hard those things are to do right now.
All of the stuff that exists right now that’s justified by the cost and demand that we have now, if you could bring that down by [inaudible 01:07:56], I think you would have tons, and tons, and tons of more stuff that we could do in our computers, tons more tools. And I’ve felt this, where… One of my early jobs actually was working for a biotechnology company, and it was building internal tools for them, and the off-the-shelf tools that existed were horrible, and did not fit their use case at all. And then the internal tools I was building, there was definitely a ton of demand there for things that could be built, and that far outstripped just the things that I could build in the time that I was with them.
The physics of working on computers are so great, you should be able to basically just move everything around, do everything that you want to do. There’s still so much friction, I think that there’s much more demand for software than what we can build today with things costing like a blockbuster movie to make simple productivity software. And so I think long into the future, yes, there will actually be more demand for engineers.
Lenny Rachitsky: Is there anything that we didn’t cover that you wanted to mention? Any last nugget wisdom you wanted to leave listeners with? You could also say no, because we’ve done a lot.
Michael Truell: We think a lot about how you set up a team to be able to make new stuff, in addition to continuing to improve the stuff that you have right now. And I think if we were to be successful, IDE is going to have to change a ton, [inaudible 01:09:18] looks like is going to have to change a ton going into the future. And if you look around, the companies we respect, there are definitely examples of companies that have continued to really ride the wave of many leapfrogs, and continue to actually push the frontier. But they’re kind of rare too, it’s a hard thing to do. So part of that is just kind of thinking about the thing, and trying to reflect on it in our good days, and the first principle side of things, part of it’s also trying to get in and study past examples of greatness here, and that’s something that we think about a lot too.
Lenny Rachitsky: Yeah. Yeah. Before we started recording, you had all these books behind you, and I was like, “What’s that over there?” It’s the history of some old computer company that was influential in a lot of ways that I’ve never heard of. And I think that says a lot about you of, where a lot of this innovation comes from, is studying the past, and study history, and what’s worked and what hasn’t.
Okay. Where can folks find you online if they want to reach out and maybe apply? You said that there may be roles they may not even be aware of, where do they go find that, and then how can listeners be useful to you?
Michael Truell: Yeah. If folks are interested in working on this stuff, would love to speak, they can find… If they go to cursor.com, they can kind of both find the product and find out how to reach us.
Lenny Rachitsky: Easy. Michael, thank you so much for being here. This was incredible.
Michael Truell: It was wonderful. Thank you.
Lenny Rachitsky: Bye, everyone.
Thank you so much for listening. If you found this valuable, you can subscribe to the show on Apple Podcasts, Spotify, or your favorite podcast app. Also, please consider giving us a rating, or leaving a review as that really helps other listeners find the podcast. You can find all past episodes or learn more about the show at lennyspodcast.com. See you in the next episode.
Glossary
| English | 中文 |
|---|---|
| ARR (Annual Recurring Revenue) | 年经常性收入 |
| Chromium | Chromium(保持原文,开源浏览器引擎项目) |
| Code Pilot | Code Pilot(保持原文,可能指 GitHub Copilot 的早期版本) |
| Cursor | Cursor(保持原文,知名 AI 代码编辑器) |
| DALL·E | DALL·E(保持原文,OpenAI 的图像生成模型) |
| deep learning | 深度学习 |
| dogfooding | dogfooding(保持原文,指团队使用自己开发的产品) |
| end-to-end automation | 端到端自动化 |
| ensemble of models | 模型组合(ensemble of models) |
| Figma | Figma(保持原文,知名设计工具) |
| IDE (Integrated Development Environment) | IDE(集成开发环境,保持原文缩写) |
| InstructGPT | InstructGPT(保持原文,OpenAI 的指令微调模型) |
| issue tracker | issue tracker(保持原文,指问题追踪系统) |
| Kevin Weil | OpenAI CPO(首席产品官),播客嘉宾 |
| Lenny Rachitsky | 播客主持人、newsletter 作者 |
| Llama | Llama(Meta 的开源大语言模型) |
| Michael Truell | Anysphere 联合创始人兼 CEO,Cursor 背后公司 |
| moats | 护城河(moats) |
| next edit prediction | next edit prediction(Cursor 的一项功能,预测程序员下一步的编辑操作) |
| plug-in | 插件 |
| post-training | 后训练(post-training) |
| Salesforce | Salesforce(保持原文,知名企业软件公司) |
| scaling laws | 规模化定律 |
| Stable Diffusion | Stable Diffusion(保持原文,开源图像生成模型) |
| taste | 品味(指对”应该构建什么”的正确判断力) |
| vibe coding | vibe coding(保持原文,指一种依赖 AI 生成代码、不太关注底层细节的编程风格) |
Reformatted by reformat_english.py