Skip to content

§7.4 The Engineer

The broader theory sharpens the question this chapter began with. If agents can increasingly implement changes, maintain models, run analyses, and propose engineering moves, what remains the engineer's work?

The answer is decidedly not whatever tasks machines happen to perform poorly today. A profession cannot define its purpose by the temporary limitations of its tools. Commodity intelligence expands the implementation capability available to engineers; it does not itself determine who is entitled to authorize the work or accept the result. The engineer must retain informed control over the resulting system and remain responsible for it. The professional question is what competence and authority that responsibility requires when much of the work is delegated.

Software engineers have often performed technical work, exercised decision authority, and borne responsibility for the resulting system within the same role. Engineering organizations have long distributed these functions across people and teams, as when technical leads and managers direct implementation they did not personally produce. Commodity intelligence can make this arrangement more routine for individual engineers: an engineer can delegate implementation to agents while defining the intended result and evaluating the evidence for acceptance.

That wider scope for delegation requires engineers to distinguish the functions explicitly. Work performed refers to the activities carried out by people or agents. Authority exercised refers to the decisions a person or mechanism is permitted to make, while responsibility retained refers to accountability for the consequences of the whole engineering arrangement. Delegating an activity does not by itself confer authority to accept its result. An agent or other mechanism can also exercise explicitly delegated authority without thereby discharging the engineer's responsibility for the system.

7.4.1 Authority Follows Competence and Responsibility

MAGE increases both the leverage of engineering knowledge and the consequences of getting it wrong. An agent can increasingly carry much of the method itself: recognize a modeling opportunity, choose among known model families, construct a state machine, query a dependency graph, propose an invariant, or suggest that recurring inspection become machinery. As the repertoire becomes machine-readable, the engineer is distinguished less by recalling the available moves than by judging where they apply. An agent's command of the repertoire does not establish that a chosen abstraction captures what matters, that a proposed invariant expresses the intended property, or that the resulting tradeoff is acceptable. Those judgments remain engineering work.

Professional authority

Engineering authority extends beyond technical capability. Societies entrust engineers with consequential decisions because engineers are expected to understand the systems they certify and to stand behind them. The institutional details differ across domains, but the principle holds: the authority to make consequential engineering decisions requires both sufficient control over the system and responsibility for the decisions made. Engineers can carry legal, professional, and sometimes personal liability for the decisions they sign. An AI system can generate an artifact or assemble evidence. It cannot assume the professional responsibility attached to an engineer's judgment.

Other engineering professions make answerability institutionally explicit through professional licensure. In U.S. professional-engineering practice, the concept of responsible charge attaches authority to the engineer exercising direct control and supervision over consequential engineering work; licensed engineers are also subject to enforceable ethical and legal duties directed toward public health, safety, and welfare.** On responsible charge — direct control and supervision by the engineer exercising professional judgment — see National Society of Professional Engineers (NSPE) Position Statement No. 10-1778 (rev. May 2024); 1515. National Society of Professional Engineers, “Responsible Charge,” NSPE, 2024. on the statutory duties and practice exemptions that bound where licensed authority is required, NSPE Position Statement No. 09-0173 (rev. November 2023) 16.16. National Society of Professional Engineers, “Licensure Exemptions,” NSPE, 2023.

The ability to understand and challenge agentic decisions is therefore part of the basis on which consequential engineering authority can legitimately be exercised. The converse matters too. If engineers cannot retain sufficient control over a system making consequential decisions to exercise that authority responsibly, withholding the authority is itself a legitimate—and sometimes necessary—engineering outcome.

Agentic production also changes what the competence behind that authority must cover: the production system itself becomes something the engineer must be able to evaluate. Someone who understands the application domain but cannot evaluate the production system may be poorly equipped to authorize its outputs. Conversely, expertise in agent orchestration alone does not establish competence to judge whether the resulting software satisfies its obligations. Authority to accept the work requires both: enough command of the production system to know what its evidence establishes, and enough command of the domain to know what that evidence must show.

The judgment frontier

One social purpose of the engineer is to be entrusted with, and answerable for, technical work too complex or consequential for ordinary individuals to undertake for themselves 1.1. George Bugliarello, “The Social Function of Engineering: A Current Assessment,” in Engineering as a Social Enterprise (National Academy Press, 1991). A small bridge across the ditch in my parents' yard allowed the neighborhood kids to visit more easily, but a few boards crossing a span of three feet did not call for a structural engineer. The Golden Gate Bridge did. Large engineering organizations extend the same principle internally: a chief engineer may be answerable for a system assembled through layers of engineers and specialists, below which lie tasks simple enough that engineering expertise is no longer needed either to perform the work or to establish that it was done correctly. GenAI can push that boundary downward. If machine intelligence can reliably perform more of the work, fewer human engineers may be needed to build the same system. Nothing about engineering requires preserving jobs that no longer require engineering judgment.

