推广软件工厂的策略:人员与组织变革
Tactics for rolling out software factories: human and organizational changes

In this post I’ll give some concrete tactics on how to roll out software factories across an org. By “software factories” I mean agentic loops in the cloud that are measurable and improveable over time. I’m going to focus on human and org changes, not technical aspects of factory enablement here. For the tech underpinnings, I’ll assume you are using infra like a factory stack.
tl;dr
- The goal is not to get to full automation. It’s to ship the highest quality software with the most customer impact as quickly and as efficiently as possible.
- Start with simple, low-risk factory automations: the tasks engineers view as chores.
- Make direct prompting through the factory as easy as tagging an agent in the tools engineers already use.
- Position the factory not as a “product” but as an infra platform where everyone does “factory engineering.”
- Encourage but don’t require it, and celebrate shipped work - not token spend.
- Track adoption first (% of merged PRs through the factory), then throughput, cycle time, and cost per PR.
Start with the goal
Let’s start with the goal. It’s not to get to full automation. The goal is to get the most out of coding agents at your organization so that you are shipping the highest quality software with the most customer impact as quickly and efficiently as possible. You’ll want to prove that you are doing this by carefully measuring and tuning your factory. We call this “factory engineering.”
An important prerequisite: you can’t do factory engineering unless your team first does at least some of its product engineering through the factory as opposed to local coding agents. This means centralizing your agents into one shared configuration that the team can optimize together. Once work starts flowing through the factory infra, you’ll have a baseline to measure and improve.
Two strategies to get going
There are two strategies we’ve been using internally at Warp and with customers to get going. The first is to put in place simple factory automations. For example, Warp’s own factory automates fixing server crashes as they are reported by Sentry. It automatically triages new issues that we run into while dogfooding. It generates our weekly changelog and updates our public docs. For customers, we have set up similar automations for investigating production issues, triaging user feedback, and more.
These are all low-risk tasks that you can have an agent do on its own. If the agent gets it right, great. If not, you can either ignore the output or have a human fix it (and if you do fix it, that serves as an important input into the learning loop of factory engineering, which I’ll get to). The point is to start simple, get some tasks running, and help engineers get accustomed to factory infrastructure and interacting with factory agents. Picking tasks that engineers view as chores is a good strategy for showing value immediately.
By starting with automations, you aren’t asking engineers to change their daily habits much; one person can set up the automation for everyone and the whole team reaps some benefit. Ideally though, the whole team responds to the outputs of these automations, taking ownership of reviewing their PRs or generated issues. The key thing is to make sure that the automations have a good signal to noise ratio and that any outcomes of the automations have clear owners.
For this reason, I don’t recommend starting with a full loop of agents fixing your backlog or auto-fixing new issues. It’s too likely the agents will generate PRs that never get reviewed and that will turn the engineering team off from a factory approach (“this thing is just a slop cannon”). Start small and focus on tasks where the outputs are likely to be right from the outset. Have a team of factory champions responsible for setting these up, and don’t roll your factory out widely until that team has tuned the automations to reliably generate high quality work.
Strategy 2: make direct prompting through the factory easy
The second strategy is to make it as easy as possible to do direct prompting through the factory, rather than locally. At Warp we have made this transition – the majority of our direct prompting starts in Slack and is continued in the other cloud tools we rely on like Linear and Github. Our factory infrastructure allows this: you can start work in one tool and continue in another with the same context.
From working with customers we know that this is a big behavior change and needs a lot of thought in how to approach it. The important principle is meeting engineers where they already work. Introducing a new product surface or workflow for inputting factory work is going to be higher friction than allowing engineers to tag agents in the tools they are already using. We do not recommend building a new “factory web portal” as the primary place to work with a factory.
Instead, make the factory accessible from your comms platforms like Slack and Teams, issue trackers like Jira and Linear, and code forges like Github and Gitlab. Make working through the factory as easy as tagging an agent in one of these tools. Make sure this works reliably, quickly, and that all of the permissions and context that the agent needs to do its work are set up. Again, if developers try these flows and they don’t work, it quickly erodes confidence in the whole factory approach and makes folks reach for local tools.
Speaking of local tools, you also want the factory to integrate directly with local coding agents. If the eng team is using a mix of Claude Code, Codex, Pi, etc, they should be able to put work into the factory directly through them; that means that instead of their local prompt being sent to the local agent, it instead goes to a factory MCP that submits the work to the cloud loop.
Your factory should support work entering at any stage of the software lifecycle: right at the outset with a new ticket or idea, after a spec exists, or even after an engineer has drafted a local PR. Again, the goal is to make submitting work as easy as possible, so that more of it flows through the cloud infrastructure and you start to build a muscle around working in the factory, and a dataset that factory engineering can improve.

