Skip to content

§6.1 From Production to Cumulative Progress

Agentic engineering must preserve engineering intent while delegating implementation. Modeling makes that intent available for reasoning; Alignment supplies independent evidence and enforcement. Chapter 5 examined the software factory as a whole. We now focus on its governed engineering environment (GEE): the reusable engineering structure through which people and agents direct, evaluate, and control implementation. Three questions organize the theory, moving from individual production to engineering over time (Table 6.1-1).

Table 6.1-1. Three perspectives on engineering progress.
Perspective and engineering question
Faithful production. Did the representation capture the intended obligations, and did the implementation fulfill them?
Economical production. What did correct, admitted delivery cost, including failed attempts and upkeep?
Cumulative progress. How does today’s work change the environment inherited by later engineering?

6.1.1 What Makes Production Faithful?

Recall the entitlement failure from Chapter 2. The client based its upload decision on a finite-credit total, ignoring a separate unlimited-status flag. That scalar could not distinguish exhausted finite credit from unlimited access. An implementation could faithfully compare the scalar with the upload cost and still make the wrong admission decision. The representation used for the decision had omitted a consequential distinction available elsewhere in the system.

This illustrates two ways delegated implementation can fail. The engineer may encode the wrong obligations, or the agent may fail to fulfill correctly encoded obligations. Let E mean that the encoding captures the consequential intent and F that the resulting artifact fulfills the encoded obligations. For a representation R, the probability of both is

pR=P(E∩F∣R)=P(E∣R)⏟Encoding: engineers statewhat must holdP(F∣E,R)⏟Realization: agents fulfillthose obligations

This encoding–realization decomposition applies the probability chain rule to separate two engineering questions: whether the representation captures the intended obligations, and whether the resulting artifact fulfills them.** In general, the probability that two events A and B both occur is the probability of A multiplied by the probability of B given A: P(A∩B)=P(A)P(B∣A). This is the probability chain rule; it does not require the events to be independent. Here we apply the same identity conditional on the representation R, with A=E (correct encoding) and B=F (fulfillment), yielding P(E∩F∣R)=P(E∣R)P(F∣E,R). The distinction lets us examine how representations, agent capabilities, and production processes affect faithful realization.

Figure 6.1-1 distinguishes encoding from realization within the software factory. The encoded property also defines which realizations are acceptable, allowing the result to be evaluated independently of the agent that produced it.

Probability in the software factory Engineering intent is encoded as a property and fulfilled through a fabricator to produce a realization. The encoded property also supplies tolerance for possible realizations; independent measurement informs admission or rejection. SOFTWARE FACTORY PROCESS DESIGN: how production proceeds PRODUCTION PROCESS Engineering intent Encoded property Fabricator Realization P(E) correct encoding P(F | E) fulfill encoded obligations Engineers authorize intent. Agents interpret, implement, and correct. Supplies the tolerance Measurement: tests, PBT, analysis, simulation, human judgment POSSIBLE REALIZATIONS Acceptable region TOLERANCE acceptable product variation within tolerance outside tolerance Admitted change Revise / reject
Figure 6.1-1. Probability in the software factory. Engineers encode consequential intent; agents fulfill the encoded obligations. The two probability terms condition on representation R, omitted for legibility. The encoded property also defines the acceptable region for realizations, allowing independent evidence to inform admission or rejection.

The two terms distinguish failures in what the agent was asked to produce from failures in producing it. Holding the task population and production setup fixed, R names the representation choice; probabilities range over the encodings and realizations produced through it. The first question is whether the representation captures the consequential intent the engineer authorizes. The second is whether the resulting artifact fulfills those obligations.

Realization includes interpretation, planning, implementation, and correction. An agent may initially misunderstand an obligation and then correct its work after a check or review exposes the error. Conversely, it may infer an obligation that the encoding omitted. The event E∩F therefore describes faithful production through the representation; observed task correctness must be assessed separately.

The first term is easy to overlook in an agentic setting. A structured model may help a machine interpret intent more reliably than prose, and it can also help the engineer express the intended property correctly in the first place. Different representations make different distinctions visible, force different decisions to be made explicitly, and make omissions easier or harder to notice. A representation can therefore improve P(E∣R) even if it leaves P(F∣E,R) unchanged. This is one reason Modeling is an engineering activity rather than merely a technique for supplying context to an agent.

Representation is not the only route to that term. A realization that misses the engineer's meaning can provide evidence about the encoding, although the failure may instead lie in realization. The comprehension amplification of §4.1 can help the engineer diagnose the cause and revise the encoding when needed. In that way, capable agents can contribute indirectly to P(E∣R).

