IV — Establish Trust and Sustain Change · Chapter 13

All fifteen chapters
  1. The New Engineering Paradigm
  2. Introducing the Engineering Challenge
  3. Planning Under Uncertainty
  4. Engineering Knowledge as Code
  5. Learning Through Models and Prototypes
  6. Engineering Data: From Measurements to Decisions
  7. Spec-Driven Development Without Waterfall
  8. Directing AI Engineering Agents
  9. Engineering in Small, Reviewable Increments
  10. From Models to an Integrated Product
  11. Verification, Validation and Engineering Evidence
  12. Governance and Engineering Authority
  13. Continuously Integrated Engineering
  14. Managing Engineering Knowledge at Scale
  15. Choosing the Next Engineering Capability

Continuously Integrated Engineering

What would it take to make a suitable engineering change releasable within one day?

Imagine a team responsible for a software-enabled physical product. It wants to move an eligible, bounded software improvement from an accepted engineering request to a controlled, releasable configuration within 24 hours.

That is a useful architectural challenge. It asks more than how quickly someone can edit code. Several agents may explore, implement and check changes simultaneously, while the team still has to reconcile sources, dependencies, evidence and decisions. The engineering factory must coordinate outcomes, not merely accelerate each individual task.

In our fictional intersection case, that capability does not exist yet. We have only a small teaching model and an unresolved interface discrepancy. The 24-hour window is therefore a hypothetical design objective, not an achieved metric, an operational promise or a claim that a roadside signal can be changed in a day.

The interesting question is what the product and its engineering environment would need before the objective could be realistic for a carefully defined class of changes.

Not every small edit is eligible

A tiny software diff may have a large system effect. Before designing the fast path, we need to decide which changes can safely and legitimately use it.

Consider three fictional proposals:

Proposed change Hypothetical eligibility Why
Correct an isolated diagnostic-report label without changing behavior, configuration meaning or interfaces Potential candidate, pending applicable checks and review Its effect may be bounded and separable
Change the command acknowledgment from “message received” to “state applied” Not automatically eligible The meaning crosses controller, electronics, physical indication and unresolved integration evidence
Change phase timing or introduce adaptive control Not automatically eligible Product behavior and operating consequences need different evidence

Even the first row needs review. Calling a change “diagnostic only” is an assertion to check, not a blanket exemption. The team must know which version of the product is affected and what its test environment can genuinely demonstrate.

The interface mismatch from Chapter 10 is particularly useful. The source comparison cannot be fixed by merely putting an ambiguous acknowledgment into a new software release.

Building the factory is engineering work

The phrase engineering factory describes the people, methods, models, tools and infrastructure that make repeated engineering changes possible. It is not simply a continuous integration server.

For the hypothetical rapid-change capability, the team would need several mutually supporting elements.

The product architecture must have coherent interfaces, configuration identification, appropriate modularity and recovery behavior. If every software change can alter unrelated physical functions, a short release process will struggle to keep its claims bounded.

The engineering environment needs controlled model and input definitions, independent behavioral and regression checks, relevant integration fixtures, review procedures, evidence records, documentation and a release/rollback mechanism appropriate to the product. It also needs a way to reconcile parallel work, shared source ownership and unresolved dependencies into a common, reviewable baseline. Detecting wrong changes and coordinating their consequences—not simply running code faster—makes the feedback useful.

Some of that infrastructure can be purchased or reused. Some must be created for the product and its disciplines. The right investments follow recurring engineering questions rather than a desire to automate every step.

Designing this capability is itself an engineering project: it has requirements, costs, dependencies, acceptance criteria, maintenance and evolution.

Operating the factory is a different job

Building a test harness does not mean a team will operate it reliably.

Follow a hypothetical eligible change through the engineering work:

Step What must actually happen What can block progress
Accept request State intended outcome, effect and change class Ambiguous product scope
Select context Identify relevant source revisions, interfaces and dependencies Stale or missing information
Make proposal Implement a bounded, reviewable change Coupled change outside agreed scope
Check Run the relevant automated and, where needed, integration evaluations A failing criterion or unavailable fixture
Assess Link results to the correct configuration and claim Evidence applicable only to another revision
Authorize Obtain the decision required for that change class Open safety, interface or operational question
Prepare Produce an identifiable releasable package and recovery information Missing packaging, version or rollback capability

A successful automation step advances one part of the process. A blocked result is useful if it shows which product or factory capability is missing.

For example, if an interface-impact check finds that the proposed adapter acknowledgment has no suitable observation, the correct factory response is not to waive it because a build passed. The team needs an integration capability or a different change classification.

Orchestrate the engineering outcome

Imagine three agent-assisted workstreams operating around the same fictional intersection: one proposes a T1 input-validation improvement, one investigates a possible change to the controller–adapter acknowledgment contract, and one prepares the relevant checks and review information.

The validation change may be a candidate for a bounded software path. The acknowledgment investigation is not evidence that the physical interface is compatible. A coordinator must see both facts and avoid treating several local successes as an accepted integrated product.

A practical orchestration capability needs to answer five questions:

Coordination question What the engineering environment should provide
Intent: What outcome are we pursuing? A clear engineering objective, product boundary and acceptance criteria
Context: Which definitions apply? Current source revisions, ownership and dependency links
Execution: Who or what is doing which work? Separate agent/workstream scopes, isolated changes where helpful, and observable progress
Integration: Can these results be combined? Relevant checks on the combined configuration and explicit status for unresolved dependencies
Assurance: What can advance, and who decides? Linked evidence, change eligibility, escalation rules and accountable approval

This is an orchestration function, not a demand for a new product. Source-controlled specifications, Git branches or worktrees, pull requests, CI, decision records and simple automation can support it. A separate AI-native, tool-agnostic control plane is one possible architecture when scale justifies it—not an assumed requirement or an engineering guarantee.

The coordinator may be a human, a bounded orchestration agent, deterministic workflow automation, or a combination. Its role is to maintain shared context and dependency truth. It must not promote proposed outputs to verified evidence merely because a worker agent reports success.

Reduce the cognitive load of supervision

If ten agents report every intermediate step, the engineering lead may spend more time reading status than resolving product questions. Increasing code-generation throughput without changing coordination can move the bottleneck into review, integration and human attention.

The remedy is exception-driven supervision. For each outcome, surface what is integrated and supported, what is waiting on a dependency, and which decision specifically needs a human. Preserve detailed traces for inspection rather than forcing every reviewer to consume them by default.

In the teaching case, an illustrative summary could be:

  • Ready for relevant review: T1 input validation changed; defined positive and negative checks reported against an identifiable revision.
  • Open engineering dependency: controller acknowledgment rev A and adapter rev B describe different meanings.
  • Human decision needed: defer compatibility acceptance or authorize a suitably scoped interface/bench investigation.

Those statuses are hypothetical; no parallel agents or physical test ran in the fictional case. A trustworthy summary must link to the corresponding source and actual check outcome where one exists.

The goal is to reduce decisions about routine tasks, not suppress evidence or automate unowned approval. Useful indicators include waiting time at dependency handoffs, incompatible revisions discovered at integration, repeated human interventions and time from an accepted outcome to checked, releasable evidence. A count of agent-generated tasks or dashboards is not a measure of product progress.

Two feedback loops, two kinds of evidence

The factory is especially valuable when it supports two connected feedback loops.

Loop What is evaluated? Who or what can act on feedback?
Inner: executable engineering Does the proposed change satisfy defined model behavior, input constraints, regression tests and relevant automated integration checks? Within scope, an AI agent can implement, execute, inspect failures and correct its work through several iterations
Outer: product and engineering judgment Are the requirements right, the model useful for the question, the interfaces compatible and the necessary physical/operational evidence available? Engineers and accountable decision-makers refine the specification, change the verification method, authorize further investigation or block release

