Course navigation · Chapter 01

Part I · Engineering in the Age of AI / Chapter 01

The New Engineering Paradigm

Software and AI change the systems we can build—and the work of building them. How do we turn that new pace into useful engineering progress?

About this chapter · Reader preview

This pilot applies the revised site direction. The monitoring example and agent workflow are conceptual, not a simulation or a recorded agent run. The original lessons and working coverage lab remain available.

Content and layout revised 15 November 2026. Repository and revision history · Original Chapter 1

An operations team wants to detect developing equipment faults before they interrupt production. A small monitoring device might help. But which faults matter, where can the sensor be mounted, and what would an operator do with its warning? The product is still a set of questions.

The team can model signal behavior, prototype an enclosure, try an AI classifier and test an early software version. Each activity can move quickly. The harder task is deciding what those results mean for the system—and what to investigate next.

Two systems develop together.

One product question. Two kinds of engineering work.

Conceptual example

Can we recognize a useful fault signal on the equipment as it is actually installed?

The product system

  1. Sensor + mountingCapture the physical signal
  2. Software + product AIInterpret what was observed
  3. Operator + responseAct on a useful warning

↓ Product questions shape the experiments↑ Findings guide the design

The engineering environment

  1. Models + test fixturesRepresent conditions and alternatives
  2. Tools + AI agentsRun analyses and inspect results
  3. People + methodsEvaluate findings and choose next work
The product has to work in use. The engineering environment helps the team discover what works, investigate what does not, and carry that learning into the next design.

This is a systems engineering problem: develop the whole system across disciplines, people and operating conditions. Sensor electronics, mechanical installation, software and the operator's task all affect whether a warning is useful.

It is also work on the engineering environment. A new mounting concept may require a better model or a different test fixture. Once the team can repeat that experiment, the next comparison becomes easier to make and explain.

We develop, operate and improve the engineering environment alongside the product.

Follow a finding into the next piece of work.

Illustrative situations · Expand a finding to see its consequences.

01 / PHYSICAL BEHAVIORThe signal changes with the mounting.

Develop the product

Compare mounting options before committing to the enclosure. Check whether the signal remains useful under the intended installation conditions.

Develop how we engineer it

Revise the model's mounting assumptions and adapt the test fixture. Keep the signal-processing workflow so the next experiment can reuse it.

The useful gain: the next design comparison starts from what the team has learned about the physical system.

02 / PRODUCT AIThe classifier misses an unfamiliar operating condition.

Develop the product

Investigate the missed condition and the consequence for the operator. Revisit the classifier, sensing approach or intended range of use.

Develop how we engineer it

Add representative cases to a separate evaluation set. Compare future candidates against these cases and the conditions already understood.

The useful gain: an observed weakness becomes a repeatable evaluation for subsequent candidates.

03 / SOFTWARE DELIVERYA firmware change alters sampling behavior.

Develop the product

Evaluate the changed behavior against the current electronics and sensing assumptions before releasing the increment.

Develop how we engineer it

Add a repeatable interface check and retain the tested configuration. Run the check on later changes and schedule physical tests where the change requires them.

The useful gain: frequent software delivery gets earlier feedback about a system dependency.

Put the models to work.

A model is more useful to the investigation when the team can change an input, run it and compare the result. A test becomes more useful when it can run again after a change. A workflow becomes more useful when the next person can use it without reconstructing every step.

We use executable engineering for this approach: models, analyses, tests and parts of the engineering workflow can be run, evaluated and improved. The name describes a way of working; it does not make every engineering judgment executable.

Software-driven workflows carry this beyond software development. A mechanical engineer can run a parameter study. An electronics engineer can evaluate a signal chain. A test engineer can process measurements and compare configurations. Repeatable execution makes another investigation practical while preserving enough context to interpret it.

A digital thread maintains the relationships that matter: this model uses that assumption; this experiment tests that configuration; this finding informs that decision. The benefit is that the next investigation can build on the reasoning, rather than rediscovering which result belongs to which design.

AI changes the work and the product.

AI-assisted engineering covers AI used in engineering work, from helping an engineer examine an idea to carrying out a delegated task. An AI agent can use tools, inspect their results and adapt its next steps toward a defined objective. We call this way of working agentic engineering. Engineers still frame the task and evaluate the work.

AI in the engineering environment

Investigate a design question.

An agent could implement alternative signal-processing models, run them against specified cases, inspect the outputs and revise a candidate. The engineer needs to examine the model, comparison and remaining uncertainty.

AI in the product

Provide a product capability.

A classifier could help the monitoring device distinguish a fault signal from normal operation. Its usefulness depends on the data, equipment conditions and consequences of a missed or false warning.

These are different uses of AI. The classifier need not be an agent or use a large language model (LLM). An LLM is a model technology behind many assistants and agents; it is one part of the surrounding tools and workflow. A fixed script that reruns tests is automation, even if an AI helped write it.

Useful agent work also changes the team's preparation. Models need usable inputs. Tools need clear interfaces. Results need context. Making those available lets people and agents investigate with the same engineering resources, while keeping the interpretation open to review.

Increase the pace. Respect the system.

Faster engineering means shortening the time between a question, an experiment and a useful decision. It also means delivering smaller improvements more frequently when the system can support them. Software releases, model revisions and physical prototypes contribute different kinds of feedback.

SoftwareChange → check → release → observe
ModelsRevise assumptions → run alternatives → compare
Electronics + mechanicsDesign → fabricate → integrate → test
System in useObserve behavior → evaluate usefulness → revise intent
Different feedback cycles, not a common release clock. This schematic assigns no durations.

Testing and evaluation belong inside these loops. Verification asks whether specified expectations are met; validation investigates whether the system is suitable for its intended use. Frequent software checks support delivery, while physical behavior and use still need relevant evidence.

This changes how teams organize and follow the work. Alongside completed tasks, ask which behavior has been demonstrated, which uncertainty remains and which dependency is holding up the next decision. A failed prototype can advance understanding. More generated code does not, by itself, establish product maturity.

A software release passes every automated check. What have we learned about the mounting?

Only what those checks actually evaluate. If they do not represent mounting behavior, they provide no new evidence about it. Use their results to advance the software work, then identify the model or physical experiment needed for the mounting question.

The engineering takeaway

We build the machine that builds the machine.

The second machine is the people, methods, models, tools and workflows that make engineering possible. Develop it through real product questions. Reuse what already works, add what the next investigation needs, and improve the environment as the team learns.

The monitoring team now has several possible next steps: understand the mounting, improve the classifier, or test what an operator needs. Which uncertainty deserves attention first—and which work is ready for commitment? That is the question for Chapter 2, Planning Under Uncertainty.

Inspect an example or go deeper

Executable engineering is this tutorial's working description. The monitoring situations illustrate an approach; they are not measured product results or evidence of a running agent.