But there is another boundary: the judgment frontier. Chapter 6 showed that some obligations cannot yet be reduced to mechanical checks. A capable reasoner must still decide whether the evidence is enough, whether a tradeoff is acceptable, or whether something is simply right for its purpose. Better GenAI will move this frontier too. We may entrust machine intelligence with judgments that in 2026 we reserve for experienced engineers, including increasingly contextual and qualitative ones. Yet technical capability and social authority are different things. Society may accept an engineering organization with far fewer human engineers before it accepts one with none: no human professional entrusted with the work, no human being who can be called to account for its judgments, and only machine intelligence standing behind the result.†† Contemporary calls for greater social control over advanced AI have argued that decisions about powerful systems should not be left solely to the organizations developing them, but should reflect broader social judgment 17.17. Future of Life Institute, Pause Giant AI Experiments: An Open Letter, Open letter, 2023. Frank Herbert imagined an extreme version of such a choice in Dune: after the Butlerian Jihad, its fictional society prohibits "thinking machines" and deliberately preserves human capacities to perform work that machines might otherwise perform 18.18. Frank Herbert, Dune (Chilton Book Company, 1965). Herbert's answer is extreme, but the underlying question is real: societies must decide not only what machine intelligence can do, but what roles they are willing to surrender to it and what human capacity they wish to preserve. The frontier is therefore not only what machines can judge. It is what society is willing to let them judge on our behalf.

Resilience gives another reason to preserve the human side of that frontier. A society whose engineering capacity exists only through machine intelligence has made that intelligence critical infrastructure. If the foundation models become unavailable, untrustworthy, compromised, or controlled by someone else, the society has no independent engineering capacity to fall back on. Some human engineering competence may therefore remain valuable even when it is no longer the cheapest way to produce engineering work.

Other industries have learned the same lesson about efficiency and reserve capacity. Systems optimized around lean inventories and just-in-time supply can be highly efficient in ordinary conditions while leaving too little cushion when a common disruption arrives. The COVID-19 pandemic made that tradeoff unusually visible 2.2. National Academies of Sciences, Engineering, and Medicine, Building Resilience into the Nation’s Medical Product Supply Chains (National Academies Press, 2022), https://doi.org/10.17226/26420. In consequential industries, resilience can go beyond prudent management and become an explicit engineering obligation. U.S. pharmaceutical manufacturing rules require an "adequate number of qualified personnel" to perform and supervise drug production, with personnel qualified for their assigned functions 3.3. U.S. Food and Drug Administration, “Personnel Qualifications,” 21 C.F.R. § 211.25. Federal law separately requires manufacturers of certain drugs and related products to maintain redundancy risk-management plans addressing threats to supply, 44. Federal Food, Drug, and Cosmetic Act § 506C(j), 21 U.S.C. § 356c(j). and FDA guidance recommends that medical-device manufacturers plan for continuity by ensuring additional production capacity and identifying alternative sources 5.5. U.S. Food and Drug Administration, “Emergency Preparedness and Medical Devices: Supply Chain Recommendations for Health Care Providers and Medical Device Manufacturers,” accessed September 11, 2026.

The analogy to machine intelligence should not be pushed too far: these rules do not require pharmaceutical manufacturers to keep redundant workers idle in case ordinary production fails. But they embody a useful engineering principle. A critical productive capability should not be evaluated only by how efficiently it operates under ordinary conditions; its dependencies, qualified capacity, and ability to continue under disruption matter too. The judgment frontier is therefore partly about trust and accountability, but also about preserving the ability to act without the machine.

Resilience need not mean preserving only human reserve capacity. It may also favor diversity in where machine intelligence resides. If consequential engineering increasingly depends on foundation models available only through a small number of remote providers, access to those providers becomes part of the engineering infrastructure on which individuals, firms, and societies depend. Smaller local or on-device foundation models could provide another layer of reserve capacity: perhaps less capable than frontier systems, but inexpensive, independently operable, and sufficient when paired with strong representations, tools, and evidence. Whether that capability becomes technically or economically competitive is uncertain. The engineering principle is not. A resilient system should be wary of concentrating an essential productive capability behind a dependency it cannot itself control.

Cheaper implementation can reduce the human effort needed to produce a given system. It does not follow that a resilient society should allow independent human engineering capacity to disappear.

Engineering has always required moving between levels of abstraction: choosing the level that exposes the property at issue and descending when the current abstraction no longer answers the question. Working with agents extends that practice. Natural-language programming—say what you want and receive code—captures only the realization interface. As agents acquire more of the technical repertoire, the engineer's leverage moves upstream—from supervising individual actions toward authoring and judging the environment in which those actions occur.

My own experience building DocAble was not one of deskilling. I needed every ounce of my software-engineering knowledge to make the system work. What changed was where I spent that expertise. I spent less of it realizing individual implementation decisions and more of it deciding what needed to be represented, constrained, measured, and preserved. I found that shift delightful: cheaper realization let me use engineering judgment on a system substantially larger than I could otherwise have built.