Process design changes the conditions under which agents realize intent: context, tools, decomposition, routing, permissions, and other features of the harness can change P(F∣E,R), its cost, or both. A better agent can improve the same term. Explicit tolerances help engineers state the intended property and make it available for independent evaluation. Tests, analysis, measurement, or human judgment can assess whether a realization falls within that tolerance. Where the evidence supports enforcement, a gate can reject work that violates the obligation. This separates helping production succeed from deciding whether its result should be admitted.

A stronger reasoner can sometimes recover meaning that a weaker one misses. A terse requirement may be enough for an agent that knows the domain and can inspect the surrounding system. Better retrieval, tools, and feedback can also help it discover what the representation leaves implicit. These possibilities affect the cost and reliability of realization; they are reasons to compare richer representations with more capable inference rather than assume that either must win.

The entitlement failure also shows the limit of inference from an inadequate representation. A reasoner using only the finite-credit total could not recover the distinction between exhausted credit and unlimited access. Better reasoning could help only by revisiting the decision representation or consulting the existing unlimited-status signal.

Even perfectly reliable realization cannot, by itself, establish that the encoded obligations were right. Holding encoding quality fixed, as conditional realization approaches certainty, faithful production approaches P(E∣R). The practical consequence is to examine the encoding when better agents keep faithfully producing the wrong thing.

The appropriate degree of specification depends on the work. Some transformations leave little useful freedom, and the cost of ambiguity may outweigh any benefit from delegation. Elsewhere, specifying nearly every realization decision in advance recreates much of the specification cost discussed in Chapter 5. It also sacrifices a major advantage of commodity intelligence: agents can explore implementation choices that engineers need not make themselves. The engineer can specify consequential obligations, leave other choices open, and let the agent find a satisfactory realization. The economic value of Modeling and Alignment therefore depends partly on how much useful freedom the environment can preserve while maintaining adequate control.

6.1.2 What Makes Production Economical?

The engineering question is what useful delivery costs. A cheap attempt may leave an engineer with hours of repair; an expensive model may support hundreds of later changes. To compare those arrangements, we need to count the work that went into delivery, including the work that never produced an acceptable result.

For N requested changes, let DN count the changes independently verified as correct and admitted within a declared evaluation horizon. Each requested change can include several attempts. The total cost and the cost per correct admitted change are

CN=Cbuild+∑i=1N(Crun,i+Ccarry,i),cN=CNDN,DN>0.

Construction covers the initial investment in the engineering environment. Running costs include production, checking, human review, and repair across all attempts; carrying costs cover the upkeep needed to keep the environment useful. A failed or abandoned task still contributes its costs to the numerator. If nothing correct is delivered, report that result and the expenditure rather than assigning a cost per delivery. Shared costs need an explicit allocation, and human effort and machine expenditure need declared valuations before they can be added. Elapsed time remains a separate outcome.

This accounting does not assume that tasks cost the same, that retries are independent, or that the environment stands still. It does require comparable work. An engineering process that accepts only easy changes may have an attractive cN while leaving important requests unfinished. Comparisons should therefore hold the requested work and evaluation horizon fixed, report what was delivered and left unresolved, and measure escaped failures and false rejection alongside cost. Repeated attempts often change the specification, tools, or next plan; observed delivery costs can count that learning without pretending that every retry starts over under identical conditions.

Admission adds the cost of gathering evidence and acting on it. A gate can provide the same protection while one representation causes agents to collide with it much more often than another. Each rejected candidate may require further inference, diagnosis, or human attention. These costs belong in Crun,i, whether the rejection catches a real defect or mistakenly turns away correct work.

Carrying cost completes the comparison. The factories in Chapter 5 preserve engineering knowledge in models, instructions, policies, skills, tests, and context systems. All require some effort to remain useful as the software changes. A structured model earns its construction and upkeep when it enables valuable work or reduces later reconstruction, realization, failure, or assurance costs enough over its useful life. For a simple or infrequent task, a natural-language description may already do the job at very little cost.

The alternative is often to buy inference when the question arises. A capable agent may reconstruct a dependency from source cheaply enough that a maintained graph would not repay its cost. For another task family, reconstructing that same dependency hundreds of times may be much more expensive than keeping it explicit. The comparison depends on the work, the available reasoner, the assurance required, and the expected reuse of the representation. A model can also repay its cost in a single use when the question is sufficiently consequential.

