Skip to content

§7.2 Back to Models, but Not Back to Waterfall

MAGE asks engineers to invest deliberately in models, specifications, and controls while delegating more implementation to agents. Does that mean software engineering is returning to waterfall: specifying the system in advance, then handing the specification to a fabricator? The resemblance is understandable. Much of software engineering's history has involved moving away from the expectation that a sufficiently complete design could precede implementation. Yet the iterative development examined in Chapter 4 showed the opposite of a fixed handoff: implementation exposed missing knowledge, models were revised, and recurring failures changed the engineering environment inherited by later work.

The distinction is between working through models and requiring models to settle the implementation before work begins. Engineers have long used representations to make consequential decisions without expecting those representations to describe every detail of the finished artifact. Software engineering developed a different balance because code itself served as an unusually powerful representation and because maintaining additional models imposed costs. Commodity intelligence changes those costs. To understand what MAGE changes, and what it inherits, we need to examine why software engineering historically organized representation and implementation differently from other engineering disciplines.

7.2.1 Engineering Through Representations

The account of Modeling in Chapter 2 belongs to a much older engineering practice. Civil, mechanical, electrical, aerospace, and systems engineers work through load models, schematics, state-space models, simulations, drawings, and analyses.

Models are the building blocks of engineering.** Here I mean model in the broad sense developed in Chapter 2: a purposeful reduction that preserves distinctions needed for some question. The claim is close to axiomatic under this book's definition of Engineering. A consequential system sufficiently simple to understand and direct without reasoning through reduced representations does not present the complexity for which engineering, in this sense, is required. A circuit schematic is not a circuit; a finite-element model is not a bridge; a process-flow diagram is not a refinery. The representation is useful because it leaves most of reality out.

Physical engineering makes the separation vivid. Fabrication can be expensive or irreversible, full-scale trials can be destructive, and physical iteration can take weeks or months. A structural model answers a loading question before concrete is poured. Circuit simulation exposes a design error before a mask set is fabricated. Realization cost makes the gap between representation and artifact obvious.

The common engineering move is simple: ask the question over the cheapest representation that preserves the property you care about, then use evidence to justify realization. Mature engineering still uses prototypes, experiments, and direct inspection. Models do not replace the artifact. They organize the reasoning around it.

Software engineering already combines explicit obligations with rapid iteration. Test-driven development, for example, states an expected behavior in a test before implementing it, then revises the implementation through repeated test–code–refactor cycles 1.1. Kent Beck, Test-Driven Development: By Example (Addison-Wesley Professional, 2003). Specifying an obligation before implementing it is not the same as specifying the entire system before development begins. Likewise, agile methods do not dispense with planning. They favor delivering useful results early, learning from them, and revising subsequent plans as evidence accumulates 2.2. Kent Beck et al., “Principles behind the Agile Manifesto,” 2001, https://agilemanifesto.org/principles.html.

Software makes the same move through its own traditions. Requirements engineering externalizes obligations. Architecture exposes consequential structural relationships. Type systems and intermediate representations make selected program properties explicit. Formal methods construct representations over which stronger claims can be established. Model-driven and model-based approaches go further and make selected models primary engineering artifacts. These traditions differ substantially, and they share one move: represent the property at a level where it can be reasoned about.

The medium varies; the purpose does not. The analysis serves a decision. Salado makes this point directly by treating engineering as disciplined decision-making under uncertainty and competing objectives, rather than technical problem solving alone 3.3. Alejandro Salado, Rethink Engineering: Revolutionize the Way You Make Decisions (Educating Thinkers Press, 2026). Engineers model, calculate, measure, and experiment because consequential choices must be made: which design to pursue, what evidence to gather, which tradeoff to accept, or whether the resulting system is fit to proceed. A model earns its place when it stands in service of such a decision. MAGE shares that emphasis, and asks what happens when much of the work downstream of those decisions can be delegated to commodity intelligence.

7.2.2 Why Software Often Modeled Differently

Software engineering did not reject models in favor of iteration. Its economics made implementation itself an unusually attractive surface for engineering reasoning.

Software realization was extraordinarily cheap; detailed design and implementation labor were not. Once source code existed, another compilation, execution, or copy of the program could usually be produced at negligible marginal cost. Producing, understanding, debugging, and changing that source consumed skilled engineering labor. The source was already a precise, executable representation through which engineers reasoned about the system.