That upstream work can outlast the individual judgment. A well-chosen abstraction, a binding constraint, or a reliable validator can continue carrying part of an engineer's reasoning into work performed by other people and agents. This is one reason the environment can accumulate engineering capital. It is also why authoring the environment carries unusual leverage: a consequential judgment made well once may shape thousands of later changes. But inheritance is not abdication. Someone must still recognize when the environment no longer fits the system, when an old distinction has stopped mattering, or when a new obligation lies outside what the existing machinery can see. The expert contribution moves toward creating, evaluating, and revising durable structure; it does not disappear once that structure exists. Engineers must also be able to make their knowledge and objections available to those who have authority to act.

Inset — Engineering at the frontier of authority

Engineers advising those with authority to proceed must make their expertise count. They remain responsible for making the engineering case legible: what is understood, what can be assured, what remains uncertain, and what risk a decision would accept.

Engineering history shows what happens when technical knowledge and decision authority become disconnected. Before the Challenger launch, Morton Thiokol engineers recommended against launching at the expected temperatures, but management reversed the recommendation; the Rogers Commission later reconstructed the disagreement and the decision process 6.6. Presidential Commission on the Space Shuttle Challenger Accident, Report of the Presidential Commission on the Space Shuttle Challenger Accident, Volume 1 (U.S. Government Printing Office, 1986). Before Columbia's loss, engineers raised concerns about the foam strike and sought additional imagery, but their uncertainties did not reach decision-makers with sufficient force 7.7. Columbia Accident Investigation Board, Columbia Accident Investigation Board Report, Volume 1 (National Aeronautics; Space Administration, 2003). Volkswagen's emissions scandal illustrates a different failure: engineers participated in implementing software that concealed regulatory violations, and the subsequent legal record established individual accountability 8.8. U.S. Department of Justice, Office of Public Affairs, Volkswagen Engineer Pleads Guilty (2016) and Is Sentenced to 40 Months in Prison (2017) for His Role in the Conspiracy to Cheat U.S. Emissions Tests, U.S. Department of Justice press releases, 2017. The disclosures of Frances Haugen and Arturo Béjar concerning harms on Facebook's platforms illustrate another form of the problem: internal measurements and warnings can exist without producing an adequate organizational response 910.9. U.S. Senate Committee on Commerce, Science, and Transportation, Protecting Kids Online: Facebook, Instagram, and Mental Health Harm, 117th Cong., 1st sess., S. Hrg. 117-719, 2021.10. U.S. Senate Committee on the Judiciary, Social Media and the Teen Mental Health Crisis, 118th Cong., 1st sess., testimony of Arturo Béjar, 2023.

These cases suggest a simple professional test. When consequential harm occurs, the engineering record should show what engineers knew, what they did not know, what they warned about, and who chose to proceed. This is not merely defensive documentation. Making knowledge, uncertainty, disagreement, and evidence explicit is part of how engineering informs consequential decisions and makes those decisions answerable.

The distinction matters increasingly as software agents become capable of consequential action. Retaining engineering control does not require engineers to make every decision an agent makes. It requires them to establish the relevant bounds: what authority has been delegated, what properties are assured within it, what evidence supports those claims, what departures can be detected, and where the limits of that assurance lie.

Sometimes the available evidence will not establish the desired bound. Engineers are not always the final decision-makers. Executives, military commanders, regulators, political leaders, and societies may have legitimate reasons to proceed despite engineering uncertainty: the consequences of inaction may themselves be severe, and competitive or geopolitical pressures may make accepting substantial risk rational. Engineering's responsibility is to preserve the distinction. A decision to accept an inadequately bounded risk does not make the risk bounded. The record should make clear what engineering could establish, what it could not, and who possessed the authority to proceed anyway.

That answerability matters after the decision as well. Society needs identifiable people and institutions from whom an account can be demanded and to whom consequences can attach. Professional licenses can be revoked, certifications withdrawn, organizations sanctioned, and individuals held legally responsible. A machine cannot become the terminus of that chain of responsibility. Delegating a decision to a machine does not delegate the responsibility that justified the human or institutional authority to make it.

Better engineering environments can expand the domain over which engineers responsibly delegate action. At this frontier, their value is measured by what people and institutions can understand, constrain, assure, and govern—and by whether they can answer for the consequences.

Table 7.4-1 names this authorship division.

Table 7.4-1. The authorship division. Self-Governance can recognize and propose engineering moves; the engineer remains answerable for the significance, intended meaning, authority, and tradeoffs those moves serve.
Self-Governance carriesThe engineer remains answerable for
recognizing a modeling opportunitydetermining its significance
proposing a representationestablishing what it means
extracting candidate conceptschoosing the consequential abstraction
finding an inconsistencyadjudicating the intent behind it
formalizing a known propertydeciding what property should hold
proposing a governance mechanismdeciding what it should enforce
identifying a recurring failuredetermining acceptable risk and tradeoff