Position the factory as infra, not product
As part of setting up early automations and direct prompting, you should make sure that your team doesn’t hit dead ends when their factories break. Developers like to control their tools; they want to be able to understand and debug issues without blocking on someone else to help. If you approach your factory as infra that the whole team owns, that’s much more likely to appeal to most devs than approaching it as a piece of SaaS that only an admin can configure.
So position the factories not as a “product,” but as an infra platform upon which everyone is expected to do “factory engineering.” Factory engineering is work to make internal factories better. That means improving the skills, models, and context that drive engineering throughput. It means encouraging engineers to build automations for their chore work. It means giving them the tools to score and benchmark factory workflows, and empowering them to use agents to build self-improvement loops. It means that everyone owns lowering factory costs and improving factory ROI. If you use a platform like Warp Factories, all of this tooling comes built-in, but beyond the tooling “factory engineering” is really a mindset.
Encourage, but don’t require it
Assuming you have the right infra in place, you need to incentivize the team to start using it. The way we achieved this at Warp is by having leadership encourage but not require it, and celebrating when folks work in the factory through public praise, a factory leaderboard (not a token leaderboard), or a shared slack channel showing cool factory work. A factory leaderboard should take cost into account and celebrate shipped work, not token spend.
For our team, once engineers started working in public they typically had an *aha* moment on how it’s better. For instance, when you start work in Slack, you can easily tag a teammate in for their opinion and all the context is already there. You can continue that work on your phone from anywhere. You can search your team’s history, and use that work to inform the next prompt. There are a lot of non-obvious benefits that product engineers start to feel from the new way of working that make them want to stick with it.
Track factory adoption
To make sure the factory approach is working, you’ll want to track factory adoption and set goals around it. The simplest metric to start is percent of merged PRs that went through the factory. You’ll want to look at this in aggregate, but you should also find early factory users who enjoy the new workflow and celebrate them getting their factory usage percent as high as possible.
Engineer the factory
Once some work is flowing through the factory, you can start to focus on engineering the factory, making sure it’s improving over time. The key metrics here are factory throughput (PRs shipped), cycle time, and cost per PR. But you should also look at factory scoring metrics, where agents are rating how well the factory is delivering along certain dimensions like code quality, verbosity and anything else you might care about for your codebase.

Driving these metrics can become like a game. At Warp we are having fun tweaking our model mix and factory workflow to drive our cost per PR down. It’s gone from $71 → $20 in the last six weeks using a factory approach, with a lower revert rate and 40% higher PR throughput than in the last month. Folks on the team are suggesting experiments to improve further. As a startup founder who cares deeply about efficiency and burn, seeing us reduce costs while increasing velocity and quality is incredible.
The ultimate goal
My final thought is that when you hit bumps rolling out factories to always remind your team of the ultimate goal: to ship faster and deliver more value to customers. Factories are just a new tool that they, the engineering team, can use to get to this outcome.
At Warp our mission is to empower developers to ship better software more quickly and efficiently, and moving to the factory model is a major step in this direction. If you are exploring adopting a software factory approach, we would love to chat.

