Skip to content

§5.1 The Software Factory

Earlier in this book, I compared coding agents to 2D and 3D printers. The comparison was about fabricative technology: unlike a specific-purpose tool such as a stapler, a fabricator can realize a broad range of artifacts from a description of what should be made.

We can now expand that metaphor. A fabricator does not operate alone. Once fabrication becomes a means of production, it sits inside a larger system that determines what should be made, organizes how production proceeds, and determines whether what was produced is acceptable. The printer becomes one piece of the factory.

Factories developed to make production repeatable at scales that craft production could not support. Interchangeable parts allowed components made separately to participate in the same product. Mechanization increased the amount of work that machinery could perform. Machine tools increased precision and repeatability. Each advance also exposed a problem. Faster machinery could produce defects faster than people could inspect them; a design was of little use if the available machinery could not realize it accurately; interchangeable parts were not interchangeable if different shops produced incompatible dimensions. Scaling fabrication therefore required engineering the production system around the fabricator.

Software engineering has already made much of this move. Continuous integration and delivery organize building, testing, and deployment into repeatable processes, with automated checks governing what may proceed 1.1. Jez Humble and David Farley, Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Professional, 2010), https://www.informit.com/store/continuous-delivery-reliable-software-releases-through-9780321601919. Coding agents extend automation into the production of the changes themselves. The factory must now govern not only how software is built and delivered, but also how implementation decisions are delegated, what system knowledge informs them, and what evidence justifies accepting the result.

Two ideas from manufacturing help explain what this expanded software factory must do:

  • Process design determines how production proceeds. Work is decomposed and sequenced; responsibilities, machinery, and information are arranged; measurements and decision points occur at selected stages. The process carries knowledge about how production should occur rather than requiring each fabricator to reconstruct it. Scientific management made this separation explicit by moving planning, work methods, instructions, and standards into a deliberately designed production system 2.2. Frederick Winslow Taylor, The Principles of Scientific Management (Harper & Brothers, 1911).
  • Tolerance states which variation in the product is acceptable. A drawing can specify a dimension and its allowable variation without prescribing every motion of the machinist or every property of the finished part. Gauges and metrology then establish whether selected properties of the realized part fall within those bounds. The factory can therefore leave substantial freedom to the fabricator while retaining control over the properties that matter 3.3. Simon Winchester, The Perfectionists: How Precision Engineers Created the Modern World (Harper, 2018).

As §3.3 showed, measurement can establish not only whether a realization satisfies a tolerance but, for quantitative properties, how much margin remains. That evidence can inform the next engineering decision without prescribing how the fabricator must work.

Two problems of factory engineering Process design organizes engineering intent, context and work, the fabricator, and realization. Measurement evaluates possible realizations against tolerance. The acceptable region contains permitted variation; an inside point leads to admitted change and an outside point to revision or rejection. Its structure matches the probability-in-the-factory figure. SOFTWARE FACTORY PROCESS DESIGN: how production proceeds PRODUCTION PROCESS Engineering intent Context / work Fabricator Realization Context; tools; routing; authority; sequencing what process design determines Measurement: tests, PBT, analysis, simulation, human judgment POSSIBLE REALIZATIONS Acceptable region TOLERANCE acceptable product variation within tolerance outside tolerance Admitted change Revise / reject
Figure 5.1-1. Two problems of factory engineering. Process design determines how production proceeds around the fabricator. Tolerance identifies acceptable variation in what the factory produces; measurement establishes whether a realization remains within those bounds. The two concerns are complementary: a production system may carry engineering knowledge in the organization of production, in explicit bounds on the resulting product, or in both.

Watt's improved steam engine shows why production capability and product tolerance must develop together. Its design required cylinders more accurately bored than ordinary eighteenth-century production could reliably make; Wilkinson's precision boring machinery made cylinders sufficiently true for the engine to perform as intended. The advance was therefore more than a faster way to make an existing artifact. A more capable production system made a different artifact practical.

5.1.1 What Does a Software Factory Produce?

The analogy requires one adjustment before we apply it to software. A physical factory commonly produces many instances of a product. Software usually does not. Another copy of a program may cost almost nothing, while a software service may consist of one continuously evolving system serving millions of users.

The output of a software factory is the next working realization of the product. Software organizations repeatedly change an existing system: adding features, repairing defects, adapting to new environments, migrating dependencies, changing architectures, and responding to new requirements. Each production cycle begins with a working software system and attempts to produce a changed system that still works.

The factory's job is to realize controlled change: creating and evolving software while preserving sufficient control over the properties and consequences that matter 4.4. James C. Davis, The Software Engineering Handbook: A Judgment and Decision-Making Approach, 1st ed. (2026), https://davisjam.github.io/model-based-agentic-software-engineering/book/se-handbook/index.html. A software factory is the production system through which that change occurs.

Software factory. The engineered production system through which software changes are realized from engineering intent and evaluated, admitted, deployed, and improved.

A software factory contains more than its fabricators. Models describe the product: architecture descriptions, service graphs, and the properties a change must preserve. Tools work on it: linters, test harnesses, validators, and analyzers. Controls bound what may be done and accepted through permissions, admission gates, and enforced policies. An agent can run a test and reason about its result. The test supplies evidence; a gate enforces a condition by requiring a passing result before admission. A failed test that is only reported leaves a different choice to the agent or reviewer. Fabricators build the product from models, using tools, subject to controls.

The governed engineering environment developed in Chapters 2–4 is part of this larger factory. It comprises the reusable representations, tools, procedures, and controls through which engineering work is directed and governed. The factory also includes the people and agents doing the work, the production activities they perform, and the organizational arrangements that determine what work is undertaken and who has authority over its consequences.