Organizations may distribute these responsibilities across engineers, platform teams, review boards, or other accountable roles. The allocation should be explicit and governed.

Natural language may be one interface to the work. It is not the engineering method.

7.4.2 Sign-Off Moves Toward Models and Evidence

In the factory Chapter 5 examined, the fleet constructed most of the implementation, maintained selected engineering representations, ran validators, and assembled evidence for the claims the design was supposed to satisfy. In its highest-throughput week, the admission gate landed nearly six hundred changes on regenerated evidence, while I read none of the diffs. My review looked less like authorship of the implementation and more like technical acceptance: inspecting representations, challenging assumptions, examining evidence, requesting deeper analysis where necessary, and deciding whether the result was fit to accept. Whether this arrangement generalizes beyond the case remains to be established.

The intermediate review surfaces developed in §7.1 change what the engineer is asked to accept. A model exposes a consequential claim; independent evidence bears on whether it holds. Neither is sufficient alone.

Models state selected claims about the system and the properties that matter. Evidence says why we should believe those claims. Governance says what evidence is required and what decisions that evidence can authorize. The engineer remains answerable for whether those are the right claims, representations, tradeoffs, and standards of evidence.

The object of review moves; accountability does not. An engineer has never needed to hand-implement every consequential choice to remain answerable for the resulting system. Agentic systems extend this arrangement across more of the system. The engineer delegates the keystrokes and stays answerable down to the code and past it — to the properties a model names and the evidence a validator produces.

Early evidence describes a related change in engineers' experience. In questionnaires administered six months apart, Vella and Blincoe found that most respondents reported spending less time writing code, with the relative balance of work shifting toward verification. Their qualitative accounts describe supervisory engineering work: directing, evaluating, and correcting AI output. Perceived productivity remained positive. Ratings of flow and cognitive-load benefits declined in the matched cohort, but those declines were not statistically significant 11.11. Annie Vella and Kelly Blincoe, The Impact of AI Coding Assistants on Software Engineering: A Longitudinal Study, arXiv preprint arXiv:2605.23135, 2026, https://arxiv.org/abs/2605.23135. These are reports of experience, not measurements of output. MAGE's proposal is to give that supervision better reasoning surfaces through explicit models and evidence.

Let me raise a concern about where this leaves the engineer. Is supervising agents necessarily a higher-skilled activity, or merely a more tedious one? There is nothing inherently satisfying about inspecting work one could have done oneself, finding mistakes, and asking for another attempt. Nor does spending less time writing code automatically mean spending more time exercising engineering judgment.

As implementation becomes cheaper, organizations have a choice. They can ask their engineers to shift left, toward requirements, specification, design, and the consequential decisions that shape a system. Or they can ask them to shift right, toward endless reviews of agent-generated work. The former offers an opportunity to exercise engineering judgment over larger systems; the latter risks turning engineers into full-time inspectors of machine output. I suspect that sustained professional satisfaction will depend on which direction organizations choose. MAGE offers a way to make the first path practical: improve the engineering environment so that recurring mistakes no longer require repeated human intervention.

Real answerability requires competence and authority. The reviewer has to distinguish local defects from structural problems, and a structural diagnosis needs a path to the architecture, models, mechanisms, or infrastructure that can address it. Otherwise responsibility becomes nominal: the engineer can see the problem but cannot change the environment that produces it.

The correspondence discipline of Chapter 2 applies to the review surface too. The engineer must ask what evidence connects a model's claims to the realized system; an orderly representation alone is no basis for sign-off.

Better realization does not establish that the encoded obligations were right. For an ordinary database interaction, a familiar algorithm, or a conventional architectural pattern, a capable agent can supply much of what the engineer left unsaid. This is enormously useful for exploration and prototyping.

Production raises a different question. A familiar pattern may make the agent likely to do the right thing without making the right thing explicit enough to check. Where the distinction is consequential, "the agent probably knows what we mean" is not an engineering control. The relevant property must be represented well enough that the environment can evaluate whether the realization actually preserves it. Familiarity can reduce the specification needed to produce software; it does not necessarily reduce the specification needed to assure it.

The trouble is the requirements. In software engineering, it always has been 12.12. Frederick P. Brooks, “No Silver Bullet: Essence and Accidents of Software Engineering,” Computer 20, no. 4 (1987): 10–19. Agents promise to get us to that discovery more quickly, and that is good news: one expensive part of engineering has become dramatically cheaper. The opportunity now is to represent consequential intent well enough to use this capacity. Capable agents allow many realization choices to remain open; engineers must establish which properties must survive that freedom.

Moving review toward models and evidence does not reduce the expertise required of the engineer. It changes the questions that expertise must answer.

7.4.3 From Full-Stack to Full-System Engineering