That blurred a distinction the older disciplines could make more cleanly. A structural engineer reasons through a design before concrete is poured; a semiconductor designer simulates a circuit before fabrication. In software, the artifact handed to the cheap realizing mechanism, the compiler, is itself the product of an iterative design process. Reeves made the strongest version of this argument by calling source code the final software design. MAGE does not require that full claim. It requires only the narrower one: software design and implementation have historically been tightly coupled, and code has served simultaneously as realization, executable specification, and a primary surface for further reasoning.†† Jack W. Reeves's "code is design" argument 44. Jack W. Reeves, “What Is Software Design?” C++ Journal, 1992, https://www.developerdotstar.com/mag/articles/reeves_design.html. is a useful historical extreme; MAGE relies only on the narrower claim that software design and implementation have traditionally been tightly coupled.

Code's malleability then works against the engineer as a system evolves. Architecture, intent, constraints, and operational knowledge can stay implicit in an artifact whose structure keeps changing, and the system stays executable long after the knowledge needed to govern it has become hard to recover. The disciplines named in the previous section exist partly to hold that knowledge where continual change cannot quietly erase it.

Those secondary models faced an unusual economic test. The implementation was already precise, executable, and immediately available, while an architectural, behavioral, or process model imposed an additional correspondence burden. A model could be useful when authored and misleading after the implementation moved beyond the relation it claimed. Many projects therefore kept such representations thin unless their communication, reasoning, or assurance value repaid that standing synchronization cost.

Commodity intelligence changes both sides of that ledger. It lowers the skilled labor required to realize and revise software, and parts of the labor required to derive, update, reconcile, and check additional representations. Implementation and live modeling can become cheaper together, making model-mediated software engineering economical over surfaces where the synchronization tax once exceeded its return. The construction and carrying costs examined in §6.3 still determine where that investment pays.

Lower construction and maintenance costs can make additional representations worthwhile without determining which should become primary. The alternatives in §7.1 remain open: maintain a model, derive a view when needed, or reason directly over implementation. The choice depends on the engineering question, the value of the representation, and the cost of keeping its claimed correspondence trustworthy.

Implementation remains an important source of truth, and some properties are most naturally reasoned about there. A useful representation need not become authoritative. What changes is that code need no longer bear the whole burden of being the realization, the repository of system knowledge, and the surface over which engineering reasoning occurs.

7.2.3 Model-First Engineering as One Point in the Design Space

Model-first engineering occupies one end of the representational design space: sufficiently complete models determine much of the realization that follows.

The Siemens reconstruction demonstrates one such equilibrium in a mature engineering culture. The public account describes persistent models carrying geometry, requirements, behavior, physical relationships, allowable change, and traceability before an agent enters the picture. Software can appear downstream as one realization among others. The agentic question is therefore not how to recover engineering structure from source code, but how to let autonomous tools operate safely through structure the organization already made explicit.

Model-first engineering does not, by itself, imply waterfall. A model can be revised after a prototype, simulation, test, or deployment exposes a mistaken assumption. The distinction concerns how much engineering intent the representation determines, not whether development proceeds through a single pass. In a model-first system, a sufficiently complete representation may support deterministic generation of much of the implementation; in MAGE, the representation may instead preserve selected obligations while leaving substantial implementation freedom to an agent. Both arrangements can be iterative. What differs is how much the engineer chooses to settle before a particular act of realization.

That inversion clarifies MAGE's position. Software-first agent systems largely ask, How do we make a codebase legible to an agent? A model-first discipline can ask, How do we let the agent work through the same engineering representations we already trust?

Degrees of freedom locate MAGE along this axis. A sufficiently complete model can determine realization closely enough that transformation, generation, or synthesis is the natural next step. MAGE includes that case, but does not require it. Its models can instead specify the obligations that matter and the tolerances those obligations permit while deliberately leaving other realization choices open. Those degrees of freedom are not defects in the model; they are choices engineers have no reason to settle in advance. Where tolerances become narrow and little consequential freedom remains, deterministic generation may be preferable. Where substantial freedom remains, autonomous realization can choose among acceptable implementations.

Cabot's vibe-driven model-based engineering proposes a contemporary software route toward the same end of the space, placing agents downstream of models much as a model-first engineering culture already does 5.5. Jordi Cabot, Vibe-Driven Model-Based Engineering, arXiv preprint arXiv:2604.10645, 2026, https://arxiv.org/abs/2604.10645. §7.1 weighed that proposal as one plausible equilibrium among several. What it adds here is the observation that the software proposal and the systems-engineering practice describe one arrangement approached from two directions.

MAGE includes this organization but does not privilege it. Which representations become primary is an empirical question about where the new prices land. A discipline may settle at different points for different systems, or for different properties of the same system.

