传统的团队扩张方式已经死了。 过去我们是靠不断招聘专家来扩张——设计师、工程师、产品经理，各自做各自的事，通过“加人”来放大产能。但当 Cursor 能让你在几分钟内从 idea 直接生成代码，执行不再是瓶颈，品味和判断力才是。 现在真正重要的是： 能够看见整个全栈、能在不同层之间流动，但又在某个 AI 还无法复制的领域拥有深度专长的人。 像 T-shaped 人才，但横向更宽——跨领域流畅沟通，某一项能力又深不可替代。 AI 不只是让你变快，它会重新把团队连接起来。 不再是传统瀑布：设计师写原型代码，工程师把它扩展，两个人在同一种媒介里工作。学科之间的鸿沟正在消失。 这也提高了个人的“上限”。 我是个设计师，却完全用 Cursor 构建了 ryOS——以前根本不可能做到。但我不是在取代工程师，而是在消除执行的障碍，同时保留设计品味和系统思维。 你不再是为“角色”招聘。 你招聘的是 广度 + 深度、品味、系统思维、学习速度。 五个能跨代码 / 设计 / 产品的通才团队，胜过二十个需要不断对接协作的专家。 新的瓶颈是深度的人性能力：品味、愿景、判断、语境。 AI 可以给你无数选项，但它无法告诉你哪个才是对的。 真正的“专业”现在体现在判断，而不是执行。 小团队、流动的边界、所有人使用同一套工具。 角色仍然重要，但更像“重叠的关注点深度不同”，而不是泾渭分明的孤岛。工具负责执行，你负责愿景。 这正是我们在 Cursor 要构建的——缩短构思与现实之间的距离。这样你的品味就成为核心，团队也能更自由地探索那些疯狂又有可能改变世界的想法。 the old way of scaling teams is dead: we used to hire specialists – designers, engineers, PMs – each in their lane, scaling by adding more people. but when Cursor can take you from idea to code in minutes, execution isn't the bottleneck anymore. taste and judgment are. what matters now: people who can see the full stack, move between layers, but specialize deeply in something AI can't replicate yet. T-shaped but way wider – conversant across domains, expert in one thing. AI doesn't just make you faster. it ties teams together differently. no more waterfall – designer codes the prototype, engineer extends it, both work in the same medium. the gap between disciplines disappears. this raises individual ceilings. i'm a designer who built ryOS entirely in Cursor – couldn't have done that before. but i'm not replacing engineers, i'm just removing execution barriers while keeping my design taste and systems thinking. you're not hiring for roles anymore. you're hiring for breadth + depth, taste, systems thinking, learning velocity. 5 people who can work across code/design/product beat 20 specialists coordinating handoffs. the new bottlenecks are deeply human: taste, vision, judgment, context. AI explores options, but can't tell you which is right. that's where specialization matters now – in judgment, not execution. small teams, fluid boundaries, everyone working in the same tools. roles still matter but as overlapping concerns with different depths, not separate silos. tools handle execution, you handle vision. this is what we're building at Cursor – closing the gap between idea and reality. so your taste becomes the main thing, and teams have more freedom to explore crazy ideas.
Ryo LuHead of Design，Cursor
观点原文
传统的团队扩张方式已经死了。
过去我们是靠不断招聘专家来扩张——设计师、工程师、产品经理，各自做各自的事，通过“加人”来放大产能。但当 Cursor 能让你在几分钟内从 idea 直接生成代码，执行不再是瓶颈，品味和判断力才是。
现在真正重要的是：
能够看见整个全栈、能在不同层之间流动，但又在某个 AI 还无法复制的领域拥有深度专长的人。
像 T-shaped 人才，但横向更宽——跨领域流畅沟通，某一项能力又深不可替代。
AI 不只是让你变快，它会重新把团队连接起来。
不再是传统瀑布：设计师写原型代码，工程师把它扩展，两个人在同一种媒介里工作。学科之间的鸿沟正在消失。
这也提高了个人的“上限”。
我是个设计师，却完全用 Cursor 构建了 ryOS——以前根本不可能做到。但我不是在取代工程师，而是在消除执行的障碍，同时保留设计品味和系统思维。
你不再是为“角色”招聘。
你招聘的是 广度 + 深度、品味、系统思维、学习速度。
五个能跨代码 / 设计 / 产品的通才团队，胜过二十个需要不断对接协作的专家。
新的瓶颈是深度的人性能力：品味、愿景、判断、语境。
AI 可以给你无数选项，但它无法告诉你哪个才是对的。
真正的“专业”现在体现在判断，而不是执行。
小团队、流动的边界、所有人使用同一套工具。
角色仍然重要，但更像“重叠的关注点深度不同”，而不是泾渭分明的孤岛。工具负责执行，你负责愿景。
这正是我们在 Cursor 要构建的——缩短构思与现实之间的距离。这样你的品味就成为核心，团队也能更自由地探索那些疯狂又有可能改变世界的想法。
the old way of scaling teams is dead:
we used to hire specialists – designers, engineers, PMs – each in their lane, scaling by adding more people. but when Cursor can take you from idea to code in minutes, execution isn't the bottleneck anymore. taste and judgment are.
what matters now: people who can see the full stack, move between layers, but specialize deeply in something AI can't replicate yet. T-shaped but way wider – conversant across domains, expert in one thing.
AI doesn't just make you faster. it ties teams together differently. no more waterfall – designer codes the prototype, engineer extends it, both work in the same medium. the gap between disciplines disappears.
this raises individual ceilings. i'm a designer who built ryOS entirely in Cursor – couldn't have done that before. but i'm not replacing engineers, i'm just removing execution barriers while keeping my design taste and systems thinking.
you're not hiring for roles anymore. you're hiring for breadth + depth, taste, systems thinking, learning velocity. 5 people who can work across code/design/product beat 20 specialists coordinating handoffs.
the new bottlenecks are deeply human: taste, vision, judgment, context. AI explores options, but can't tell you which is right. that's where specialization matters now – in judgment, not execution.
small teams, fluid boundaries, everyone working in the same tools. roles still matter but as overlapping concerns with different depths, not separate silos. tools handle execution, you handle vision.
this is what we're building at Cursor – closing the gap between idea and reality. so your taste becomes the main thing, and teams have more freedom to explore crazy ideas.
Sharing
相关观点
- 软件依然是一门关于“思考”的工作 软件从来都是：把模糊的人类需求，提炼成精确、相互咬合的系统。真正的技艺不在敲代码，而在拆解：该创造哪些抽象？边界放在哪里？各个部分如何通信？ 当下用 AI 写代码，出现了一个新的陷阱：没有结构的速度幻觉。代码可以生成得很快，但如果没有清晰的系统架构——没有真正的边界、明确的不变量、核心抽象——你最终得到的只是一个“暂时能跑的堆”。它之所以变成一堆烂泥（slop），是因为背后没有一致的心智模型。 AI 并不会取代系统思维，它只会放大你不做系统思考的代价。如果你自己都不知道结构上想要什么，AI 只会用它见过最多的模式来填空。结果就是： * 用通用解法应付具体问题 * 需要清晰边界的地方却高度耦合 * 同一件事出现三种做法，只因为你从未定义“唯一正确的方式” 随着 Cursor 能处理越来越长的任务，“大概方向对”与“系统被精确理解”之间的差距会指数级扩大。当 agent 执行的是 100 步而不是 10 步时，你的角色只会更重要，而不是更不重要。 技能正在从“亲手写每一行代码”转向“在脑中完整地持有系统，并清晰地传达它的本质”： 定义边界：核心抽象是什么？这个组件该知道什么？状态应该放在哪里？ 指定不变量：哪些条件必须始终成立？哪些常量和默认值支撑系统运转？ 引导拆解：系统该如何分解？自然结构是什么？哪些是稳定的，哪些会变化？ 保持一致性：当 AI 生成越来越多代码时，你要确保它符合心智模型、遵循模式、尊重边界。 这正是优秀架构师和设计师一直在做的事：他们不写每一行代码，但持有系统设计，并引导整体走向一致性。Agent 只是速度极快、极其字面理解的团队成员。 真正的危险，是因为 AI 让“思考”看起来变得可有可无，于是你跳过了它。人们靠 prompt 一路堆出自己都不理解的代码库： 无法调试，因为从没设计过 无法扩展，因为没有结构，只有功能叠加 真正懂系统的人，现在可以快 100 倍。你把时间花在最难的部分——理解你在构建什么、以及为什么要这样构建——而 AI 负责机械性的翻译工作。你不再被语法拖住，可以更久地停留在架构层。 未来不是“AI 取代程序员”，也不是“人人都会写代码”，而是：想清楚系统的人，会以惊人的速度构建；想不清楚的人，会大规模制造垃圾代码。 真正的核心技能变成了：承载复杂性、干净地拆解、精确地表达结构。更少语法，更多系统；更少实现，更多架构；更少写代码，更多设计一致性。 人类擅长的是：看见模式、理解权衡、判断事物该如何组合在一起。 AI 无法拯救混乱的思考——它只会让混乱跑得更快。 software is still about thinking software has always been about taking ambiguous human needs and crystallizing them into precise, interlocking systems. the craft is in the breakdown: which abstractions to create, where boundaries should live, how pieces communicate. coding with ai today creates a new trap: the illusion of speed without structure. you can generate code fast, but without clear system architecture – the real boundaries, the actual invariants, the core abstractions – you end up with a pile that works until it doesn't. it's slop because there's no coherent mental model underneath. ai doesn't replace systems thinking – it amplifies the cost of not doing it. if you don't know what you want structurally, ai fills gaps with whatever pattern it's seen most. you get generic solutions to specific problems. coupled code where you needed clean boundaries. three different ways of doing the same thing because you never specified the one way. as Cursor handles longer tasks, the gap between "vaguely right direction" and "precisely understood system" compounds exponentially. when agents execute 100 steps instead of 10, your role becomes more important, not less. the skill shifts from "writing every line" to "holding the system in your head and communicating its essence": - define boundaries – what are the core abstractions? what should this component know? where does state live? - specify invariants – what must always be true? what are the constants and defaults that make the system work? - guide decomposition – how should this break down? what's the natural structure? what's stable vs likely to change? - maintain coherence – as ai generates more code, you ensure it fits the mental model, follows patterns, respects boundaries. this is what great architects and designers do: they don't write every line, but they hold the system design and guide toward coherence. agents are just very fast, very literal team members. the danger is skipping the thinking because ai makes it feel optional. people prompt their way into codebases they don't understand. can't debug because they never designed it. can't extend because there's no structure, just accumulated features. people who think deeply about systems can now move 100x faster. you spend time on the hard problem – understanding what you're building and why – and ai handles mechanical translation. you're not bogged down in syntax, so you stay in the architectural layer longer. the future isn't "ai replaces programmers" or "everyone can code now." it's "people who think clearly about systems build incredibly fast, and people who don't generate slop at scale." the skill becomes: holding complexity, breaking it down cleanly, communicating structure precisely. less syntax, more systems. less implementation, more architecture. less writing code, more designing coherence. humans are great at seeing patterns, understanding tradeoffs, making judgment calls about how things should fit together. ai can't save you from unclear thinking – it just makes unclear thinking run faster.Ryo Lu · 2026/02/05
- 代码不是牢笼，它是人类历史上唯一真正没有边界的材料。你可以用它重建、重组、重新想象，速度超过任何其他媒介。认为“在代码中工作会把你锁进既有模式”的想法，只有在你害怕这种材料时才成立。 真相只会在你真正开始构建时显现。不是在你思考构建的时候，不是在一个受保护的空间里勾勒可能性的时候——而是在你把东西真正做出来、让现实对你作出回应的时候。草图和探索之所以让人感觉自由，是因为它们允许你回避那些艰难的问题。而构建会迫使你回答这些问题，这正是你发现什么才真正可行的地方。 把设计拆分成不同阶段的那一整套框架——先自由探索，再引入约束，最后才开始构建——本质上只是对创作过程的官僚化处理。它把本该鲜活、迭代的过程强行线性化。结果就是：你在错误的媒介里“寻找”得太久，等到真正接触现实材料时，已经对最初的想法投入过深，无法推倒重来。你只得到一次探索，然后就被迫承诺。这不是在保护创造力，而是在限制它。 最好的作品，来自于在真实材料中反复迭代。构建、学习、重建、再学习。代码让这一切发生得比任何草图都快。它会暴露边界条件、涌现行为，以及那些只有在系统真实存在时才会出现的交互。约束并不是等你“准备好了”再引入的东西——正是约束，让你发现那些在抽象层面根本看不到的优雅解法。 建筑师不会先脱离物理规律随意画草图，然后再“邀请”重力登场。他们从第一笔开始就考虑材料，因为他们知道：真理存在于材料之中。草图之所以有效，是因为它压缩了对材料的理解，而不是把幻想隔绝于现实之外。软件也应该如此。真正理解系统——它的原语、数据模型、能力边界——不会限制你的想象力，反而会扩展它。它让你看到真正可行的东西，而不是仅仅“看起来能想象”的东西。 把“设计”与“媒介本身”分离，并不会保护探索，它只是让你在太晚之前都不用面对一个问题：你的想法到底行不行。真正有价值的痛苦，不是在一切皆有可能的搜索阶段，而是在你把东西做出来、被现实反击、被迫找到更好方案的时候。工艺就在这里。突破也发生在这里。 把代码当成“等真正思考完成后再进入的阶段”， 这才是真正的牢笼。这意味着：不理解材料能力的设计师在幻想空间里构思，然后把半成品想法交给别人去实现。损失不仅发生在交接过程中，更发生在思考本身。 伟大的软件，来自那些能在所有层级同时思考的人—— 从模糊的想法，到交互方式，到数据结构，一并成立。 未来不是去保护阶段、维持分工边界。而是要更快地接近真实材料本身。是要有那种让你在同一个动作里思考、构建、迭代的工具，让你发现真正可行的东西，而不是过早承诺那些只在草图里看起来不错的想法。 代码不是探索的敌人， 它是探索真正变成现实的唯一场所。 code isn't a cage, it's the only material that's actually boundless. you can rebuild, restructure, and reimagine faster than any other medium in human history. the idea that working in code locks you into existing patterns is only true if you're afraid of the material. the truth only reveals itself when you build. not when you think about building, not when you sketch possibilities in a protected space – when you actually make the thing real and let reality talk back. sketches and explorations feel free because they let you avoid the hard questions. building forces you to answer them, and that's where you discover what actually works. this whole framework of separating design into phases – first explore freely, then invite constraints, then build – that's just bureaucracy for the creative process. it linearizes something that should be iterative and alive. you end up spending so long "searching" in the wrong medium that by the time you touch the real material, you're too invested in your early idea to start over. you get one round of exploration, then commitment. that's not protecting creativity, that's limiting it. the best work happens when you can iterate in the actual material. build, learn, rebuild, learn again. code lets you do this faster than any sketch ever could. it shows you the edge cases, the emergent behaviors, the interactions that only exist when the system is real. constraints aren't something you invite later when you're ready – they're what reveal the elegant solution you couldn't see in the abstract. architects don't sketch free from physics then invite gravity later. they think through materials from the first line because they understand that the material is where truth lives. the sketch works because it's compressed material knowledge, not fantasy protected from reality. software should be the same. understanding the system deeply – the primitives, the data models, the capabilities – doesn't limit your imagination, it expands it. it shows you what's actually possible instead of what's merely conceivable. separating "design" from "the medium" doesn't protect exploration, it protects you from learning whether your idea works until it's too late to really change it. the valuable suffering isn't the searching phase where everything feels possible. it's when you build something and reality pushes back and forces you to find something better. that's where craft lives. that's where breakthroughs happen. treating code as something you "graduate to" after the real thinking is done – that's the actual cage. it means designers who don't understand what the material can do, building in a fantasy space, then handing off half-formed ideas to people who have to make them real. the translation loss isn't just in the handoff, it's in the thinking. great software comes from people who can think at every level, from the loose idea to the interaction to the data structure, all at once. the future isn't about protecting phases or preserving separation. it's about getting closer to the true material, faster. it's about tools that let you think and build and iterate in the same motion, so you can discover what actually works instead of committing to what seemed good in a sketch. code isn't the enemy of exploration, it's the only place exploration becomes real.Ryo Lu · 2025/12/16
- 定制系统过去成本过高，因此我们只能勉强使用拼拼凑凑的 SaaS 和各种框架，并被迫承受它们带来的沉重负担。 Cursor 的智能代理改变了这一切——不再是按周计算，而是按天构建，打造真正契合团队需求的更简单系统。 custom systems were too costly, so we lived with frankensteined SaaS and frameworks and their baggage Cursor agents changed this – days not weeks, build simpler systems that actually fit your teamRyo Lu · 2025/12/14
- 我们花了一个小时在争论，要用模型图、视频，还是直接用真代码来做 http://cursor.com 的演示。 我当时就说：“直接干就行了。” 然后我在 Cursor 里不到一小时就把基础 demo 写出来了。 团队里的每个设计师也都加入进来，自己把自己的部分写成了代码。 这才是正确的做法。 we spent an hour debating mocks vs videos vs real code for the http://cursor.com demos. i was like “just do it” – built the base demos in Cursor in under an hour. every designer on the team jumped in and coded their own parts. that's the way to do it.Ryo Lu · 2025/11/26