Course in Review: Engineering Controlled Change
Premise. The activities of this course are not stages of a process; they are the standing obligations of an engineer who remains answerable for a system that keeps changing.
The course opened with a claim about what makes software development an engineering discipline. Since then you have studied how engineers decide what software should do, how they delegate its realization without surrendering control, and what technical properties a deployed system must preserve. This unit brings those subjects together and then looks forward, because you are entering a profession whose means of production are changing while you train for it.
The objects of our discipline¶
Three definitions have been in force since week one, reproduced here in the wording you first met.
Software. Software is an expressive medium in which behavior is represented for execution by machines, including through both conventional instruction-based computation and machine reasoning.
Software engineering. Software engineering is the engineering discipline of controlled change in software systems. It creates and evolves software while preserving sufficient control over the properties and consequences that matter.
Engineering. Engineering is the discipline of exercising informed control over consequential systems and accepting responsibility for their outcomes. Engineers need not personally perform every act required to realize a system. They must retain sufficient command to understand and direct it, evaluate the evidence for its consequential properties, recognize when its assumptions fail, and intervene when necessary. They remain answerable for the consequential decisions made under their authority.
Read in order they establish a hierarchy: what we engineer, what software engineering does with it, and what makes the activity engineering at all. Nothing in the third definition requires you to write the code.
One system, many engineering questions¶
Act III followed one campus room reservation service through the concerns that arrive when a useful program becomes a software system. Each unit asked a different question and built the representation needed to answer it.
| Unit | Engineering question | Representative model |
|---|---|---|
| Compute Environments & Deployment | Where does the software run, and how does it get there? | Deployment topology, release pipeline |
| Data Management | How is information represented and preserved? | Relational schema, constraints, transactions |
| Architecture & Dependencies | How do components relate, and what constrains change? | Dependency graph, coupling measures |
| Performance & Reliability | How does the system behave under load and failure? | Workload model, failure model |
| Security Engineering | What may an adversary do? | Threat model, trust boundaries |
| Operations & SRE | How do operators understand and recover the running system? | Objectives, telemetry, incident records |
None of these describes the software completely. Their value comes from what each one leaves out.
Consider a change to the service: students may reserve a room for a recurring weekly meeting. It looks like a change to application behavior. It reaches five models.
- Data. How is a recurrence represented, and can the no-overlap invariant still be enforced where it was enforced before?
- Architecture. Which component owns recurrence rules, and which owns conflict detection?
- Performance. What additional work does conflict-checking a recurring series demand, and at what point in the request path?
- Security. Who may create, modify or cancel a series, as distinct from one of its occurrences?
- Operations. How would an operator detect a series that was accepted when it should have been refused?
The engineer decides which of those questions are consequential here, which models therefore need revision, and what evidence would establish that the changed system is still acceptable. That triage is the work. It is not a step that precedes the work.
Models also go stale, and a stale model is worse than a missing one because it still answers. The implementation changes and the architecture diagram does not. A migration changes the schema and a consumer still assumes the old shape. An objective survives the workload it was set against. Keeping consequential representations in correspondence with the system is engineering, not documentation.
Engineering controlled change¶
The three acts examined different parts of one problem.
| Act | Central question | Contribution to controlled change |
|---|---|---|
| I. Foundations | What should the software accomplish, and how do we reason about it? | Establishes what must be true |
| II. Engineering with Agents | How is realization delegated without surrendering control? | Organizes and governs delegated work |
| III. Engineering Software Systems | What must the resulting system preserve? | Holds consequential properties in an operating system |
The acts are not sequential phases. Their activities recur for as long as the system lives. An incident exposes a missing requirement. A measurement forces an architectural change. An agent finds a better design while implementing a feature. A security review decides that an interface everyone had accepted now needs restricting. What orders these activities is whatever you have just learned.
This is an account of how the activities relate, not a workflow to follow. Many changes deserve almost no explicit modeling. A few deserve analysis, independent validation and a carefully staged deployment. Judging that proportion is itself an engineering decision you will be held to.
Engineering capability accumulates. An organization holds more than its source code. It holds knowledge of the system, the means to reason about a proposed change, and mechanisms that hold the properties it cares about. Some of that stays in people. Some becomes durable structure: models, tests, validators, architectural boundaries, runbooks.
Durable structure becomes engineering capital when later work inherits the judgment rather than reconstructing it. A regression test retires one defect permanently. A dependency model makes impact analysis cheap. A deployment gate carries an operational obligation across every future release. None of it is free: models drift, tests go obsolete, and controls interfere with each other. Keep the ones whose continuing value covers their cost.
The changing work of software engineers¶
Software engineering has been reorganized before, each time by something that made one activity cheap. Compilers removed the need to write machine instructions. Libraries, frameworks and cloud platforms turned whole implementation and operational capabilities into services somebody else runs.
Coding agents belong to that history, with a broader reach. They participate in activities that previously required human interpretation: reading a repository, proposing a design, implementing a change, constructing tests, diagnosing a failure, revising an implementation against evidence. The consequence is not that programmers type less. As implementation gets cheaper, every other constraint on engineering gets relatively more expensive.
| Engineering activity | Effect of cheaper implementation | The question that remains yours |
|---|---|---|
| Requirements | More alternatives can be explored | Which problem should be solved? |
| Design | Alternatives can be realized and compared | Which tradeoffs are acceptable? |
| Implementation | Most realization can be delegated | What freedom should the implementer have? |
| Validation | Tests and analyses are cheap to generate | What evidence establishes correctness? |
| Maintenance | Changes are produced rapidly | What must remain true across them? |
| Operations | Diagnosis and recovery are increasingly assisted | Which actions are safe and authorized? |
The right column is not a list of things machines cannot do. Agents may come to do much of the modeling, analysis and validation as well, and there is no principled reason to assume otherwise. The column records where the consequence of being wrong currently lands.
More implementation is not more engineering. Suppose your team can now produce ten times as many changes. If its capacity to understand, evaluate, integrate and operate them has not moved, the extra output buys little. The bottleneck relocated; it did not disappear. An organization that notices this invests in the system through which software is produced: better representations, stronger automated checks, integration that holds, operational mechanisms that remove repeated human intervention. Those investments raise how much work the organization can govern, which is a different quantity from how much code it can write.
What remains the engineer's responsibility?¶
Delegation is not new to engineering. Engineers have always relied on other people, specialized tools, suppliers and automatic machinery to realize what they designed. Agents widen the range of what can be delegated. They do not transfer the authority or the responsibility that attaches to an engineering decision.
An engineer answerable for a consequential system keeps enough control to answer five questions.
- Intent. What is the system supposed to accomplish?
- Knowledge. What must be understood about it to decide responsibly?
- Evidence. What would justify believing a proposed change is acceptable?
- Control. Which obligations must be preserved, and what enforces them?
- Responsibility. Who is answerable for the decision and its consequences?
Answering these does not require performing every task yourself. It requires knowing what you delegated, what remains uncertain, and when to intervene. Nor does it mean settling everything in advance. Good engineering preserves legitimate freedom: an implementer may choose among many acceptable realizations, and an experiment sometimes finds a better answer than the one you specified. Your task is to tell acceptable freedom apart from consequential uncertainty, and to say which one you were relying on.
So, returning to the definition in force since week one:
Software engineering is the engineering discipline of controlled change in software systems. It creates and evolves software while preserving sufficient control over the properties and consequences that matter.
Four of its terms now carry the semester's weight. Controlled does not mean prevented; it means subject to informed judgment, with the evidence to back it. Change is the normal condition of software, not an exception to be managed. Properties are the things you decided must stay true, which is why you had to make them explicit. Consequences reach past the system to the people who depend on it, and they are what responsibility attaches to.
The means of producing software will keep changing. The obligation to understand and govern what it does will not.
Closing questions¶
Bring your semester project.
- Which engineering models would another team need in order to maintain your system responsibly?
- Which of your important properties does your engineering environment enforce, and which still rest on someone remembering?
- What has your team accumulated that would make the next change easier than the last one?
- If agents became ten times more capable, what would change about your process, and what would still be yours?
Answer the fourth question twice. The second time, ask whether you are keeping each task because human judgment is genuinely required, or because you are used to a human doing it. Telling those apart is the last thing this course asks of you, and you will keep answering it long after the course ends.
Materials¶
- Lecture slides — Course in Review: Engineering Controlled Change — source (PPTX)
Readings¶
Where engineering work moves
- MAGE §7.1, "The Reorganization of Software Work." Davis, 2026. Required. The chapter argues that commodity intelligence changes software engineering's cost structure rather than invalidating it: when implementation consumes less of the engineering budget, the relative value of specification, architecture, modeling, validation, measurement and governance rises. Read it for the distinction the lecture turns on, between accelerating the coding portion of the work and reorganizing the whole production process. Ask yourself which of your own project's activities got cheaper this semester, and which got more consequential as a result. Full citation: James C. Davis, Model-Based Agentic Engineering, 1st ed. (2026), https://davisjam.github.io/model-based-agentic-software-engineering/book/mage-book/index.html, chap. 7, §7.1 The Reorganization of Software Work.
What the engineer still owes
- MAGE §7.4, "The Engineer." and MAGE §7.5, "What Must Not Be Delegated?." Davis, 2026. Required. These two sections pose the question the final lecture closes on: if agents can implement changes, maintain models, run analyses and propose engineering moves, what remains the engineer's work? The answer offered is not a list of tasks machines currently perform badly, because such lists expire. It is informed control and responsibility for what the system should mean. Read §7.5 last; it is the book's coda and it states where the difficulty moves rather than claiming the difficulty disappears. Full citation: James C. Davis, Model-Based Agentic Engineering, 1st ed. (2026), https://davisjam.github.io/model-based-agentic-software-engineering/book/mage-book/index.html, chap. 7, §7.4 The Engineer and §7.5 What Cannot Be Delegated?.
Optional / further reading
- MAGE §6.1, "From Production to Cumulative Progress." and MAGE §6.2, "What the Theory Predicts." Davis, 2026. Optional. The economic argument underneath the lecture's third and fourth sections: governance conversion, engineering capital, and why a change inherits the architecture, representations, conventions, obligations and tests that earlier work produced. §6.2 is the more useful of the two here, because it treats engineering capital as a quantity that can fail to materialize, and gives the conditions under which a conversion does not pay. Full citation: James C. Davis, Model-Based Agentic Engineering, 1st ed. (2026), https://davisjam.github.io/model-based-agentic-software-engineering/book/mage-book/index.html, chap. 6, §6.1 A Theory of MAGE and §6.2 What the Theory Predicts.
- Beyer, Jones, Petoff and Murphy (eds.), Site Reliability Engineering (O'Reilly, 2016), chapter 15. Optional, and carried over from Operations & SRE. Reread the section on corrective actions against this unit's closing questions: it is the clearest short account of the difference between repairing one failure and changing the conditions that let its class recur. Full citation: Betsy Beyer et al., eds., Site Reliability Engineering: How Google Runs Production Systems (O’Reilly Media, 2016), chapter 15, Postmortem Culture: Learning from Failure.