From craft to mass production: Software as an industrial system

For a long time, writing software felt like a creative act, much like composing music or shaping clay. That feeling was real. But software development is no longer the sum of those moments. It is a production system in which creativity occupies only a small fraction of total lead time.

For most businesses, software development is not defined by the act of writing code. It is a multi-stage production system that spans planning, coordination, execution, verification, integration, and release. Code is one station on a factory floor. An important one, but no longer the bottleneck.

The craft myth breaks

This is not the first time work has gone through a transition like this.

In early-19th-century London, factories were filled with highly skilled machinists operating lathes by hand. Every screw, shaft, and fitting was cut individually. Parts fit because craftsmen made them fit, and throughput depended on experience, dexterity, and judgment. Early factories did not replace craft so much as concentrate it under one roof. Production was slow, variable, and ultimately bounded by human effort.

Henry Maudslay changed that. By building precision screw-cutting lathes and, later, machines that could produce other machines, he shifted the bottleneck. Accuracy moved from the worker’s hands into the tooling itself. Parts became repeatable, and throughput increased dramatically. Craft did not disappear, but it moved. Skilled workers stopped shaping every part and instead designed machines, calibrated tools, and inspected output. Humans ceased to be the rate-limiting step and became the force that shaped the system.

Software is at the same inflection point.

We still talk about software as craft and build identities around clean code, elegant abstractions, and clever designs. Those skills still matter, but they no longer determine throughput. They shape quality, not capacity.

For any economic endeavor that produces software, code creation has always been a small fraction of total lead time. Most time is spent elsewhere: deciding what to do, coordinating work, validating correctness, integrating changes, and releasing safely.

With AI, the most craft-heavy stations are becoming automated. Code generation is the most visible example. As those stations accelerate, throughput shifts elsewhere. Craft no longer sets the pace of production. It sets the boundaries of correctness and trust.

The real factory floor

Once craft stops being the constraint, the shape of the system becomes hard to ignore.

Modern software production looks less like a workshop and more like a factory with shared machinery. Software development is a flow system. What we call the Software Development Life Cycle is simply its formal description.

Work enters as an idea, turns into a plan, becomes code, gets reviewed and tested, lands in production, and is then watched closely to make sure it behaves as expected.

This is not a new process. It is the SDLC, seen not as a set of roles or rituals, but as a production line. Whether we acknowledge it or not, this is the system we are running. Unlike physical manufacturing, almost every software product runs through these same stations. The work differs, but the factory does not.

AI shifts the bottleneck

AI dramatically accelerates the code generation station. When one station speeds up by an order of magnitude and the rest do not, inventory piles up.

In software, inventory is work in progress: pull requests waiting for review, unmerged branches, unreleased features, untested changes. Most teams recognize this immediately. It shows up as growing backlogs, review queues that never clear, flaky CI, and releases that keep slipping.

Every manufacturing system learns this lesson the hard way. Local optimization makes global throughput worse. Software is now being forced to learn it.

Throughput beats talent

You cannot fix this by adding better agents alone. When production is the constraint, brilliance does not save you. Balance does.

What’s needed is a system that spans the entire factory floor, one that integrates generation, execution, verification, review, and release into a coherent flow. Optimizing a single station in isolation only pushes the problem downstream.

A pull request tool that ignores how code is actually reviewed. An agent that generates code without running it in a realistic environment. A CI system detached from how work is planned and released. Each makes its own station faster while slowing the system as a whole.

What matters instead is flow efficiency: short feedback loops, minimal inventory, fast integration, predictable release. Just-in-time manufacturing lessons apply directly. Work sitting around is expensive, even if it was cheap to create.

Cheap progress is not the same as value. It is easy to do the first 80% when execution is cheap. The last 20%—verification, integration, release—is where value is created. Until work runs all the way through the system and reaches production, it is inventory, not output.

The organizations that win next will not write the most code. They will move ideas through the system with the least friction.

Humans shift from production to intent and judgment

As code becomes abundant, the role of humans changes. Not because humans disappear, but because the work that creates leverage moves.

AI is good at searching solution spaces. It is not good at deciding which problems matter, what trade-offs are acceptable, or when something is correct enough to ship. Those decisions remain human, and they become more important as execution gets cheaper.

The human role shifts from producing artifacts to specifying intent, defining constraints, and validating outcomes. Less construction. More judgment.

This is not new. In every industrial transition, machines took over execution and humans moved upstream. Design, quality, purpose, and acceptance became the human domain. Software is following the same path. Code is no longer the primary output of human effort. Correctness is. Direction is. Knowing what not to build is.

Efficiency scales human progress

Every major increase in human prosperity came from production efficiency. Not from working harder, but from producing more with less. The Industrial Revolution did not devalue craftsmanship. It made goods abundant, cheaper, and more accessible.

Software is about to follow the same curve.

When software production becomes industrial, software stops being scarce. More problems get solved. Smaller teams build larger systems. Capabilities once reserved for large organizations become available to many.

This is not about replacing engineers. It is about compounding leverage. Software already eats the world. Industrialized software feeds it.

Lower cost software means better healthcare systems, better infrastructure, better education tools, and coordination that was previously unaffordable. The gains do not stay inside engineering teams. They spill outward.

That is the real shift. Not an identity crisis, but an efficiency dividend. One we have seen before. One that, historically, has benefited humanity far more than any romantic attachment to how work used to feel.