Software has used full-stack engineer to describe someone able to work across multiple implementation layers: interface, application logic, data, infrastructure, and deployment. Commodity intelligence may make that breadth easier to obtain. An engineer assisted by capable agents can increasingly construct and modify artifacts across layers without personally possessing the implementation fluency that each layer once demanded.

MAGE suggests a broader requirement. Retaining engineering control can require reasoning across the full system and its lifecycle, beyond the layers of the implementation stack. A representation chosen during design determines what later implementation can express; an architectural boundary determines what can be validated independently; operational evidence can reveal that an earlier abstraction was wrong; a recurring failure may justify changing the model, mechanism, or environment inherited by every subsequent change. These are not separate concerns merely because organizations have historically assigned them to separate roles.

Building DocAble made this breadth concrete for me. The work crossed regulatory obligations (the ADA, WCAG) and product judgment about usability, user expectations, and the limits of existing accessibility tools. It required knowledge of document formats and their representations (PDF, Office, LibreOffice, LaTeX, Typst), alongside accessibility semantics such as reading order, alternative text, tables, and structure. Those concerns shaped the architecture and structured models through which documents could be changed safely, the boundaries placed on agent behavior, and the validation needed to separate plausible output from conforming output. The same system also had to meet the memory, performance, deployment, and operational demands of a cloud service.

The consequential decisions were the ones that crossed these domains. The decision record of Chapter 5 shows the shape. Retiring accessibility-checker scores in favor of validation grounded in the standards required three judgments together: a regulatory reading of what the obligations actually require, a product observation that users' documents passed the checkers while losing meaning, and a change to the validation architecture. None of the three could have settled it alone.

Supporting additional document formats did different work: an architectural probe rather than simply an expansion of the product. Each format tested whether the architecture captured general properties of document remediation or assumptions inherited from the formats supported first. Cheap implementation made those experiments economical even when the additional formats were not immediate product requirements. Implementation can be selected for the knowledge it produces, not only the functionality it delivers. Neither decision belonged to any layer of an implementation stack.

There is also a personal side to this change. Many software engineers enjoy programming. I do too. There is satisfaction in finding a clean abstraction, writing a good algorithm, or making a difficult implementation work. Delegating implementation means giving up some of that experience, and I would not dismiss the loss. But I have found a different source of satisfaction in its place. I can spend less time deciding what to name a variable or working through routine implementation details, and more time asking what the system should do, exploring alternative designs, and discovering why something that seemed reasonable does not work. The agents make it possible to try ideas that I might previously have abandoned because implementing them would take too long. That part is amazing.

This is the implementation amplification described in Chapter 4: I can form a hypothesis, model it, implement it, measure what happens, discover where my understanding was wrong, and repeat the cycle many times in the time a conventional implementation might once have taken. That compressed exploration also produces connection amplification. Consequences that conventional development might have separated by days or weeks arrive close enough together for their relationships to become visible.

I have found that this process develops the engineer as well as the system. The engineer goes through the loop too. Repeatedly choosing representations, confronting predictions with evidence, finding the proper level of a failure, and deciding what knowledge should become durable machinery forces the engineer to learn. Abundant implementation can deskill an engineer who merely consumes its output and loses the feedback through which expertise develops; used this way, it can instead become an unusually powerful medium for developing engineering judgment.

This is systems thinking applied to software engineering under agentic leverage. Local implementation can increasingly be delegated, but consequential judgment often requires following a property across requirements, models, architecture, implementation, validation, deployment, operation, and maintenance. The engineer need not personally perform every activity or master every technology. The requirement is sufficient command: enough understanding of each relevant domain to recognize how decisions made in one part of the system constrain, enable, or invalidate reasoning elsewhere, and to intervene when those relationships threaten consequential properties.

The professional trajectory may therefore be from full-stack toward full-system engineering. Full-stack breadth crosses implementation layers. Full-system breadth crosses domains, abstractions, and lifecycle boundaries. As agents make implementation expertise cheaper to apply, the latter may become the scarcer and more consequential form of engineering competence.

7.4.4 What Should We Teach?

If engineers increasingly review systems through representations and evidence rather than reconstructing every property from implementation, education should shift accordingly. This book is not an education study, so the argument is a professional hypothesis rather than a curricular finding.

Is there software engineering knowledge you cannot just figure out for yourself?

The question for software engineering education is whether there is important software engineering knowledge that practitioners cannot reasonably be expected to figure out for themselves, or whether software engineering is distinct among the engineering disciplines in being predicated on adaptability more than specific expertise. Perhaps software changes so quickly that what matters most is the ability to learn whatever comes next. In that case, we should stop pretending that software engineering has a durable body of technical knowledge. We should abandon software engineering as a discipline and retreat toward a liberal-arts education in critical reasoning, analysis, synthesis, and communication, supplemented by enough practical experience to learn the technologies of the moment.

