Coding agents are changing the economics of software development. When implementation gets cheaper, companies have every reason to hand more of it to autonomous systems. But most engineering orgs aren’t doing that yet, and the reason isn’t capability, but trust. Nobody deploys code just because it was produced fast; they need to know it works, that it’s secure, and that someone can maintain it six months from now.

This talk looks at a new pattern emerging in response: the software factory. Instead of treating development as one big act of implementation, it breaks the process into distinct, checkable stages: specification, implementation, testing, review, deployment, observation, remediation. Each one is a place where a human or system can step in before work moves forward.

That decomposition is what makes trust possible at scale. Teams don’t have to choose between full autonomy and no autonomy. They can grant it stage by stage, at whatever level their risk tolerance allows.

The bigger story is what this does to the shape of software engineering itself. As implementation gets automated and the process around it gets more systematic, we’re watching the field shift from craftsmanship toward industrial production.

Takeaways Attendees will learn:

• Why the economics of coding agents make broader adoption a matter of when, not if
• Why trust rather than capability is the bottleneck holding companies back from giving agents more autonomy
• What a software factory is: a way to extend automation past writing code into specification, validation, deployment, and remediation
• How breaking development into smaller stages lets organizations set their own bar for oversight
• How software engineering is moving from craftsmanship to an industrialized process