This gives packaged agent systems a place in the theory. A capable reasoner and generic supervisory machinery may economically replace some structure that a weaker reasoner would need. How much can they replace, and for which obligations? We can compare what those arrangements deliver, what escapes their assurance, and what they cost, while also asking what engineering knowledge survives for the next task.

This accounting makes alternative engineering arrangements comparable, but it does not tell us which arrangement to choose. A stronger foundation model may reduce the need for explicit representations; a better representation may let a cheaper foundation model perform the same work. A gate may reduce escaped failures while increasing rejection and repair costs. The engineering problem is to choose among these arrangements under requirements for correct delivery, acceptable risk, and human attention. The cheapest implementation attempt need not be the cheapest way to deliver acceptable work.

Human attention is part of this accounting. A production system that generates changes cheaply but requires an expert to reconstruct each one has moved work onto that expert. The relevant cost includes the time needed to interpret the evidence, diagnose failures, and decide whether the result is acceptable. The following inset explains why increasing output can make this cost decisive.

HUMAN FACTORS

Inset — Human Attention Is Not a Free Control

Moving work from human execution to machine execution does not eliminate the cost of human attention if people must inspect the resulting stream. Software engineering has long relied on one engineer reviewing another's work, but code review is imperfect. Studies document the improvements reviewers prompt and associate review coverage and participation with post-release quality 12.1. Moritz Beller et al., “Modern Code Reviews in Open-Source Projects: Which Problems Do They Fix?” Proceedings of the 11th Working Conference on Mining Software Repositories, 2014, 202–11, https://doi.org/10.1145/2597073.2597082.2. Shane McIntosh et al., “The Impact of Code Review Coverage and Code Review Participation on Software Quality: A Case Study of the Qt, VTK, and ITK Projects,” Proceedings of the 11th Working Conference on Mining Software Repositories, 2014, 192–201, https://doi.org/10.1145/2597073.2597076. At Microsoft, reviews spanning more files had a lower proportion of useful feedback, and developers reported that such reviews required more time and effort 3.3. Amiangshu Bosu et al., “Characteristics of Useful Code Reviews: An Empirical Study at Microsoft,” Proceedings of the 12th Working Conference on Mining Software Repositories (MSR), 2015, 146–56, https://doi.org/10.1109/MSR.2015.21. As agents assume more implementation work, software engineering faces a problem familiar to industries that automated earlier. Bainbridge's Ironies of Automation described how automation can leave human operators responsible for monitoring rare failures and intervening when something goes wrong 4.4. Lisanne Bainbridge, “Ironies of Automation,” Automatica 19, no. 6 (1983): 775–79, https://doi.org/10.1016/0005-1098(83)90046-8.

As agentic output grows, proportional human inspection becomes a bottleneck. Where recurring obligations can be represented explicitly and checked or enforced adequately, reusable mechanisms can reduce the inspection required for each change. Engineers can then concentrate their attention on ambiguous evidence, novel failures, tradeoffs, exceptions, and decisions whose consequences require expert judgment. Human attention is an engineering resource.

The return on an engineering environment depends on the value of the work it enables and its cost over time. Product work may deliver new capabilities, security work may retire risks, and reliability work may prevent failures or shorten recovery. The environment also incurs costs between production episodes as its models, controls, and other assets require maintenance. Some structures remain useful for years with little attention; others lose fit quickly.

6.1.3 What Makes Progress Cumulative?

Choosing the least costly arrangement for the next change is not necessarily the best decision for the next hundred changes. A model, validator, or procedure may cost more to construct than the immediate task justifies, yet repay that investment through later work. Conversely, a locally inexpensive change can introduce architectural irregularity or obscure information that subsequent engineers and agents must reconstruct.

Winters et al. characterize software engineering as “programming integrated over time”: software is developed, modified, and maintained as both the system and its environment change 5.5. Titus Winters et al., Software Engineering at Google: Lessons Learned from Programming Over Time (O’Reilly Media, 2020). Each realization therefore changes the architecture, conventions, representations, tests, and other structure inherited by subsequent work. The lifecycle account totals these costs, but does not yet explain how earlier work changes the conditions for later production. We need to represent that inheritance explicitly.

Let Ti be the task at step i, M the foundation model, and Gi the governed engineering environment inherited at that step. The GEE includes the task-relevant representations, tools, procedures, and controls available to direct and evaluate the work. Let ai denote the work performed during the episode and the changes it leaves behind:

pi=p(Ti,M,Gi),Gi+1=f(Gi,ai).