7.2.4 Established Traditions, New Composition

MAGE combines two established lines of work around delegated realization. Engineering disciplines developed ways to represent systems, justify consequential claims, and control realization. AI developed ways to extend reasoners through external representations, memory, and tools. Figure 7.2-1 shows how these contributions meet in an agentic production system.

Established traditions, new composition Engineering and AI traditions feed MAGE. Modeling makes knowledge explicit and Alignment enforces selected obligations. Both contribute to a governed engineering environment that contains engineering capital. Subsequent work inherits that capital, with trustworthy autonomy as the intended outcome. ENGINEERING TRADITIONS AI TRADITIONS MBSE / MDE explicit models PL / compilers Types · DSLs Knowledge representation explicit knowledge Memory · planning state external state Formal methods specs; verification Systems / safety boundaries; control Structured reasoning intermediate structure Tools · interfaces reasoner support MAGE New economics → new composition Modeling make knowledge explicit Alignment enforce selected obligations Governed engineering environment representations · tools · procedures · evidence · constraints · controls where both traditions meet Engineering capital recurring judgment, made durable inherited by subsequent work Trustworthy autonomy intended outcome
Figure 7.2-1. Established traditions, new composition. MAGE draws on two long-running traditions. Engineering disciplines developed explicit models, constrained representations, verification, and external control; AI repeatedly extended reasoners through knowledge representation, planning state, memory, structured reasoning, tools, and surrounding machinery. MAGE brings these inheritances together around autonomous software work: Modeling makes engineering knowledge explicit, Alignment enforces selected obligations independently, and both meet in the Governed Engineering Environment. Governance conversion carries recurring judgment into durable engineering capital within that environment.

Engineering supplies the first inheritance. Across its disciplines it externalized consequential knowledge into representations, constrained realization against those representations, established evidence that the constraints held, and controlled the transitions that carry consequence: a release, a certification, a change to a system already in service.

AI supplies the second. Its long history of improving reasoners runs substantially through structure placed outside the reasoner: knowledge representations holding what the system knows, planning state and memory holding what it is doing, tools and interfaces extending what it can act on, and intermediate reasoning structures holding partial work. §7.1 traces that line through recent systems. The reasoner improved because its surroundings did.

Commodity intelligence brings the two traditions into the same production system. The engineering environment itself becomes an object of design: the representations, evidence, constraints, and controls around autonomous work must be engineered and maintained together.

The conversion and ratcheteering developed in Chapter 4 keep this arrangement open to correction as experience reveals missing knowledge or controls.

7.2.5 What MAGE Claims Is New

MAGE neither restores a sequential development process nor requires a complete model before implementation begins. Its components have deep precedents: models, constraints, verification, external memory, structured reasoning, and autonomous software agents. The contribution lies in their architectural and disciplinary composition, made newly practical by commodity intelligence.

Much recent agentic software engineering asks how increasingly capable agents can perform work within the software-engineering environment they inherit. MAGE asks how that environment itself should be redesigned when autonomous implementation becomes a primary productive substrate.

Its answer is to make purposeful models, Alignment machinery, and the governed engineering environment first-class objects of software engineering, and to treat recurring judgment converted into durable structure as engineering capital. Consequential semantic judgment stays with engineers wherever representation and mechanism cannot responsibly carry it.

The claim is bounded in two directions. MAGE does not depend on inventing new modeling or verification techniques, and it does not hold that model-first organization is where software engineering must arrive. MAGE makes selected engineering representations authoritative within an increasingly automated production system, and applies the same approach to the production process itself. Commodity intelligence changes the cost of constructing and maintaining that arrangement. The engineering task is to decide where it pays and to build the production environment accordingly.

Works Cited

  1. Beck, Kent. Test-Driven Development: By Example. Addison-Wesley Professional, 2003.
  2. Beck, Kent, Mike Beedle, Arie van Bennekum, et al. “Principles behind the Agile Manifesto.” 2001. https://agilemanifesto.org/principles.html.
  3. Salado, Alejandro. Rethink Engineering: Revolutionize the Way You Make Decisions. Educating Thinkers Press, 2026.
  4. Reeves, Jack W. “What Is Software Design?” C++ Journal, 1992. https://www.developerdotstar.com/mag/articles/reeves_design.html.
  5. Cabot, Jordi. Vibe-Driven Model-Based Engineering. arXiv preprint arXiv:2604.10645, 2026. https://arxiv.org/abs/2604.10645.
© James C. Davis, 2026–present