In the inner loop, fast and informative tests allow an agent to work through more of a complete engineering flow without needing a human to issue each next task. Orchestration coordinates several such loops around one outcome and makes cross-workstream conflicts visible. The checks should include meaningful valid and invalid cases, and their acceptance criteria should not be under the agent’s unchecked control. Otherwise the agent can make a weak test suite green while missing the intended behavior.

The outer loop cannot be reduced to running the same tests again. A model can produce identical correct results every time and still omit an important product requirement. Where physical interfaces, operating conditions or system safety matter, the factory must provide suitable observations and human review rather than treating code-level success as acceptance.

This distinction is an autonomy design decision: grant more agent iteration where feedback is relevant and trustworthy, and require escalation where criteria or product validity are uncertain. It does not imply that each inner-loop correction retrains the AI model.

Continuous integration, delivery and deployment

These terms are related but should not be collapsed.

Continuous integration means frequently combining and checking changes so problems are found relatively early.

Continuous delivery maintains a software configuration in a state where release can be performed when its applicable conditions are met.

Continuous deployment goes further by automating deployment to an operational environment under a suitable policy.

A physical system may have release preparation, hardware baselines, installation work and qualification gates that differ from software release cadence. A releasable software package does not, by itself, mean an installed intersection configuration has been accepted for operation.

When AI agents assist, they can prepare bounded changes, inspect sources or execute permitted checks. That may help the factory operate, but it does not transform missing physical evidence into a valid approval.

The 24-hour target is a requirement to analyze

To make the target meaningful, define what starts and stops the clock.

For this educational discussion, it starts when a bounded eligible engineering request is accepted and stops when a configuration is releasable under the defined process, not necessarily deployed to an installed system.

That differs from DORA’s change lead time, which is concerned with commit-to-production deployment in software delivery measurement. Mixing definitions would make the performance claim misleading.

The team should look beyond typing speed and the number of simultaneous agents. How long do changes wait on dependencies or shared-source ownership? Can results from different workstreams be integrated and checked against the same baseline? Does an engineer receive a small, actionable set of exceptions with links to the underlying evidence? Can a failed integration check be diagnosed and the release recovered?

No invented duration is needed for every step. The value of the target is that it exposes dependencies that the architecture and engineering environment must address.

What would we improve after a blocked release?

Suppose a proposed software change depends on the controller-to-adapter acknowledgment. The factory finds that the interface semantics differ and that applied-state evidence is absent.

The immediate product decision is to defer that change’s release eligibility.

The engineering-environment decision may be to improve interface source checks, define a relevant emulator/bench observation, retain configuration evidence or clarify which change classes the fast path can support.

That improves the outer loop by introducing evidence the former process lacked. In turn, the new checks can provide faster, more actionable feedback for the inner loop. The product reveals a bottleneck in how it is engineered; the factory is improved to address it.

That is why we need to build the engineering capability and operate it, then improve it based on real product questions.

The factory becomes reusable knowledge

After the team establishes a reliable source, test and review method for one configuration, other teams may want to reuse it. But reusable tooling and reusable evidence are different.

A new supplier adapter or product variant may use the same model/checking pattern while requiring new interface compatibility evidence. A shared test procedure is valuable; the original result is not automatically transferable.

That is the next problem for Managing Engineering Knowledge at Scale.

Engineering takeaway: The engineering factory must orchestrate outcomes across people, agents and disciplines, not only accelerate individual implementations. Fast checks enable local autonomy; explicit dependency and integration management keeps the combined baseline coherent. People should focus on priorities, exceptions and decisions that cannot responsibly be automated.


Inspect the case decision: Eligibility and blocked-change reasoning · Integration discrepancy · DORA continuous delivery.

Published after initial author review. This fictional teaching case is not physical validation. Interactive V3 tools remain in development. Chapter source