That conclusion would make software engineering unusual among mature engineering disciplines. No one would seriously propose that mechanical engineers are simply clever people who can acquire the necessary engineering knowledge through curiosity and experience on the job. Something closer to that proposition may have been plausible 200 years ago, when much of mechanical engineering could be learned through machinery, craft, and apprenticeship. It is not plausible when an engineer must reason about fluid mechanics, heat transfer, materials, dynamics, and control. Engineering accumulated bodies of knowledge that practitioners cannot reasonably be expected to rediscover for themselves. Formal education is one way we transmit that accumulated expertise.

The skeptical case is stronger in software. Consider some of the principles routinely presented as software-engineering wisdom: Don't Repeat Yourself. Separate concerns. Hide implementation details. Prefer small interfaces. SOLID. Refactor duplicated or poorly structured code. Test your work. Talk to users before building the wrong thing. These are useful ideas, but it would be absurd to claim that someone needs a four-year university education to understand them. Much of the familiar literature of software practice is deliberately accessible to working programmers, and much of its advice can be learned through experience—sometimes painfully, but effectively. A capable programmer can encounter a tangled dependency, suffer its consequences, learn why modularity matters, and carry that lesson to the next system without ever taking a university course called Software Engineering.

The profession itself makes the challenge harder to dismiss. Many successful software professionals entered the field without formal education in software engineering or computer science, and even developers with university degrees commonly report learning programming through other routes. The 2024 Stack Overflow Developer Survey reflects this mixture: 66 percent of respondents reported holding a bachelor's or master's degree, while 49 percent reported learning to code at school and 82 percent reported using online resources to learn 13.13. Stack Overflow, “2024 Stack Overflow Developer Survey,” Stack Overflow, 2024, https://survey.stackoverflow.co/2024/. If people can become successful software professionals this way, perhaps adaptability and experience really are the expertise. Perhaps there is no software-engineering equivalent of fluid mechanics.

What shouldn't software engineers have to figure out for themselves?

I would concede some of this ground. Parts of software engineering really can be learned through practice. MAGE's Alignment Principle is a useful example. If a property matters, do not rely only on someone—or something—remembering to respect it. Check it, constrain it, or otherwise make violations harder to admit. Experienced software practitioners have been turning recurring mistakes into tests, linters, schemas, permissions, review rules, and automation for decades. MAGE systematizes that move and extends it to probabilistic implementors, but its basic intuition does not require a university education to discover.

But that concession does not extend to the foundations of computing. Beneath changing software technologies lies accumulated knowledge about how information can be represented, manipulated, transformed, constrained, and reasoned about—and about what guarantees can and cannot be established over those processes. Data structures expose the consequences of choosing one representation over another. Algorithms establish how information can be transformed and at what cost. Programming languages and type systems make selected distinctions explicit and constrain permissible operations. Operating systems expose problems of concurrency, isolation, resource management, and failure. Databases and distributed systems make persistence, consistency, coordination, and partial failure unavoidable. Security asks what can be trusted when other actors may actively work against the system. Specifications, architectural models, and formal methods provide still other representations through which engineers can state and reason about consequential properties.

The important expertise is understanding more than the existence of these subjects or techniques: the abstractions they provide, the questions those abstractions make tractable, the conclusions that follow, and where those conclusions stop. An asymptotic bound says something precise about computational growth without saying whether a system will meet its latency target. A type system can exclude a class of invalid programs without establishing that a program does what its users need. A test can provide evidence about executions without proving the absence of untested behavior. A formal specification can support strong guarantees about the properties it states while saying nothing about an important property that was omitted. An architectural view can make a dependency visible while abstracting away behavior that matters for another engineering question. These limits are not defects. They are consequences of abstraction, and understanding them is part of engineering expertise.

MAGE rests on these foundations rather than replacing them. Its Modeling Principle particularly depends on the representational part of this knowledge: what information a representation preserves, what it leaves out, how it corresponds to the realized system, and what claims it can legitimately support. Commodity intelligence changes who performs more of the implementation; it does not repeal the bodies of knowledge needed to understand what that implementation means, how it behaves, or what can be established about it.

This is technical knowledge that practitioners cannot reasonably be expected to rediscover for themselves. Commodity intelligence may make particular languages, frameworks, APIs, and implementation techniques cheaper to learn and quicker to replace. Delegating more realization makes the foundations more consequential: engineers increasingly judge systems whose detailed implementation they did not personally construct.

The curriculum therefore remains substantially recognizable. Programming does not disappear, nor does software engineering, and neither do the computing foundations on which they depend. Engineers still need enough implementation fluency to understand the systems they build, diagnose failures, evaluate generated work, and descend through abstractions when necessary.

Diagnosing a failure may require examining the realized system and then translating what was learned into a change to its governing models. The engineer must be able to move between the behavior of the implementation and the representations that direct subsequent work. This does not require personally producing every implementation, but it does require enough technical understanding to recognize when the governing abstractions are inadequate. Engineers still need the disciplinary foundations that make those judgments possible.

