Skip to content

§1.2 The Engineering Object

1.2.1 Consequential Choices and Degrees of Freedom

Delegating implementation is useful only if we can avoid doing much of the implementation work ourselves. Imagine asking an agent to build a feature. The first attempt fails, so we specify the data structures. The next attempt performs poorly, so we prescribe the indexes and queries. Then come the transaction boundaries, the function signatures, and eventually the variable names. At that point, we might as well write the code ourselves. The question is how much direction, and of what kind, the agent needs to produce an acceptable result. We want to specify the decisions that matter without having to make all the decisions that implementation requires.

When implementation is delegated, engineers must decide which properties to preserve and which choices to leave open. A function could be implemented in ten lines or ten thousand. A service could be built as a monolith or decomposed into microservices. Different algorithms, data structures, and architectures might all satisfy the same requirements. Some choices are better than others, but engineers need not make every choice in advance. They can specify the properties that matter and leave other decisions to the intelligence performing the work. Which choices can safely remain open is itself an engineering decision.

Commodity intelligence can also change why an engineering choice matters. Consider the choice of a programming language. A human team might favor Java both because its developers can write it fluently and because they can readily review or audit code written in it. If an agent can implement competently in several languages, the first consideration weakens: the developers no longer have to author every line themselves. The second may become more important as agents produce more code for people to examine. Meanwhile, a safety requirement may favor a language that provides a needed property, such as automatic garbage collection to reduce memory leaks caused by missing deallocation. A deployment target may also require a particular toolchain. These considerations persist regardless of who writes the code. The relevant question is what made the choice matter, and how those reasons change when agents perform the implementation.

The same distinction applies at larger scales. Suppose a service needs persistent storage. If either a relational or nonrelational database can satisfy every property that matters, choosing between them may simply be a degree of freedom left to implementation. But if the system requires transactions across related records, a particular consistency model, or another property that distinguishes the alternatives, the choice becomes consequential. MAGE does not supply the database theory needed to make that judgment. It asks that the consequential property be represented—and, where necessary, enforced—rather than relying on each implementing agent to rediscover why the choice mattered.

Notice the distinction between unmodeled and free. A choice is unmodeled when the engineering representations do not state it; it is free only when engineers permit the alternatives. Suppose the model says nothing about which database to use. If either database really can satisfy every consequential property, the omission represents a genuine degree of freedom. But if one alternative would violate a security, consistency, or performance obligation, the choice was never free. The model simply failed to make the relevant obligation explicit.

1.2.2 Engineering the Environment

Engineers increasingly exercise those decisions through the environment in which agents work. That is what I meant by the forms and ways of working that make productive machinery useful. An engineering environment includes the representations, tools, processes, permissions, evidence, and mechanisms surrounding the agents’ work. In MAGE, a Governed Engineering Environment (GEE) deliberately carries engineering decisions forward by making consequential knowledge available, enforcing selected obligations, and preserving evidence needed for engineering control. Figure 1.2-1 shows how engineering leverage shifts from implementation toward this environment.

Where engineering leverage acts Two pipelines are stacked for contrast. In the classical pipeline the engineer builds the implementation directly, so the implementation is the primary point of engineering control: Engineer, then Implementation, then Product. In the agentic pipeline agents build the implementation inside an engineered environment the engineer constructs, so the environment becomes the primary point of engineering control: Engineer, then Engineered Environment, then Agents, then Implementation, then Product. A rust badge marks the primary node in each row; it moves upstream from the implementation to the environment. A footer strip unpacks the environment into models, obligations, evidence, controls, and infrastructure. WHERE ENGINEERING LEVERAGE ACTS CLASSICAL engineer writes the implementation Engineer Implementation Primary point of engineering control Product AGENTIC agents write the implementation Engineer Engineered Environment Agents Implementation Product Primary point of engineering control Governed Engineering Environment the engineered instructions around autonomous realization models · obligations · evidence · controls · infrastructure
Figure 1.2-1. Where engineering leverage acts. When engineers implement systems directly, much of their control acts through the code. With agentic implementation, more of that control acts through the governed engineering environment, which represents consequential intent, constrains work, and evaluates results.

The environment can serve two different purposes: establishing consequential properties and reducing the cost of repeated engineering work. For assurance, models and checks can provide a manageable basis for evaluating a system even when an agent needs little help understanding its implementation. For efficiency, reusable representations can reduce the work agents spend recovering system knowledge. The two benefits may arise at different scales. Their value must justify the cost of building and maintaining the supporting structure.

The environment we build for agents need not simply reproduce the one built for human developers. Agents can consume and maintain representations at scales that would be impractical for people, and automated analyses can check properties that human review would otherwise have to reconstruct from implementation. The design question is therefore two-sided: what existing engineering machinery should agents inherit, and what stronger machinery becomes practical because the workers are now machines?

1.2.3 When Agents Produce the Wrong Result

“’Tis a poor craftsman who blames his tools.” For an engineer, the aphorism directs attention to the work that precedes fabrication: representing the problem, choosing which properties must hold, and arranging how the result will be checked. A 3D-printed bracket may fail because the printer cannot achieve the required accuracy, but it may also fail because the design, material, or fabrication instructions were unsuitable. Diagnosing the printer alone would overlook much of the engineering.

Software agents blur the distinction between the productive machinery and the engineering supplied to it because they can infer missing structure. A capable agent may produce an impressive result from a screenshot, prose request, or incomplete specification, filling in decisions that an engineer might otherwise have had to make explicit. That inferential capacity makes delegation useful, but it can also make omissions in the engineer’s work harder to notice. A completed artifact does not establish that the inferred choices satisfy the intended properties or reflect acceptable tradeoffs.

When an agent produces the wrong result, start with what the engineer controlled: the instructions, the representation of the problem, the task boundary, the available tools, and the evidence required of the result. Were important properties missing from the representation? Did an instruction leave a decision open that should have been settled? Could the checks detect the error? Sometimes the foundation model simply lacks the necessary capability. Failed output alone does not establish that diagnosis.

Abundant implementation raises the stakes. Capable agents can execute a bad direction with extraordinary speed. Velocity amplifies sound engineering and bad engineering alike.** My field notes on this point were less measured: “Claude is the fastest road to hell.”

© James C. Davis, 2026–present