Here pi is the probability of faithful production for task Ti, extending the earlier encoding–realization account to include the inherited environment. The second relation describes how the episode can change that environment. A failed attempt may leave a useful diagnosis or a new control even when it produces no admitted change. Holding the foundation model fixed lets us examine how changes to the GEE affect subsequent work; over a longer sequence, the foundation model can change as well. These are schematic relationships describing inheritance, not calibrated laws or a claim that every episode improves the environment.

This coupling creates path dependence. A locally acceptable change can increase architectural irregularity, obscure structure, or introduce inconsistent conventions, leaving later agents a worse reasoning surface. A change that improves representations, architecture, constraints, or other engineering capital can instead make later work easier to reason about and govern.

Agentic capacity and the GEE jointly shape what a software factory can accomplish, but they play different roles. Work orders specify the intended changes; foundation-model capability, concurrency, and implementation speed determine the available agentic capacity. The GEE supplies the representations, procedures, evidence, and controls through which that capacity is directed and governed. Figure 6.1-2 relates these inputs to attempted work and realized performance, then shows how experience can change the environment inherited by later work.

The MAGE Dynamic Model Prior knowledge seeds the governed engineering environment. Work orders, agentic capacity and the environment shape attempted work and its outcomes. Observed problems can lead to diagnosis and adaptation. Corrective feedback revises the inherited environment, which may enable larger tasks and greater concurrency. Prior engineering knowledge standards, requirements, existing assets, prior lessons seeds Governed engineering environment 𝒢 representation · coverage · coherence · economy Expanding task frontier may enable larger tasks and greater concurrency Work orders task, intent, acceptance criteria Attempted work changes undertaken, task frontier Agentic capacity model capability, concurrency, implementation speed specify intended work enables execution produces Realized performance durable throughput, defect escape, human attention provides evidence Experience and adaptation Observed problems churn, recurring failures, interventions, control friction Diagnosis local defect? structural gap? inadequate enforcement? Governance adaptation convert, reconcile, retire Corrective feedback revises inherited structure
Figure 6.1-2. The MAGE Dynamic Model. Prior engineering knowledge seeds the governed engineering environment (GEE). Work orders specify intended changes, agentic capacity enables their implementation, and the GEE governs attempted work. Observed problems can prompt diagnosis and governance adaptation, revising the environment inherited by later work. An improved GEE may also support more ambitious tasks, exposing new demands on its representations and controls.

The corrective feedback path begins when attempted work exposes recurring failures, escaped defects, repeated human intervention, or friction from existing controls. Engineers diagnose whether the problem is local to an implementation or reflects a deficiency in the GEE. A structural problem may warrant a new representation, stronger enforcement, reconciliation of conflicting mechanisms, or retirement of an obsolete control. Improving the GEE’s fit may require removing machinery rather than adding it. When such changes address the underlying cause, subsequent work can avoid repeating the same failure. Without diagnosis and authority to revise the shared environment, the organization may instead repeat local repairs indefinitely.

The expanding task frontier is a related effect. As the GEE becomes better suited to existing work, engineers may attempt larger changes, increase concurrency, or undertake work previously too expensive to supervise. A GEE that supports ordinary changes may make cross-service migrations practical, exposing obligations and failure classes that simpler work never encountered. Corrective feedback can improve the environment’s fit to current work; an expanding task frontier changes the work against which that fit is judged. Neither effect guarantees improvement.

The GEE need not begin empty. Existing standards, requirements, architecture descriptions, tests, and lessons from other projects can provide useful structure before local experience reveals a gap.

More machinery does not mean a better GEE. Ten thousand lines of stale checks are worse than one hundred lines that govern the obligations that matter. The four properties identified in Figure 6.1-2 provide ways to assess that fit:

  1. Useful representations. The information needed for the work is explicit at an appropriate level of abstraction.
  1. Adequate coverage. Important obligations have appropriate evidence and enforcement.
  1. Coherence. Models and mechanisms reinforce one another rather than contradicting or needlessly duplicating.
  1. Economy. Their future value justifies their maintenance, friction, and context cost.

Coverage does not require mechanizing every obligation. Some belong in a compiler rule or gate; others require statistical evidence, semantic evaluation, or human judgment. A strong GEE makes clear where judgment belongs and where repeatedly buying the same judgment is wasteful.

These properties describe different ways a GEE can support the work, rather than stages of a maturity model 6.6. Terry B. Bollinger and Clement L. McGowan, “A Critical Look at Software Capability Evaluations,” IEEE Software 8, no. 4 (1991): 25–41, https://doi.org/10.1109/52.300034. The appropriate investment depends on what is limiting progress. Repeated reconstruction of important state suggests a representation problem; escaped failures call for examining evidence and enforcement. When existing controls impose more friction than protection, reconciliation or retirement may improve the GEE more than adding another mechanism.