What changes is the allocation of attention. Routine implementation is already becoming cheap enough to alter the engineering problem. Specification, validation, coordination, and judgment have not become correspondingly abundant. Education should reflect that shift. The question is therefore less what subjects disappear than which competencies deserve more or less practice.

Chapter 6 explains why these competencies matter, and the four trajectories in Table 7.1-1 explain why their relative importance may continue to move. They may advance unevenly. Education must prepare engineers to judge that changing allocation of work, rather than train them for one presumed destination.

Shift the emphasis

Less educational effort may need to go toward producing routine implementation by hand, and more toward selecting abstractions, specifying properties, measuring systems, validating claims, reasoning about quality attributes, and governing autonomous work. Modeling, specification, architecture, measurement, programming languages, and formal methods deserve more room because these fields teach durable ways to choose abstractions, state properties precisely, make invalid states harder to express, and separate a claim from the evidence that establishes it. Students should also learn to distinguish improving a reasoner's context from improving the representation of the engineering problem itself. This does not require every engineer to become a language theorist, systems modeler, or verification specialist.

Coordination deserves greater emphasis as well. An engineer directing several autonomous workstreams must decompose a larger objective, identify dependencies and integration points, sequence work where necessary, monitor progress and risk, and reconcile independently produced results. These are familiar project-management competencies, but agentic capacity changes the scale at which they become technical concerns: an individual engineer may command enough parallel implementation capacity to face coordination problems that previously arose mainly at team scale. This does not make every software engineer a project manager. It makes decomposition, dependency management, sequencing, and integration part of the technical problem of converting abundant implementation capacity into coherent engineering progress.

ENGINEERING EDUCATION

Inset — A software-engineering curriculum for the agentic era

The curricular argument in this section is developed more concretely in The Software Engineering Handbook: A Judgment and Decision-Making Approach. The Handbook is intended as a companion to MAGE, but it starts from a different question. MAGE asks how software engineering changes when implementation can increasingly be delegated. The Handbook asks what software engineers need to know and what decisions they need to be able to make. Its subjects are deliberately traditional: process, teamwork, engineering knowledge, requirements, specification, architecture, design, validation, and research and development.

Like MAGE, the Handbook treats software engineering as a discipline of engineering judgment rather than a recipe for producing implementation. Each subject is organized around the decisions it supports: what must be known, what should be made explicit, what should be fixed and what should remain open, which alternatives deserve consideration, what evidence bears on the choice, and when there is enough information to decide. Commodity intelligence does not make this curriculum obsolete. It makes the judgment underneath it more important.

Change what students demonstrate

A capstone should therefore demonstrate more than a working artifact. Ask students to bring the engineering case.‡‡ Existing accreditation already asks for a culminating design experience that integrates standards and multiple constraints and builds on earlier coursework, with software-specific criteria adding requirements analysis, security, verification and validation, and processes for complex software systems 19.19. ABET Engineering Accreditation Commission, “Criteria for Accrediting Engineering Programs, 2025–2026,” ABET, 2025, https://www.abet.org/accreditation/accreditation-criteria/criteria-for-accrediting-engineering-programs-2025-2026/. Computing-accredited programs likewise require a major integrative project 20.20. ABET Computing Accreditation Commission, “Criteria for Accrediting Computing Programs, 2025–2026,” ABET, 2025, https://www.abet.org/accreditation/accreditation-criteria/criteria-for-accrediting-computing-programs-2025-2026/. The open question is not whether students should integrate their knowledge but what should count as evidence that they have — which is why the capstone should carry the engineering case, not only the demo. The artifact should be one component of that case, alongside requirements, models, tradeoffs, measurements, validation evidence, and an explicit argument for acceptance. Students should also demonstrate that they can organize substantial work: decompose an objective, manage dependencies and integration, coordinate parallel realization, and adapt the plan as engineering evidence arrives. This extends the integrative purpose of the capstone by asking students to show how they exercised informed control over the system. They should be able to explain which evidence supports its consequential properties, recognize the assumptions and tradeoffs behind that evidence, and justify accepting the result.

Assessment must distinguish between work students performed themselves and work they directed and evaluated. A successful implementation can demonstrate that a production arrangement worked without establishing that the student understood its assumptions, recognized consequential decisions, or could intervene when the arrangement failed. Both direct technical work and the competent direction of delegated work are legitimate educational outcomes, but they require different evidence.

Program objectives may need to change less than daily engineering work does. In my view, most engineering programs need little change in what they claim an engineer should become. The larger change is in how students practice and demonstrate those capabilities.

The durable curriculum should not be organized around the current agent interface. Prompt conventions, harness architectures, model APIs, and context-management techniques matter in practice and students should use them, but they change too quickly to define the intellectual core. Teach the principles beneath them—finite reasoning and abstraction, representation and fidelity, action boundaries and authority, independent evidence, security, measurement, and the design of environments in which uncertain components can be used safely—and let students encounter current agents throughout the curriculum.

7.4.5 The Entry-Rung Problem

