在软件公司里,EPD(工程、产品和设计)是关于创造优秀的软件。虽然角色是分开的,但最终目标是做出能够解决业务问题、用户可以使用的功能性软件。归根结底,这其实只是代码。必须认识到,EPD 这个职能产出的本质就是代码,因为……编码代理突然让写代码变得非常容易。那么,这会如何改变 EPD 的角色?
变化中的流程:
PRD 已死
瓶颈从实现转向评审
PRD 万岁
对角色的影响:
通才比以往任何时候都更有价值
编码代理成为必需品
好的 PM 很出色,差的 PM 很糟糕
每个人都需要产品感
专业化的门槛更高了
你要么是构建者,要么是评审者
每个人都觉得自己的角色最能从编码代理中受益——而他们说得没错
PRD 已死
在 Claude 出现之前的时代,PRD(产品需求文档,Product Requirement Documents)是软件开发的核心。EPD 流程大致是:
某个人(通常是产品)有了一个想法
产品写一份 PRD
设计根据 PRD 做出一个原型稿
工程把原型变成代码
这并不是一成不变的规则(在初创公司里这些步骤往往会混在一起,最优秀的构建者往往能同时做其中好几件事),但这是教科书式的构建方式。
之所以需要这样做,是因为构建软件(以及制作原型)需要投入大量时间和精力。因此人们建立了不同的职能来专门负责这些工作。随着人越来越专业化,也就需要在这些职能之间进行沟通。PRD 就是这种沟通的基础,并由此启动整个流程。然后流程会像瀑布一样流向设计,设计把漂亮的文字变成漂亮的 UI 和流畅的 UX。接着工程再把它真正实现出来。
编码代理改变了这一切。编码代理可以把一个想法直接变成功能性的软件。当我(以及其他人)说“PRD 已死”时,我们真正的意思是:这种从撰写 PRD 开始的传统软件开发方式已经过时了。
瓶颈从实现转移到了评审
现在任何人都可以写代码,这意味着任何人都可以构建东西。但这并不意味着做出来的东西架构良好、解决的是正确的问题、或者足够易用。工程、产品和设计应该成为这些方面的评审者和裁决者。问题在于,生成出来的代码并不总是“很棒”。EPD 的角色变成了去评审并确保它是“很棒”的。“很棒”可以有多种含义:
从工程系统的角度来看架构是否良好:代码是否以可扩展、高性能、稳健的方式编写?
从产品角度是否经过深思熟虑:它是否解决了用户的痛点?
设计是否良好:界面是否易用且直观?
由于创建某个代码初始版本的成本非常低,我们看到越来越多的原型被创建。这些原型随后成为一个焦点,由产品、工程和设计团队一起进行评审。
问题在于——生成代码太容易了。过去,编写代码需要花一些时间,所以作为评审者,在任何时候摆到你桌面上需要评审的项目数量是有限的。但现在——任何人都可以写代码。这意味着正在进行的项目数量在增加。我们看到的瓶颈(在这三个职能中)变成了评审——拿到这些原型并确保它们是“好的”。
PRD万岁
从PRD开始构建软件的“前Claude时代”已经过去。但描述产品需求的文档仍然至关重要。
假设有人有一个想法并迅速做出了一个原型。它如何进入生产环境?它需要由EPD的其他成员进行评审。在这个过程中,一份书面文档总是有帮助,而且往往是必不可少的。当其他人进行评审时,他们怎么知道代码中的某一部分是偶然存在的还是有意为之?这取决于意图。因此需要某种方式来传达这种意图。
我认为传统的PRD流程(PRD → 原型图 → 代码)已经死了。但描述产品需求的文本仍然非常有生命力。在将原型交付评审之前,这份相关文档应该成为其必备的配套说明。
最常见的形式会是一份文档,但也有一些有趣的想法,比如共享用于创建这个功能的提示词(prompts),把它作为沟通方式。如果未来的PRD只是结构化、可版本化的提示词,会怎样?
通才比以往任何时候都更有价值
这里所说的通才,是指对产品、工程和设计三方面都有良好理解的人。这类人一直都很有价值、影响力也很大——但在有了编码代理之后更是如此。为什么?
沟通是所有事情中最难的部分。它会拖慢进度。一个能够完成产品、设计和工程所有工作的个人,比一个由三个人组成的团队要走得更快,因为沟通的开销。
之前,当实施是瓶颈时,这位通才仍然需要与他人沟通才能完成工作。现在,他们只需要与代理沟通。这意味着他们仅凭自己就能比以往更具影响力。
编码代理是必需的
由于编码代理使得实施变得便宜,使用它们是必须的。能够使用编码代理的人将能够自己完成更多的工作:
采用编码代理的PM可以通过直接构建原型来验证想法,而无需编写规格说明并等待。
采用编码代理的设计师可以在代码中进行迭代,而不仅仅是在Figma中。
采用编码代理的工程师可以将时间从实施转移到系统思考上。
采用编码代理是必须的,因为这并不难,如果你不这么做,你会被那些做的人取代。
优秀的PM很棒,差的PM很糟糕。
好的产品思维比以往任何时候都更有价值——你可以构建有用的东西。差的产品思维比以往任何时候都更浪费。如果有人有一个糟糕的产品想法,他们可以拿着原型出现——但那个原型将是一个无用或构思不周的功能。这些原型现在需要更多的审查——来自工程、产品和设计。这消耗了时间和资源。要将这些原型投入生产也需要更多的惯性(“它已经存在了!我们直接合并吧!”)。这有可能导致产品变得更糟或臃肿。
系统思考是需要磨练的技能
在执行成本便宜的世界中,系统思考成为了区分者。你应该专注于成为一名擅长系统思考的人,并且对你所在领域有清晰的思维模型:
工程:非常好的思维模型,帮助架构服务、API 和数据库。
产品:非常好的思维模型,帮助了解用户实际需要的东西,而不是他们说想要的。
设计:非常好的思维模型,帮助理解为什么某个东西看起来和使用起来是合适的。
系统思维一直都很重要——那么,是什么改变了呢?实施的成本大大降低了。这意味着实现某些东西比以往任何时候都更容易——但这并不意味着它就一定很棒。成为一个优秀的系统思考者,能够确保你一开始就构建正确的东西。它还可以让你在事后审查他人的工作。这两者都意味着,成为一个优秀的系统思考者的重要性已经增加。
每个人都需要产品感觉。
编码代理仍然需要有人来引导他们,需要有人告诉他们该做什么。如果你告诉他们去构建错误的东西——你是在为别人制造更多需要审查的杂乱。知道该告诉代理构建什么(“产品感觉”)是必备的,否则你会成为组织的拖累。这对于工程、设计和(显然)产品都是适用的。
EPD 的一个重要部分现在是审查原型。如果你有产品感觉,审查设计/工程时会更容易。如果你没有产品感觉,你需要一份非常详细的产品文档与原型一起使用。如果你有产品感觉,你能通过最简洁的规格理解功能的意图,从而加速沟通、审查和交付。
专业化的门槛更高了。
你需要知道如何使用编码代理。你需要产品感觉。所有角色之间的界限正在模糊。
角色之间一直有重叠。设计和产品长期以来一直是紧密相关的——在一些公司,比如苹果和AirBnb,设计师担任产品经理。像 Vercel 这样的公司,‘设计工程师’这一角色越来越受欢迎。
这并不意味着没有专业化的空间。一位非常资深的工程师,如果只关注系统架构,依然是有价值的。同样,一个没有学会编码,但对客户问题和该构建什么有非常清晰的思维模型的 PM 也是有价值的。一个能够理解并模拟用户旅程和交互的设计师也是如此,即便他/她仍然使用 Figma。
但专业化的门槛确实更高了。你不仅要在自己的领域非常出色,还要在审查和沟通方面非常快速和出色。而且在任何公司,可能没有那么多这样的角色。
你要么是构建者,要么是评审者
我们看到在 EPD 中正在出现两种不同类型的角色。
第一种:构建者。这类人具备良好的产品思维,能够使用编码代理,并且拥有基础的设计直觉。在有护栏的情况下(测试套件、组件库),他们可以把小功能从想法带到生产环境,也可以为更大的功能做出可运行的原型。
第二种:评审者。对于大型且复杂的功能,需要进行细致的 EPD 评审。这个门槛很高——你必须在自己的领域里是出色的系统思考者。同时你还必须工作节奏很快——需要评审的内容很多。
如果你现在是一名工程师——你要么应该努力在系统设计方面变得非常出色,并且能够自如地评审架构,目标成为一名评审者……要么尝试提升你的产品/设计能力,成为一名构建者。
如果你在做产品或设计——你要么必须对产品/设计有非常出色的心智模型,并主要承担评审工作;要么就要开始使用编码代理并提升你的编程能力。
有意思的是,角色正在某种程度上开始融合,这一点从整个 EPD 都分布在上面的图表中可以看出来。角色开始相互交融——工程师有了更多时间,可以更多地思考产品和设计;而产品和设计人员也可以编写代码。
每个人都觉得自己的角色最能从编码代理中受益——而他们其实都没错。
Twitter 上有一篇很棒的帖子,讲的是哪类人最能从编码代理中受益:
那种对现有产品有直觉式理解的人——知道哪里还不够好,哪里真正出彩,以及如何把它不断迭代打磨得更加锋利。
这种人最稀有的版本,是站在文化与深度技术交汇点的人。某种真正的“双语者”。他们既知道技术上什么是可能的,也知道哪些文化潮流是真实的、哪些只是昙花一现。正是这种组合,让产品看起来像是必然出现的,而不是被拼装出来的。
这篇帖子很好地概括了这个新世界,并且在一定程度上走红了。它之所以传播开来,其中一个原因是:每个读到它的人都觉得它是在说自己或自己的角色。我看到做产品的人在引用它、设计师在引用、设计工程师、创始人……每个人都觉得它适用于自己和自己的角色。
而且他们可能都说对了!我觉得这个新世界最伟大、最令人兴奋的一点是:背景变得没那么重要了。我真心相信,这种类型的人可能来自产品、设计或工程领域。这并不意味着每个人都能成为这样的人——说起来容易,做起来难。真正的“独角兽”其实非常少。
这是一个令人兴奋的建设与创造的时代 :)
显示英文原文 / Show English Original
EPD (Engineering, Product, and Design) at software company is about creating good software. Separate roles exist, but the end goal is functional software that solves a business problem that users can use. At the end of the day, this is just code. It is important to recognize that the output of what EPD as a function builds is just code because… coding agents have suddenly made code very easy to write. So how does this change the role of EPD? The changing process: PRDs are dead The bottleneck shifts from implementation to review Long live PRDs Impact on roles: Generalists are more valuable than ever Coding agents are a requirement
Good PMs are great, bad PMs are terrible Everyone needs product sense The bar for specialization is higher You're either a builder or a reviewer Everyone thinks their role is most advantaged by coding agents - and they are right PRDs are dead PRDs (Product Requirement Documents) were the focal point of building software in the pre-Claude era. The EPD process was largely: Someone (usually product) has an idea
Product writes a PRD Design takes PRD and creates a mock Engineering turns mock into code This wasn’t a hard and fast rule (at startups these steps blended together, the best builders were able to do multiple of these together) but it was the textbook way to build things. This was required because building the software (and building the mock) required a significant amount of time and effort. So disciplines were created to specialize in those efforts. As people became more specialized, there then became a need to communicate across those disciplines. The PRD was the basis of that, which kickstarted everything. It would then waterfall to design, who would turn pretty words into a pretty UI and smooth UX. Engineering would then make that real. Coding agents change all of that. Coding agents can take an idea and create functional software. When I (and others) say “PRDs are dead” what we really mean is this traditional way of building software, starting with the writing of a PRD, is dead. The bottleneck shifts from implementation to review Anyone can write code now, which means anyone can build things. That does not mean the things that are built are well architected, or solve the right problems, or easy to use. Engineering, Product, and Design should be the reviewers and arbitrators of these areas. The issue is the code generated isn’t always “great”. The role of EPD becomes reviewing and making sure it is “great”. “great” can mean several things:
Well architected from an engineering systems perspective: is it written in a scalable, performant, robust way? Well thought out from a product perspective: does this solve the user pain point? Well designed: are the interfaces easy and intuitive to use? Since the cost of creating some initial version of the code is so cheap, we see that a lot more prototypes are created. Those prototypes then serve as a focal point, with Product, Engineering, and Design reviewing them. The issue is - it’s so easy to generate code. Previously, it took a while to create the code - so as a reviewer there were only so many projects coming across your desk for review at any given point. Now though - anyone can write code. That means the number of projects going on is increasing. We’ve seen the bottleneck (in all three functions) be review - taking the prototypes and making sure they are “good”. Long live PRDs The pre-Claude era of building software (starting with a PRD) is gone. But documents describing product requirements are still essential. Let’s assume someone has an idea and quickly builds a prototype. How does this get into production? It needs to be reviewed by other members of EPD. As part of this process, a written document always helps and is often essential. When others are reviewing, how are they to know if part of the code is there by accident or on purpose? Depends on the intent. Some communication of this intent is needed.
I think the traditional PRD process (PRD → mock → code) is dead. But text that describes product requirements is very much alive. This associated document should be a required companion to the prototype before being handed off for review. The most standard format would be a document, but there are some interesting ideas around sharing the prompts used to create this feature as a way to communicate that. What if PRDs of the future are just structured, versioned prompts? Generalists are more valuable than ever By generalists I mean people with a good sense of all three of product, engineering and design. These people were always valuable and impactful - but with coding agents they are even more so. Why? Communication is the hardest part of everything. It slows things down. One person who can do all of product, design, and engineering will move faster than a team of three because of the communication overhead. Previously, when implementation was the blocker, this generalist still had to communicate with others to get work done. Now they can just communicate with agents. This means they can be far more impactful by just themselves than ever before. Coding agents are a requirement With coding agents making implementation cheap, using them is a requirement. People who can adopt coding agents will be able to do more by themselves:
PMs who adopt coding agents can validate ideas by building prototypes directly, without writing a spec and waiting Designers who adopt coding agents can iterate in code, not just in Figma Engineers who adopt coding agents can shift their time from implementation to system thinking Adopting coding agents is a requirement because it is not hard to do so, and if you don’t do you so you will be replaced by someone who does. Good PMs are great, bad PMs are terrible Good product thinking is more valuable than ever - you can build things that are useful. Bad product thinking is more wasteful than ever. If someone has a bad product idea, they can show up with a prototype - but that prototype will be of a feature that is useless, or poorly conceived. These prototypes now require more reviews - from engineering, product and design. This sucks up time and resources. There is also more inertia to get these prototypes into production (”It already exists! Let’s just merge it!”). This risks creating a worse or bloated product. System thinking is the skill to hone In a world where execution is cheap, system thinking becomes the differentiator. You should focus on being really good at systems thinking and have a clear mental model of your particular domain:
Engineering: really good mental model of how to architect services and APIs and databases Product: really good mental model of what users actually need, not what they say they want Design: really good mental model of why something looks and feels right to use System thinking has always been important - so what has changed? The cost of implementation went way down. This means that it is easier than ever to implement something - but that doesn’t mean it’s great. Being a good system thinker allows you make sure you are building the right things upfront. It also lets you review others work after the fact. Both mean that the importance of being a good system thinker has grown. Everyone needs product sense Coding agents still need someone to prompt them. Someone to tell them what to do. If you tell them to build the wrong thing - you are creating more slop for others to review. Knowing what to tell the agent to build (”product sense”) is a requirement, or you will be a drag on the org. This is true across engineering, design, and (obviously) product. A big part of EPD is now reviewing prototypes. Reviewing is easier if you have product sense, even for reviewing design/engineering. If you don’t have product sense, you need a super detailed product document along side the prototype. If you do have product sense you understand the intent of the feature with a minimal spec, speeding up communication, review, and delivery. The bar for specialization is higher
You need to know how to use coding agents. You need product sense. All the roles are blending together. There’s always been overlap in roles. Design and product have long been linked -a t certain companies like Apple and AirBnb, designers serve as product managers. “Design engineer” as a role has been picking up steam at companies like Vercel. This doesn’t mean there is no room for specialization. A very senior engineer who just thinks about the system architecture is still valuable. As is a PM who hasn’t picked up vibe coding but does have a super clear mental model of the customers problems and what to build. Same with a designer who can understand and mock user journeys and interactions, even if still in Figma. But the bar for specialization is much higher. You have to be not only fantastic at your domain, but also incredibly fast at review and an incredible communicator. And there probably aren’t that many of these roles at any given company. You’re either a builder or a reviewer We see two different types of roles emerging in EPD. First: the builder. This archetype has good product thinking, they are capable of using coding agents, and have baseline design intuition. With guardrails around them (test suite, component library) they can take small features from idea to production, and prototype functional versions of larger ones. Second: the reviewer. For large and complicated features, detailed EPD review is required. The bar for this is high - you have to be a fantastic systems thinker in your domain. You also have to work at a fast pace - there is a lot to review.
If you are an engineer right now - you should either aim to get fantastic at system design and comfortable reviewing architectures and aim to be a reviewer… or try to grow your product/design skills and become a builder. If you are in product or design - you either have to have a fantastic mental model for product/design and largely review, or jump into coding agents and improving your coding chops. Whats interesting is that roles are kind of collapsing, as shown by all of EPD being somewhere on the above chart. Roles can start to blend together - engineers have more time, can think more on product and design. Product and design can create code. Everyone thinks their role is most advantaged by coding agents - and they are right There was a great post on Twitter about the type of people most advantaged by coding agents: someone with an intuitive grasp of the product as it exists, where it's soft, where it sings, & how to iterate it toward something even sharper. the rarest version of this person sits at the intersection of culture & deep technology. someone genuinely bilingual. they know what's technically possible & they know which cultural currents are real vs. ephemeral. that combo is what separates products that feel inevitable from products that feel assembled. The post was a great encapsulation of this new world, and it went semi-viral. Part of the reason it went viral was everyone reading it thought it was about them or their role. I saw product people quoting it, designers, design engineers, founders… everyone thought it applied to them and their role.
And they were all probably right! I think the great and exciting thing about this new world is that backgrounds matter less. I genuinely believe this archetype of person could come from product, design, or engineering. That doesn’t mean everyone will be this person - it’s much easier said than done. There are very few true unicorns out there It’s an exciting time to be building :)