在本文中,我将给出一些具体策略,说明如何在组织内推广软件工厂。我所说的“软件工厂”,是指在云端运行、可度量并可持续改进的智能体循环。这里我将重点讨论人员与组织层面的变革,而非软件工厂赋能的技术层面。至于技术基础,我假设你使用的是类似软件工厂技术栈的基础设施。
要点速览
- 目标不是实现完全自动化,而是尽可能快速、高效地交付质量最高、对客户影响最大的软件。
- 从简单、低风险的软件工厂自动化开始:也就是工程师眼中的杂务。
- 让通过工厂进行直接提示,像在工程师已使用的工具中标记智能体一样简单。
- 不要将工厂定位为“产品”,而应定位为一个人人都开展“软件工厂工程”的基础设施平台。
- 鼓励但不强制使用,并庆祝已交付的工作,而非 token 消耗。
- 先跟踪采用率(通过工厂完成的已合并 PR 占比),再跟踪吞吐量、周期时间和单 PR 成本。
从目标出发
我们先从目标说起。目标不是实现完全自动化,而是在你的组织中充分发挥编码智能体的作用,从而尽可能快速、高效地交付质量最高、对客户影响最大的软件。你会希望通过仔细度量和调优工厂来证明自己正在做到这一点。我们称之为“软件工厂工程”。
一个重要前提:除非你的团队首先至少将一部分产品工程工作通过工厂而不是本地编码智能体来完成,否则就无法开展软件工厂工程。这意味着要把智能体集中到一个共享配置中,让团队可以共同优化。一旦工作开始通过工厂基础设施流转,你就有基准来度量和改进。
两种起步策略
我们内部在 Warp 以及和客户合作时,一直采用两种策略来启动。第一种是部署简单的软件工厂自动化。例如,Warp 自己的工厂会自动修复 Sentry 报告的服务器崩溃。它会自动分类处理新问题,这些问题都是我们在内部试用时遇到的。它会生成每周变更日志,并更新我们的公开文档。对于客户,我们也设置了类似的自动化,用于调查生产问题、分类处理用户反馈以及更多场景。
这些都是低风险任务,可以交给智能体自行完成。如果智能体做对了,那很好。如果没有,你可以忽略输出,也可以让人来修复(而如果你确实修复了,这会成为软件工厂工程的学习循环的重要输入,我稍后会讲到)。关键是先从简单任务开始,让一些任务运转起来,并帮助工程师熟悉软件工厂基础设施以及与软件工厂智能体交互。选择工程师视为杂务的任务,是立即展现价值的好策略。
从自动化入手,不会要求工程师大幅改变日常习惯;一个人就能为所有人设置自动化,整个团队都能从中获益。不过,理想情况下,整个团队都应响应这些自动化的输出,承担起审查其 PR 或生成问题的责任。关键是确保这些自动化具有良好的信噪比,并且自动化的任何结果都有明确的负责人。
因此,我不建议一开始就启用完整的智能体循环来修复积压工作或自动修复新问题。智能体很可能会生成永远没人审查的 PR,这会让工程团队对软件工厂模式产生反感(“这东西只会批量产出垃圾”)。从小处着手,专注于那些一开始输出就很可能正确的任务。让一支软件工厂推广大使团队负责设置这些自动化,并且在该团队把自动化调优到能够可靠地产出高质量工作之前,不要广泛推广工厂。
策略 2:让通过工厂的直接提示变得简单
第二种策略是让通过工厂进行直接提示尽可能简单,而不是在本地进行。在 Warp,我们已经完成了这一转变——大多数直接提示从 Slack 开始,然后在我们依赖的其他云工具(如 Linear 和 GitHub)中继续。我们的软件工厂基础设施支持这一点:你可以在一个工具中开始工作,然后在另一个工具中带着相同的上下文继续。
从与客户合作的经验中我们知道,这是一项重大的行为改变,需要深入思考如何推进。重要原则是在工程师现有的工作场所与他们对接。引入新的产品界面或工作流来输入工厂工作,会比允许工程师在已有工具中标记智能体产生更大的阻力。我们不建议新建一个“工厂 Web 门户”作为与工厂协作的主要场所。
相反,应让工厂可以从你的通讯平台(如 Slack 和 Teams)、问题跟踪工具(如 Jira 和 Linear)以及代码托管平台(如 GitHub 和 GitLab)访问。让通过工厂工作像在这些工具中标记智能体一样简单。确保它可靠、快速地运行,并确保智能体完成工作所需的所有权限和上下文都已设置好。再说一次,如果开发者尝试这些流程却发现行不通,就会迅速削弱对整个软件工厂模式的信心,使大家转而使用本地工具。
说到本地工具,你还会希望工厂能直接与本地编码智能体集成。如果工程团队混合使用 Claude Code、Codex、Pi 等工具,他们应当能够直接通过这些工具把工作提交到工厂;这意味着他们的本地提示不再发送给本地智能体,而是发送到一个软件工厂 MCP,由它将工作提交到云端循环。
你的工厂应当支持工作在软件生命周期的任何阶段进入:从最初的新工单或新想法,到规格已经存在之后,甚至到工程师已经起草了本地 PR 之后。再次强调,目标是尽可能简化工作提交,让更多工作通过云基础设施流转,并开始培养在工厂中工作的“肌肉记忆”,同时积累可供软件工厂工程改进的数据集。