Process design organizes how changes are produced; tolerance determines which resulting changes are acceptable. Unlike a factory producing repeated copies of a fixed design, a software factory must preserve consequential properties while changing the system itself.

That task carries a cost that physical manufacturing can often amortize differently. A drawing for a manufactured part can remain useful across thousands of instances of that part. A representation of a software system describes a target that is itself being changed. Requirements, architecture descriptions, interface specifications, models, tests, and other engineering artifacts therefore incur a carrying cost: as the software changes, they may also have to change if they are to remain useful representations of it.

Software organizations have made different economic judgments about that cost. Some have found enough durable value in explicit models, specifications, interface definitions, and other representations to justify creating and maintaining them; others have found it cheaper to keep skilled human engineers close to implementation, where they can resolve open questions about behavior, structure, interfaces, failure handling, and performance as the software changes 5.5. Oliver Kautz et al., “Achievements, Failures, and the Future of Model-Based Software Engineering,” in The Essence of Software Engineering, ed. Volker Gruhn and Rüdiger Striemer (Springer, 2018), https://doi.org/10.1007/978-3-319-73897-0_13. Neither choice is intrinsically irrational. The tradeoff depends on how much reusable engineering knowledge a representation carries, how expensive that knowledge would be to reconstruct during implementation, and how expensive the representation is to keep accurate.

The Agile movement placed greater weight on keeping knowledgeable engineers close to implementation 66. Kent Beck et al., “Manifesto for Agile Software Development,” 2001, https://agilemanifesto.org/. 7.7. Ken Schwaber and Jeff Sutherland, “The Scrum Guide: The Definitive Guide to Scrum: The Rules of the Game,” 2020, https://scrumguides.org/. Working software became the primary measure of progress; changing requirements were expected rather than exceptional; close collaboration was preferred to elaborate handoffs; and documentation was valuable insofar as it continued to serve the work. These choices make particular sense when the object of engineering is controlled change. A representation that does not change with the software can cease to describe the thing it is meant to govern. Keeping knowledgeable humans close to implementation accepts repeated human judgment partly in exchange for avoiding representations whose carrying cost may exceed their continuing value.

Earlier attempts to separate engineering judgment from implementation encountered the same tradeoff from the other direction. Moving decisions upstream could allow implementation to be performed by less experienced programmers, but only if sufficiently detailed requirements, architecture, interfaces, or models carried the judgment that those programmers would otherwise need to supply. Producing those representations required skilled engineering labor, and maintaining them as the software changed added further cost. Leave more decisions open, however, and the organization again needed skilled human fabricators capable of resolving them during implementation.

The economic question was where engineering judgment could be carried most economically without losing control. Craft production remains economical when transferring enough judgment out of fabrication would cost as much as leaving that judgment with the skilled human fabricator. Factory production becomes economical when reusable production structures can carry consequential judgment more cheaply than repeatedly exercising it during fabrication.

Commodity intelligence changes this tradeoff. In an agentic software factory, inexpensive agents can perform substantial realization work and resolve many ordinary implementation decisions. The production system can carry selected consequential judgments while leaving the agent substantial realization freedom, subject to the evidence required for acceptance.

5.1.2 Walking Through a Software Factory

Four questions orient a walkthrough without prescribing how the factory should be organized:

  1. What does the factory produce? What changes enter it, and where do they originate?
  1. What do people do? Which judgments and acts of realization do people retain or delegate?
  1. How is production organized? How does work move through realization, evaluation, admission, and deployment, and how do lessons change that process?
  1. What are the tolerances? Which properties must remain within bounds, how are those bounds represented, and what evidence establishes compliance?

Software tolerances include quantitative bounds, invariants, architectural constraints, and qualitative obligations that may still require human judgment; each identifies variation the factory must control while leaving other choices open.

These questions can be answered at different levels of detail. A longitudinal account can show how a factory’s arrangements developed, which problems prompted changes, and what the resulting machinery accomplished. Reports from established organizations can show how factories differ in their allocation of work, authority, and control, although they rarely expose the same development history. DocAble provides the first perspective; the industrial accounts provide the second.

Works Cited

  1. Humble, Jez, and David Farley. Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation. Addison-Wesley Professional, 2010. https://www.informit.com/store/continuous-delivery-reliable-software-releases-through-9780321601919.
  2. Taylor, Frederick Winslow. The Principles of Scientific Management. Harper & Brothers, 1911.
  3. Winchester, Simon. The Perfectionists: How Precision Engineers Created the Modern World. Harper, 2018.
  4. Davis, James C. The Software Engineering Handbook: A Judgment and Decision-Making Approach. 1st ed. 2026. https://davisjam.github.io/model-based-agentic-software-engineering/book/se-handbook/index.html.
  5. Kautz, Oliver, Alexander Roth, and Bernhard Rumpe. “Achievements, Failures, and the Future of Model-Based Software Engineering.” In The Essence of Software Engineering, edited by Volker Gruhn and Rüdiger Striemer. Springer, 2018. https://doi.org/10.1007/978-3-319-73897-0_13.
  6. Beck, Kent, Mike Beedle, Arie van Bennekum, et al. “Manifesto for Agile Software Development.” 2001. https://agilemanifesto.org/.
  7. Schwaber, Ken, and Jeff Sutherland. “The Scrum Guide: The Definitive Guide to Scrum: The Rules of the Game.” 2020. https://scrumguides.org/.
© James C. Davis, 2026–present