Build the thing that builds the product

In a couple of years, building software with AI has gone from autocomplete and chat to interactive agents: you sit at your computer, describe a change, watch an agent make it and steer it when it drifts. The next step is already visible. The work moves out of your terminal and into a pipeline that runs on its own, with people stepping in only where they add something.

That changes what software engineering is. When agents write most of the code, the engineer's job becomes building and running the system that produces it. Software engineering starts to look a lot like factory engineering.

The loop every project will run

Strip away the tooling and a software factory is just the development life cycle, automated. Ideas come in. An agent triages them. If the work is simple and unambiguous, it goes straight to implementation; if it is hard, an agent writes a spec first. An agent implements the change, review happens, the result is verified, it ships, and monitoring watches what happened. What monitoring sees becomes the next idea, and round it goes.

The interesting part is where people sit in that loop. Not everywhere, and not nowhere: at the spec, where intent gets decided; at review, where risk gets judged; and at the product check, where someone asks whether it actually works the way a user expects. Everything between those points can run without you.

Expect this to become as ordinary as CI/CD. Nobody asks any more whether a serious project has automated builds and tests. In a few years, nobody will ask whether it has a factory either.

What's on the factory floor

Each station is simpler than it sounds, and each one is worth getting right on its own.

• Inputs. Work arrives from your task tracker, team chat, your terminal or editor, and your monitoring. Decide which channels feed the factory, so ideas don't get lost in a thread.
• Triage. This is the easiest place to start. An agent reads each new issue and asks one question: is this small and unambiguous? If yes, it builds it. If not, it sends it to the spec station.
• Specs. Two documents work well. A product spec describes the behaviour you're building towards, the things that must stay true. A tech spec describes the architecture and the shape of the code. A person reviews both before anything gets built.
• Implementation. A coding agent works in a sandbox in the cloud and produces a diff. Which agent or model you use matters less than giving it the right context.
• Review. The most tiring part of working with agents today. Let an agent review first, then treat human review as risk management: decide which changes need a person and which don't.
• Verification. For anything with an interface, have an agent actually use the result, clicking through it and recording screenshots and video, alongside the usual tests.
• Monitoring. Agents shouldn't stop at the merge. Is the change crashing? Is anyone using it? Those answers go back to the top of the loop.

Under the floor

A simple version of this is easy to build: a few scheduled agents and some glue. A version that scales is a product in its own right, and for most teams that effort is better spent on their own product. Whether you build or buy, the shape ends up the same.

Work comes in from the channels at the top. A control plane decides what runs where and in what order. The execution layer is where agents work: sandboxes, the harness around the agent, and the model inside it. Underneath sits the layer most people forget, a data plane that records what agents did and what happened next, so the factory can remember and learn instead of starting from zero on every task.

Measure the line, then improve it

A factory is a mindset as much as a system, and the mindset is efficiency. How much useful software did you ship? What did it cost, in people's time and in tokens? Measure both, and look for where work gets stuck.

The tool for improving it is the loop. Loops sound complicated, but the idea is simple: one agent does the work, and another watches how that work goes and improves the instructions for next time.

Take code review. A review agent applies a review skill and leaves comments. Senior engineers correct some of them, dismissing a false alarm here, adding a missed problem there. An observer agent reads those corrections and updates the skill. The next review is better, and nobody had to sit down and rewrite a prompt.

When building gets cheap, product isn't enough

There's a business side to this. If software gets cheap to build, it also gets cheap to copy. A great product has always mattered, but it has rarely been enough, and it is even less so now. The advantages that last sit around the product: distribution, an ecosystem, a brand, data, capital.

Startups rarely have those, which is why building in the open is attractive. An open project gathers a community and an ecosystem that a competitor can't simply clone. Until recently the cost was the flood that comes with it: noisy issues, sloppy pull requests, endless review and verification. Those are exactly the jobs a factory takes on. Triage, review and verification agents make an open project far cheaper to maintain, and they help contributors contribute as much as they help maintainers.

What's left for engineers

You will write less code. If your joy is in typing code, that is a real loss. If your joy is in shipping things people use, it has never been a better time: you build the thing that builds the product, and that's a hard, interesting engineering problem in its own right. Call it meta-engineering: designing a system of agents that is as good as possible at engineering.

The skills that matter shift with it. Adaptability and how fast you learn. Critical thinking. A real understanding of systems and architecture, because someone still has to judge the specs and the code agents produce.

And taste matters more than ever. The factory metaphor can sound mechanical, but a factory that efficiently produces things nobody wants is pointless. The decisions that count are still human ones: what customers need, what's worth building, and what good looks like at each point where a person steps in. Build the factory, but keep your hands on those.