A theory of agentic engineering should distinguish activity from progress. Durable throughput is useful system progress that survives rework, integration, and operation. Defect escape records consequential failures that reach later lifecycle stages or production. Human-attention burden measures the scarce engineering judgment consumed per unit of durable progress. Table 6.1-2 gives candidate observables; §6.4 returns to how comparisons can distinguish the effects of representation, enforcement, and inherited capital.

Table 6.1-2. Outcomes of the theory. Raw implementation activity is an input. The theory is interested in how much survives as durable progress, what failures escape, and how much scarce human judgment that progress consumes.
OutcomeWhat it measuresCandidate observables
Durable throughputRaw implementation converted into lasting system progresslanded changes net of rework; churn share; the slope of sustained throughput
Defect escapeRelevant failures reaching later lifecycle stages or productionescaped-defect rate; reopen rate; silent-corruption escape
Human-attention burdenHuman judgment required per unit of durable outputinterventions per landed change; review time; conversion effort

Several easy-to-count quantities measure activity or investment rather than outcome: commits, lines changed, control files, model-sync events, and support ratio. They can help explain what an environment is doing; they do not establish that it is producing a return.†† The activity-versus-outcome gap also appears in industry data. LinearB's 2026 benchmark covers 83,000 developers across 253 organizations and compares merge rates from June 2025 to May 2026 7.7. LinearB, “The Engineering Productivity Gap: How Elite AI Teams Are Pulling Away from the Rest,” LinearB, 2026, https://linearb.io/resources/ai-engineering-productivity-gap. Among the heaviest AI users, merge rates roughly doubled while pull-request yield—the share of opened requests merged within 30 days—fell. The association does not establish that AI caused either change, and neither measure establishes durable progress. An industry analyst reads the same period as rising AI spend without proportionate shipping velocity, the difficulty having moved from comprehension to confidence 8.8. Jennifer Riggins, “AI Coding Got Faster. Why Didn’t Engineering?” The New Stack, August 9, 2026, https://thenewstack.io/ai-productivity-measurement-gap/.

None of these descriptions supplies a measured effect size. Together they support a more focused question: under what conditions do representations, independent enforcement, and inherited engineering judgment turn additional agentic capacity into useful progress? The next section develops four propositions that evidence could challenge.

Works Cited

  1. Beller, Moritz, Alberto Bacchelli, Andy Zaidman, and Elmar Juergens. “Modern Code Reviews in Open-Source Projects: Which Problems Do They Fix?” Proceedings of the 11th Working Conference on Mining Software Repositories, 2014, 202–11. https://doi.org/10.1145/2597073.2597082.
  2. McIntosh, Shane, Yasutaka Kamei, Bram Adams, and Ahmed E. Hassan. “The Impact of Code Review Coverage and Code Review Participation on Software Quality: A Case Study of the Qt, VTK, and ITK Projects.” Proceedings of the 11th Working Conference on Mining Software Repositories, 2014, 192–201. https://doi.org/10.1145/2597073.2597076.
  3. Bosu, Amiangshu, Michaela Greiler, and Christian Bird. “Characteristics of Useful Code Reviews: An Empirical Study at Microsoft.” Proceedings of the 12th Working Conference on Mining Software Repositories (MSR), 2015, 146–56. https://doi.org/10.1109/MSR.2015.21.
  4. Bainbridge, Lisanne. “Ironies of Automation.” Automatica 19, no. 6 (1983): 775–79. https://doi.org/10.1016/0005-1098(83)90046-8.
  5. Winters, Titus, Tom Manshreck, and Hyrum Wright. Software Engineering at Google: Lessons Learned from Programming Over Time. O’Reilly Media, 2020.
  6. Bollinger, Terry B., and Clement L. McGowan. “A Critical Look at Software Capability Evaluations.” IEEE Software 8, no. 4 (1991): 25–41. https://doi.org/10.1109/52.300034.
  7. LinearB. “The Engineering Productivity Gap: How Elite AI Teams Are Pulling Away from the Rest.” LinearB, 2026. https://linearb.io/resources/ai-engineering-productivity-gap.
  8. Riggins, Jennifer. “AI Coding Got Faster. Why Didn’t Engineering?” The New Stack, August 9, 2026. https://thenewstack.io/ai-productivity-measurement-gap/.
© James C. Davis, 2026–present