Software engineers will increasingly build and manage automated factories that move work from ideas through triage, specification, implementation, review, verification, and monitoring.
2
Warp open-sourced after five years of closed development because a public project can build an ecosystem, while automation can reduce the maintenance cost of noisy issues and poor pull requests.
3
Engineers will write less code but may ship more product, provided they keep human judgment in the places where automation cannot decide what is useful.
Summary
Zach Lloyd argues that software development is moving from interactive AI assistance toward automated software factories. In his model, ideas enter through task trackers, communication tools, development environments, or monitoring systems. Agents triage the work, write product and technical specifications for difficult tasks, implement changes, review code, verify behavior, and monitor shipped software. Humans review specifications, code, and product behavior at selected points. Lloyd connects this model to Warp's decision to open source after five years of closed development. Software is becoming cheaper to build and easier to clone, so companies need advantages beyond the product itself. Building in public can create community and an ecosystem. The factory also needs a data layer, measurement, and loops that improve agent skills over time. Lloyd expects engineers to write less code, while spending more time designing and tuning the system that builds the product. He is clear that human product sense still decides what is worth building.
Software development is moving from interactive agents toward automation
Lloyd describes a recent shift from chat and autocomplete tools such as Cursor and Copilot to interactive agents such as Claude Code and Warp. He expects the next phase to involve more automation, although he cannot predict the exact pace. In that model, engineers will not simply ask an agent to perform one task at a time. They will build systems that move work through much of the software development life cycle. The change matters because the engineer's job shifts toward designing and managing those systems.
A software factory routes work through agents and human review
Lloyd's factory is a loop. Ideas enter, agents triage them, and difficult work receives a specification. Humans review the specification. Agents implement the change, humans and agents review the code, agents verify the result, and a human reviews the product before shipment. Monitoring then feeds information back into the beginning of the loop. The human checkpoints are deliberate. They are places where judgment is still needed, rather than steps that the system treats as fully automatic.
Open source gives Warp an ecosystem around a product that is easier to copy
Warp spent five years building as a closed company before opening its source. Lloyd says software is becoming cheaper to build and trivial to clone, which makes it harder for a company to capture value from a product alone. Startups may lack advantages such as distribution, capital, brand, or a data moat. Building in public can create a community and ecosystem around the product, and can improve the company's reputation. Warp built build.warp.dev to show issues moving through its public project, including the agents and contributors working on them.
Automation can reduce the maintenance cost of an open-source project
Traditional open-source work can produce noisy issues, poor pull requests, long code reviews, and a large verification burden. Lloyd says Warp decided to open source after building automations around these problems. The factory can help contributors make changes and help maintainers handle incoming work. The same approach applies beyond open source. Lloyd expects every sizable company and project to develop a software factory in the way that CI/CD became a normal part of software development.
The factory needs inputs, triage, specifications, implementation, review, verification, and monitoring
Work can enter from a task tracker, Slack or another communication channel, a terminal or IDE, or monitoring systems. An agent can implement easy and unambiguous issues directly. For harder issues, Lloyd recommends specification-driven development. Warp uses a product spec to describe the product invariants and a technical spec to describe the architecture and code shape. A cloud coding agent then produces a diff. Agents can perform the first code review, while humans review where the risk requires it. Verification can include CI/CD and computer use, such as generating screenshots or videos for a user interface. Monitoring checks whether shipped code crashes or is being used, then sends that information back into the factory.
A scalable factory has a control plane, cloud workspaces, and a data layer
Lloyd says teams can build a simple factory, but building infrastructure that scales may distract from the company's product. Whether a team builds or buys the system, the result will include ways to bring work in, a control plane that distributes work across the factory, and cloud sandboxes where agents run. Teams will also choose the agent harness and model. Underneath these pieces, a data plane lets agents remember what they have done, learn from past work, and improve over time.
Factories improve through measurement and skill loops
Lloyd treats the factory as an operating system that needs measurement and adjustment. Teams should track how much software they ship and the human time and token time it costs. A skill loop can improve the agents themselves. For example, an observer agent can watch a code review agent's comments and compare them with the corrections made by a senior engineer. It can then improve the review skill for the next run. This creates a feedback process around the factory rather than treating its agents as fixed tools.
Engineers will write less code while human product judgment remains necessary
Lloyd expects software engineers to spend less time writing code and more time building the system that builds the product. He compares this work with process engineering and manufacturing, while describing the design of agent systems as a form of meta-engineering. He says the trade-off depends on what an engineer enjoys: people who value writing code may be disappointed, while people who value shipping product may ship more. In the questions, he adds that adaptability, critical thinking, fast learning, system knowledge, and the ability to understand code and specifications will matter. Human taste and product sense still decide whether the factory is making something people want.
"Every company, every open source project will have at its core a software factory, kind of like the way that CI/CD became just like, oh, of course you have that."08:48
Who should watch
You are deciding how to introduce coding agents into a team and need a model for connecting them to specifications, review, testing, and monitoring.
You maintain an open-source project and want to understand Lloyd's case for using automation to handle incoming issues and contributions.
You are a software engineer thinking about how your work changes when agents handle more implementation and your time moves toward system design and product decisions.