The traditional path into software engineering runs through implementation. Junior engineers become useful by writing code, and through that work they encounter larger systems, learn why designs fail, and gradually acquire the judgment needed to take responsibility for more of the system. GenAI changes this apprenticeship model. If routine implementation requires fewer people, the profession loses some of the work through which it has historically trained its future senior engineers.

This creates an entry-rung problem. Requirements discovery, modeling, security, systems reasoning, validation, and engineering judgment are harder to teach through a short framework-oriented path—and they are also the capabilities that become more valuable when implementation is abundant. Practitioners concentrated in implementation therefore need paths into architecture, assurance, modeling, and system responsibility. New entrants need ways to acquire those foundations even if the market demands less handwritten construction. The deeper educational problem is how students acquire the engineering judgment that routine implementation previously helped them develop through experience. The companion Software Engineering Handbook is one attempt to address this problem directly: it organizes an undergraduate software engineering core around judgment and decision-making rather than treating implementation technique as the center of the discipline 14.14. James C. Davis, The Software Engineering Handbook: A Judgment and Decision-Making Approach, 1st ed. (2026), https://davisjam.github.io/model-based-agentic-software-engineering/book/se-handbook/index.html.

The profession cannot define itself by a stable residue of tasks left to humans; those tasks will continue to move as capabilities improve. Its educational challenge is to develop people who can take responsibility for the engineered whole, even when much of the work through which earlier generations learned is delegated.

Works Cited

  1. Bugliarello, George. “The Social Function of Engineering: A Current Assessment.” In Engineering as a Social Enterprise. National Academy Press, 1991.
  2. National Academies of Sciences, Engineering, and Medicine. Building Resilience into the Nation’s Medical Product Supply Chains. National Academies Press, 2022. https://doi.org/10.17226/26420.
  3. U.S. Food and Drug Administration. “Personnel Qualifications.” 21 C.F.R. § 211.25.
  4. Federal Food, Drug, and Cosmetic Act § 506C(j), 21 U.S.C. § 356c(j).
  5. U.S. Food and Drug Administration. “Emergency Preparedness and Medical Devices: Supply Chain Recommendations for Health Care Providers and Medical Device Manufacturers.” Accessed September 11, 2026.
  6. Presidential Commission on the Space Shuttle Challenger Accident. Report of the Presidential Commission on the Space Shuttle Challenger Accident, Volume 1. U.S. Government Printing Office, 1986.
  7. Columbia Accident Investigation Board. Columbia Accident Investigation Board Report, Volume 1. National Aeronautics; Space Administration, 2003.
  8. U.S. Department of Justice, Office of Public Affairs. Volkswagen Engineer Pleads Guilty (2016) and Is Sentenced to 40 Months in Prison (2017) for His Role in the Conspiracy to Cheat U.S. Emissions Tests. U.S. Department of Justice press releases, 2017.
  9. U.S. Senate Committee on Commerce, Science, and Transportation. Protecting Kids Online: Facebook, Instagram, and Mental Health Harm. 117th Cong., 1st sess., S. Hrg. 117-719, 2021.
  10. U.S. Senate Committee on the Judiciary. Social Media and the Teen Mental Health Crisis. 118th Cong., 1st sess., testimony of Arturo Béjar, 2023.
  11. Vella, Annie, and Kelly Blincoe. The Impact of AI Coding Assistants on Software Engineering: A Longitudinal Study. arXiv preprint arXiv:2605.23135, 2026. https://arxiv.org/abs/2605.23135.
  12. Brooks, Frederick P. “No Silver Bullet: Essence and Accidents of Software Engineering.” Computer 20, no. 4 (1987): 10–19.
  13. Stack Overflow. “2024 Stack Overflow Developer Survey.” Stack Overflow, 2024. https://survey.stackoverflow.co/2024/.
  14. Davis, James C. The Software Engineering Handbook: A Judgment and Decision-Making Approach. 1st ed. 2026. https://davisjam.github.io/model-based-agentic-software-engineering/book/se-handbook/index.html.
  15. National Society of Professional Engineers. “Responsible Charge.” NSPE, 2024.
  16. National Society of Professional Engineers. “Licensure Exemptions.” NSPE, 2023.
  17. Future of Life Institute. Pause Giant AI Experiments: An Open Letter. Open letter, 2023.
  18. Herbert, Frank. Dune. Chilton Book Company, 1965.
  19. ABET Engineering Accreditation Commission. “Criteria for Accrediting Engineering Programs, 2025–2026.” ABET, 2025. https://www.abet.org/accreditation/accreditation-criteria/criteria-for-accrediting-engineering-programs-2025-2026/.
  20. ABET Computing Accreditation Commission. “Criteria for Accrediting Computing Programs, 2025–2026.” ABET, 2025. https://www.abet.org/accreditation/accreditation-criteria/criteria-for-accrediting-computing-programs-2025-2026/.
© James C. Davis, 2026–present