将工厂定位为基础设施,而非产品
在设置早期自动化和直接提示时,你应确保团队不会在工厂出故障时陷入死胡同。开发者喜欢掌控自己的工具;他们希望能理解和调试问题,而不必等待他人协助。如果你将工厂视为整个团队共有的基础设施,这比把它视为只有管理员才能配置的 SaaS 产品更能吸引大多数开发者。
因此,不要把工厂定位为“产品”,而应定位为一个人人都应开展“软件工厂工程”的基础设施平台。软件工厂工程是让内部工厂变得更好的工作。它意味着改进驱动工程吞吐量的技能、模型和上下文。它意味着鼓励工程师为自己的杂务工作构建自动化。它意味着为他们提供工具,以便评分和对工厂工作流进行基准测试,并赋能他们使用智能体构建自我改进循环。它意味着每个人都要负责降低工厂成本、提升工厂投资回报率(ROI)。如果你使用像 Warp Factories 这样的平台,所有这些工具都是内置的,但在工具之外,“软件工厂工程”实际上是一种思维方式。
鼓励但不强制
假设你已经有了合适的基础设施,就需要激励团队开始使用它。我们在 Warp 的做法是:由领导层鼓励但不强制使用,并通过公开表扬、软件工厂排行榜(而非 token 排行榜)或展示出色工厂工作的共享 Slack 频道,来庆祝大家在工厂中工作。软件工厂排行榜应将成本纳入考量,并庆祝已交付的工作,而非 token 消耗。
对我们的团队来说,工程师一旦开始在公开渠道中工作,通常会对这种方式为何更好产生一个*顿悟*时刻。例如,当你在 Slack 中开始工作,你可以轻松地标记队友来征求意见,而所有上下文也都已就位。你可以从任何地方用手机继续这项工作。你可以搜索团队历史,并利用这些工作为下一个提示提供信息。产品工程师会从这种新的工作方式中感受到许多不那么显而易见的益处,从而愿意坚持下去。
跟踪软件工厂采用率
为了确保软件工厂模式奏效,你会希望跟踪软件工厂采用率并围绕它设定目标。最简单的起步指标是通过工厂完成的已合并 PR 占比。你会希望从总体上看这个指标,但也应找到喜欢新工作流的早期工厂用户,并表彰他们尽可能提高工厂使用率的做法。
对工厂进行工程化
一旦有一些工作开始通过工厂流转,你就可以开始专注于对工厂进行工程化,确保它随时间不断改进。这里的关键指标是工厂吞吐量(已交付 PR)、周期时间和单 PR 成本。但你还应关注软件工厂评分指标,其中智能体会按代码质量、冗长程度以及你可能关心的代码库其他方面,对工厂的交付表现进行评分。

推动这些指标可以变得像一场游戏。在 Warp,我们正乐在其中地调整模型组合和工厂工作流,以降低单 PR 成本。采用软件工厂模式后,过去六周里它从 $71 → $20,同时回滚率更低,PR 吞吐量比上个月高 40%。团队成员正在提议进一步改进的实验。作为一名高度重视效率和资金消耗的初创公司创始人,看到我们在提高速度和质量的同时降低成本,实在令人难以置信。
最终目标
我的最后一点想法是,当你在推广工厂的过程中遇到磕碰时,要始终提醒团队最终目标:更快交付,为客户带来更多价值。工厂只是工程团队可以用来实现这一结果的新工具。
在 Warp,我们的使命是赋能开发者更快、更高效地交付更好的软件,而转向软件工厂模式是实现这一目标的重要一步。如果你正在探索采用软件工厂模式,我们非常乐意与你交流。