Skip to content

§7.1 The Reorganization of Software Work

In software, MAGE is software engineering under changed economics. The analysis in Chapter 6 leaves a practical question: how should the profession reorganize its work when implementation and routine analysis become cheaper?

7.1.1 Was Implementation Ever the Bottleneck?

A reasonable objection begins with a fact: software engineers do not spend most of their workweek typing code. This result predates generative AI. Meyer et al., drawing on 5,971 responses from professional developers, found that software work spans a much broader mixture of development and non-development activities. More recently, Kumar et al. separated the developer workweek into sixteen activities; in their Microsoft sample, coding new features occupied roughly 11 percent of the actual week, alongside debugging, architecture and design, code review, testing, refactoring, environment work, security, communication, and other activities.** André N. Meyer et al.; 11. André N. Meyer et al., “Today Was a Good Day: The Daily Life of Software Developers,” IEEE Transactions on Software Engineering 47, no. 5 (2021): 863–80, https://doi.org/10.1109/TSE.2019.2904957. Sukrit Kumar et al. 2.2. Sukrit Kumar et al., “Time Warp: The Gap Between Developers’ Ideal vs Actual Workweeks in an AI-Driven Era,” Proceedings of the 2025 IEEE/ACM 47th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP), 2025, 12–22, https://doi.org/10.1109/ICSE-SEIP66354.2025.00007. Kumar et al. distinguish sixteen activities and report approximately 12 percent of the actual week in communication and meetings, 11 percent in coding, 9 percent in debugging, 6 percent in architecture and design, and 5 percent in pull-request and code review.

Butler et al. turn that observation into a critique of contemporary GenAI.†† These developer-time studies describe how work was allocated before today's stronger autonomous coding agents; I use them as evidence about work allocation, not as an empirical ceiling on what later bounded agents can perform. If the technology merely makes the coding slice faster, its whole-job effect has a low ceiling. Even if coding occupies only roughly 10–15 percent of the workweek, doubling performance on it cannot double developer productivity; faster source production can simply move pressure downstream into review, testing, integration, and other work. Their criticism applies well to GenAI used as individual code-generation assistance. It also supports a broader point MAGE shares: lines of generated code are not an engineering outcome, and handing developers a tool does not by itself redesign the system of work around them.‡‡ Jenna Butler et al. 3.3. Jenna Butler et al., “Eight Myths on Software Engineering and GenAI,” Queue 24, no. 2 (2026), https://doi.org/10.1145/3807963. The article's "Writing Code Is the Bottleneck" discussion explicitly frames the problem as GenAI used primarily to accelerate code creation while the surrounding development loop remains unchanged.

The disagreement begins when that fixed slice is treated as a bound on agentic engineering. Time categories are not independent production stages. Software engineers learn about a design by realizing it: implementation exposes missing abstractions; debugging changes what we believe about behavior; tests expose underspecified obligations; refactoring discovers structure; deployment reveals couplings that static design did not anticipate. This interleaving is not a new observation. Ralph's Sensemaking–Coevolution–Implementation theory models software development as repeated movement among understanding the context, revising the problem and design together, and constructing, debugging, and deploying the artifact; a later multi-method study using more than 1,300 developers and four longitudinal cases strongly supported that process account.§§ Paul Ralph, the Sensemaking–Coevolution–Implementation theory, 44. Paul Ralph, “The Sensemaking–Coevolution–Implementation Theory of Software Design,” Science of Computer Programming 101 (2015): 21–41, https://doi.org/10.1016/j.scico.2014.11.007. and its multi-method follow-through, 55. Paul Ralph, “Software Engineering Process Theory: A Multi-Method Comparison of Sensemaking–Coevolution–Implementation Theory and Function–Behavior–Structure Theory,” Information and Software Technology 70 (2016): 232–50, https://doi.org/10.1016/j.infsof.2015.06.010. which combined a survey of more than 1,300 developers with four longitudinal case studies and reported strong support for the SCI account. For an older and deliberately stronger version of the "implementation is design" argument, see Jack W. Reeves 6.6. Jack W. Reeves, “What Is Software Design?” C++ Journal, 1992, https://www.developerdotstar.com/mag/articles/reeves_design.html.

MAGE therefore uses implementation capacity in an economic rather than time-sheet sense. Every design hypothesis that has to be realized before the team can learn from it imposes a cost, even if the eventual keystrokes occupy only a small fraction of the calendar. Reduce that cost sufficiently and more alternatives become affordable, feedback arrives sooner, and intelligence can participate in more of the surrounding loop. Modern coding agents already reach beyond source generation into repository inspection, debugging, test construction, refactoring, tool execution, and multi-step changes. Whether they can safely take on still more of that loop is exactly the engineering question MAGE addresses.

This makes the disagreement empirically testable. If assistance accelerates only code writing while the surrounding work stays unchanged, the fixed-slice argument largely holds. If governed agents can assume meaningful portions of debugging, testing, refactoring, integration, migration, and operation without proportionate growth in human review, a fixed coding-time slice is no longer the right model of attainable leverage. The relevant boundary is the work delegated and the supervision it requires. MAGE asks how to cross that boundary without losing engineering control.

DevOps offers a particularly close precedent. Infrastructure as Code and Policy as Code moved knowledge that once lived in operating practice into executable artifacts. MAGE generalizes the move without insisting on code as the form: an engineering decision might become a type, model, schema, validator, permission, workflow, or documented review obligation. Useful engineering knowledge increasingly becomes structure later work can inherit; residual semantic judgment remains with people.

7.1.2 Agents Entered an Implementation-Centered Discipline

The first generation of agentic software-engineering research inherited the engineering object already in front of it: a repository and a software-development task. The central question was how to make an increasingly capable reasoner perform that task more effectively.

The progression is instructive. Early agentic software-engineering research improved agents' ability to work with existing software artifacts. Repository retrieval made relevant code and documentation available during implementation 7.7. Fengji Zhang et al., “RepoCoder: Repository-Level Code Completion Through Iterative Retrieval and Generation,” Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (Singapore), 2023, 2471–84. Purpose-built interfaces improved an agent's ability to navigate repositories, edit files, and execute tests 8.8. John Yang et al., “SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering,” Advances in Neural Information Processing Systems 37, 2024. Program analysis helped agents locate and reason about changes by exploiting program structure rather than treating a project as a collection of files 9.9. Yuntong Zhang et al., “AutoCodeRover: Autonomous Program Improvement,” Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA ’24) (New York), 2024, https://doi.org/10.1145/3650212.3680384. More recent work has also attempted to infer specifications from existing artifacts 10.10. Haifeng Ruan et al., “SpecRover: Code Intent Extraction via LLMs,” Proceedings of the 47th IEEE/ACM International Conference on Software Engineering, 2025, https://doi.org/10.1109/ICSE55347.2025.00080. These developments improve how agents understand and modify software, and establish important foundations for autonomous implementation. They share an orientation: improving the machinery an agent uses to act on the software artifact.

Research on agent governance provides another important antecedent. Existing methods translate organizational and regulatory obligations into technical controls and assign those controls across design-time, runtime, and assurance layers 11.11. Christopher Koch, From Governance Norms to Enforceable Controls: A Layered Translation Method for Runtime Guardrails in Agentic AI, arXiv preprint arXiv:2604.05229, 2026, https://arxiv.org/abs/2604.05229. Other frameworks evaluate a proposed action against policies that depend on the agent's execution history 12.12. Maurits Kaptein et al., Runtime Governance for AI Agents: Policies on Paths, arXiv preprint arXiv:2603.16586, 2026, https://arxiv.org/abs/2603.16586. Governance-by-construction systems demonstrate how policy enforcement can be integrated into an agent's operating environment 13.13. Segev Shlomov et al., Governance by Construction for Generalist Agents, arXiv preprint arXiv:2605.20874, 2026, https://arxiv.org/abs/2605.20874. These approaches develop architectures and methods for governing agentic systems. MAGE's governance-conversion process additionally accounts for how failures encountered during implementation reveal missing obligations or controls, and how engineers preserve those lessons for subsequent work.

MAGE accepts that machinery and enlarges the engineering object. The question is no longer only how an agent should navigate a repository, retrieve context, use tools, or construct a patch. It is what durable environment should be engineered around autonomous implementation: which system properties deserve explicit representation; which obligations deserve enforcement; what evidence work must produce; how representations remain in correspondence with the implementation; and how recurring judgment becomes machinery inherited by later work.

The difference is one of level, not opposition. Repository retrieval, structured code search, agent-computer interfaces, tests, and tool use all belong inside a governed engineering environment. MAGE's claim is that they are pieces of a larger engineered substrate rather than accessories to a coding agent.

7.1.3 The Old Dream, with a New Substrate

The ambition predates today's coding agents. In the 1980s, Charles Rich and Richard Waters's Programmer's Apprentice envisioned an AI system not merely as a programming tool but as an agent in the software process. The engineer would share programming knowledge with the Apprentice and delegate work across implementation, design, requirements, verification, explanation, and documentation 14.14. Charles Rich and Richard C. Waters, “The Programmer’s Apprentice Project: A Research Overview,” Computer 21, no. 11 (1988): 10–25, https://doi.org/10.1109/2.86782. Its internal representations made programming concepts explicit so that routine questions could be answered from represented knowledge rather than reconstructed from first principles.

The project realized important pieces of that vision, but under different constraints. Its intelligence depended heavily on programming knowledge deliberately encoded into specialized representations; Rich and Waters themselves observed that the economics failed when too much knowledge had to be supplied for each problem. Commodity intelligence changes that premise. A general-purpose reasoner can now arrive with substantial prior competence, enter an unfamiliar repository, use tools, interpret natural-language intent, and construct substantial implementations without the engineering organization first encoding everything it might need to know.

Earlier systems could demonstrate pieces of that vision; today's systems realize enough of it to expose the next-order engineering problems: keeping representations trustworthy, deciding which obligations deserve enforcement, producing evidence at agentic velocity, and converting recurring judgment into machinery that later work inherits.

7.1.4 Where Engineering Effort Moves

As commodity intelligence assumes more implementation and routine engineering work, human effort shifts toward directing that work and governing its results. Figure 7.1-1 illustrates two related changes: delegation transfers work to agents, while governance conversion preserves recurring engineering judgment in durable structure. The latter calls for Modeling to represent consequential knowledge and obligations, and Alignment to establish evidence, constraints, and controls. These are broad directions rather than a fixed allocation of effort; their relative importance depends on which capabilities improve and what investments become economical.

Where engineering effort moves Delegation shifts implementation and routine work to agents, while engineers retain judgment. Governance conversion turns recurring judgment into models, controls and evidence in the governed engineering environment. Pre-GenAI allocation Agentic engineering Implementation is a major claim on human effort. More implementation is delegated, and more judgment is preserved in structure. Human engineering work Requirements and intent Design and abstractions Implementation Review and acceptance Operation and adaptation Human engineering judgment Intent and abstractions Modeling: consequential knowledge and obligations Alignment: evidence, constraints, and controls Tradeoffs and acceptance Adaptation Commodity intelligence Implementation Analysis Transformation Routine remediation Delegation Shifts more implementation and routine work to agents. Engineering tools and processes CI/CD and build automation Tests and test infrastructure Static analysis and quality checks Repositories and code review Coding standards and policies Governed engineering environment Models and context Constraints and permissions Evidence and validators Admission Operational controls Governance conversion Turns recurring judgment into durable, reusable structure.
Figure 7.1-1. Where Engineering Effort Moves. As the fleet assumes work across the lifecycle, the engineer increasingly works through the surrounding engineering environment: specifying intent, choosing consequential abstractions, evaluating evidence, resolving tradeoffs, and adapting the environment itself.

Where that displaced effort settles depends on which parts of the production system become cheaper and more reliable. Chapter 6 supplies the distinctions. Faithful production through a representation R depends on whether consequential intent is encoded in it (P(E∣R)) and whether the agent fulfills those obligations (P(F∣E,R)). Interpretation contributes to the second term. Governance separately concerns which unacceptable results the mechanisms detect, reject, or prevent. Cost includes realization attempts and the work required to keep representations and controls useful as the software changes. The engineer chooses the representation and the Alignment strategy together against those quantities.

Technological progress can move these terms independently. Reasoners can improve. So can the machinery for constructing and maintaining representations, the machinery for realizing them, and the machinery for detecting and refusing unacceptable results. These four are not a taxonomy of tools. They are the independent variables that prevent a single confident forecast. Table 7.1-1 sketches how each would redirect engineering effort. The correspondence is deliberately not one term per row: an improvement can change several terms at once, and representation machinery changes probabilities and costs alike.

Table 7.1-1. Possible movements of engineering effort. Improvements in different parts of the production system act on different terms of the Chapter 6 engineering problem. The trajectories can proceed independently and in combination, so the rows describe the pressures each would create rather than a forecast of a single future process.
Technological trajectory and terms affectedWhat becomes economicalEngineering effort moves toward
Reasoners improve: P(F∣E,R)↑Reasoning successfully from less complete representations, and leaving more legitimate choices unresolved until realizationChoosing consequential distinctions, bounding degrees of freedom, and judging results rather than specifying every realization choice
Representation machinery improves: P(E∣R)↑, P(F∣E,R)↑, lower upkeepConstructing, maintaining, reconciling, and querying explicit representationsChoosing abstractions, validating representations, and maintaining correspondence among them and with the system
Realization machinery improves: P(F∣E,R)↑, lower realization costReliably transforming sufficiently complete representations into implementations, potentially deterministicallySpecifying and validating what should be realized rather than supervising how it is implemented
Governance machinery improves: less escaped failure, lower upkeepDetecting, rejecting, or preventing unacceptable realizations independently of the producing reasonerChoosing which obligations require enforcement, placing controls, and judging residual risk

Because these trajectories need not proceed together, commodity intelligence does not fix a single destination for software engineering. Better reasoners let engineering leave more legitimate freedom unresolved. The engineer states the consequential distinctions and lets realization choose among the acceptable possibilities. As Chapter 6 shows, faithful production approaches P(E∣R) when conditional realization approaches one and encoding quality is held fixed. Agents may infer omitted intent, but reliable fulfillment alone does not establish that the encoded obligations were right. Capability therefore moves effort toward deciding which distinctions are consequential; it does not retire the obligation to encode them.

If explicit representations become cheap to construct, maintain, and reconcile, engineers can profitably externalize more consequential knowledge. The modeling work developed in Chapter 2 then becomes economical for more questions: choosing useful abstractions and maintaining their claimed correspondence with the system.

Retrieval and representation engineering address different questions. Retrieval selects information to place before a reasoner; representation engineering asks whether a different form would make the engineering question easier to answer. An agent might retrieve enough source to reconstruct an architectural dependency, or work over a dependency model in which that relation is already explicit. The first improves access to the implementation; the second changes the representation over which reasoning proceeds. The two can be combined: a context pipeline may retrieve the dependency model itself.

Program comprehension and architecture recovery make this economic choice concrete. Their established methods recover higher-level views from source, execution, and other evidence 151617.15. Elliot J. Chikofsky and James H. Cross II, “Reverse Engineering and Design Recovery: A Taxonomy,” IEEE Software 7, no. 1 (1990): 13–17, https://doi.org/10.1109/52.43044.16. Stéphane Ducasse and Damien Pollet, “Software Architecture Reconstruction: A Process-Oriented Taxonomy,” IEEE Transactions on Software Engineering 35, no. 4 (2009): 573–91, https://doi.org/10.1109/TSE.2009.19.17. Bas Cornelissen et al., “A Systematic Survey of Program Comprehension through Dynamic Analysis,” IEEE Transactions on Software Engineering 35, no. 5 (2009): 684–702, https://doi.org/10.1109/TSE.2009.28. If agents make accurate recovery cheaper, they can lower the cost of realization and improve P(F∣E,R) by reducing reconstruction cost and exposing the dependencies relevant to a change. Recovery does not automatically improve P(E∣R): existing structure and observed behavior do not establish what the system ought to do. Engineers must compare recovering a view on demand with retaining it as engineering capital, whose future reuse must justify its construction and carrying costs.

This trajectory changes the price of representation work, not its nature. It makes a larger investment in representations economical without establishing that such an investment will dominate software engineering.

If realization from a sufficiently complete representation becomes cheap and reliable, engineering effort moves further upstream. Little consequential freedom then remains downstream of the representation, and transformation or generation can replace autonomous realization wherever the representation determines the implementation. §7.2 examines the engineering tradition that already works this way.

If strong controls become cheap, engineers can tolerate more freedom in realization while independently checking the consequential results. Validators, monitors, and admission checks can reduce the chance that unacceptable work is admitted when they detect violations and trigger an effective rejection or intervention. Lower cost makes that coverage more economical to construct and maintain; it does not by itself make a check sound. Effort then moves toward deciding which obligations deserve enforcement, placing the controls that enforce them, and judging the risk that remains. Under this trajectory an organization can become far more governed without becoming more model-driven.

Real engineering environments will combine these trajectories, often differently for different properties of the same system. A system might maintain an authoritative state model where invalid transitions are consequential, allow an agent wide implementation freedom locally, derive architectural views when a question needs them rather than maintain them, and enforce security and dependency obligations at admission.

The appropriate unit of analysis is therefore usually the engineering question or obligation, not the development methodology.

Model-driven engineering is one plausible destination, reached when improvements in representation and realization machinery reinforce one another. Cabot's proposal for vibe-driven model-based engineering keeps models as the pillar of development while letting AI assist their construction and, where a model determines the implementation, their realization through deterministic generators 18.18. Jordi Cabot, Vibe-Driven Model-Based Engineering, arXiv preprint arXiv:2604.10645, 2026, https://arxiv.org/abs/2604.10645. That is one combination of the trajectories in Table 7.1-1: AI lowers the cost of constructing and manipulating explicit models while model-based realization stays attractive. MAGE includes that future. It does not predict it. The opposite combination is equally available. If reasoners become good at reconstructing trustworthy task-specific representations from implementation, carrying separately maintained models may become less attractive for many questions.

Commodity intelligence changes the economics of representation and control without determining their eventual form.

More modeling need not mean more permanently maintained models. Agents can make it economical to construct a dependency graph, a state abstraction, a quantitative model, or another purposeful reduction for one consequential question and discard it afterward. Construction cost must be repaid by the value of the reasoning it enables. Repeated reuse is one way to earn that return; answering a sufficiently consequential question once is another. Cheaper construction expands the range of one-off questions for which a model pays. A model can matter because reasoning passes through it today; an organization need not preserve it forever.

Whichever trajectory dominates, recurring judgment remains an opportunity for governance conversion. The conversion and ratcheteering developed in Chapter 4 let later work inherit that judgment while keeping the resulting structure open to correction. The professional question is whether the judgment belongs in the next reviewer's head or whether future work should inherit it from the environment.

The answer is not always "mechanize." Guidance remains useful where interpretation is semantic; human review remains appropriate where consequence or ambiguity warrants it; and every new mechanism adds carrying cost. The goal is to mechanize where doing so pays. Engineers make that choice one obligation at a time, under economics that have not finished moving.

7.1.5 Review When Implementation Is Abundant

Code review does not disappear when agents produce the code. Its center of gravity moves.

At low change volume, an experienced engineer can treat the diff itself as the principal reasoning surface. Read the implementation, reconstruct the surrounding architecture, infer the affected behavior, inspect the tests, decide whether the change belongs. That strategy stops scaling as implementation becomes abundant. The scarce resource is no longer the ability to produce another diff. It is the engineer's ability to determine what the change means.

This pressure predates agents. Long before agentic programming, empirical work at Microsoft found that larger changes were harder to review well: as more files were touched, the proportion of useful reviewer feedback declined, and large changes imposed greater reviewer effort 19.19. 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. Agentic generation makes that problem larger; it does not change its basic cognitive shape. The older result establishes that large changes tax human review and reduce useful feedback. It does not establish that explicit models would relieve the strain; models as the remedy are MAGE's proposal.

Greiler's more recent SCOPE proposal responds by changing the review operating model: detailed implementation review moves increasingly into the developer–agent loop, and team review becomes risk-proportional assurance over code together with higher-level artifacts and evidence 20.20. Michaela Greiler, “From Peer Review to Self-Review: The Epistemic Risk of Agentic Development,” July 2026, https://www.michaelagreiler.com/code-reviews-from-team-to-individual/. That proposal already includes agent review, developer attestation, risk-based team assurance, and accountability. SCOPE changes the operating model for review; MAGE additionally changes the surfaces available to the reviewer. When the environment holds explicit models of structure, behavior, ownership, execution, measurement, and provenance, those models become review surfaces in their own right. The engineer need not reconstruct every relevant property from the diff.

Explicit models provide intermediate review surfaces. A change can be projected onto component ownership, permitted dependencies, service edges, lifecycle states, deployment placement, user journeys, measurement obligations, and provenance. Deterministic mechanisms discharge the obligations that are mechanically decidable before scarce human attention is spent. The reviewer then spends attention on the remainder:

  • Is the intended change desirable — the question a diff could never answer on its own.
  • Do the models capture the relevant concern — or has the change moved a property no current representation exposes.
  • Is the evidence sufficient — do the checks that ran actually bound the risk this change carries.
  • Should the tradeoff be accepted — the residual judgment that stays with a person.

Implementation becomes one evidentiary surface among several, rather than the origin from which every system property must be reconstructed. The reviewer still examines implementation details when they are necessary to evaluate the risk. The models supply an index into the engineering significance of a change.

In the terms of Chapter 6, these representations can reduce the cost of evaluating a realization without necessarily improving the probability that the agent produces an acceptable one.

Review moves upstream, from inspecting realization toward evaluating intent, consequence, evidence, and the judgment that remains. Some argue that capable coding agents will eliminate human code review altogether 21.21. Martin Monperrus, The End of Code Review: Coding Agents Supersede Human Inspection, arXiv preprint arXiv:2606.13175, 2026, https://arxiv.org/abs/2606.13175. Even if code review disappears, engineers must still evaluate the models, evidence, and tradeoffs that govern the resulting software.

Appendix A examines selected DocAble models, their consumers, and the checks that maintain correspondence with the implementation. These examples illustrate the engineering surfaces available for review without prescribing a fixed catalog of models.

This shift in review surfaces has a broader implication: effective engineering capability may increasingly be a property of the environment as well as the foundation model. A weaker reasoner operating over accurate representations, well-routed context, strong tools, and independent evidence may outperform a stronger reasoner over an opaque repository. MAGE does not establish that substitution quantitatively; §6.4 asks how capability and environment substitute for or complement one another, and how those comparisons might inform engineering routing.

7.1.6 Engineering the Production System

Chapter 5 distinguished two places engineering attention can go as realization becomes abundant. Engineers can spend increasing effort operating agentic machinery: supplying work and context, coordinating agents, inspecting output, and resolving exceptions. They can also engineer the production system around that machinery so that selected knowledge, evidence, and controls persist across acts of realization.

Both futures can contain capable agents and very little human implementation. They differ in where scarce engineering judgment goes. MAGE predicts increasing value in designing and revising the production environment: deciding what it must preserve, how it establishes acceptability, and which choices it can safely leave to agents.

Making agents easier to operate is not the same as making software easier to engineer.

This is not a new lifecycle phase. Requirements, design, validation, operation, and maintenance remain. What changes is that engineers increasingly exercise those responsibilities through the production system in which agents work. The next section places that arrangement within the longer history of engineering through explicit representations and controls.

Works Cited

  1. Meyer, André N., Earl T. Barr, Christian Bird, and Thomas Zimmermann. “Today Was a Good Day: The Daily Life of Software Developers.” IEEE Transactions on Software Engineering 47, no. 5 (2021): 863–80. https://doi.org/10.1109/TSE.2019.2904957.
  2. Kumar, Sukrit, Drishti Goel, Thomas Zimmermann, Brian Houck, Balasubramanyan Ashok, and Chetan Bansal. “Time Warp: The Gap Between Developers’ Ideal vs Actual Workweeks in an AI-Driven Era.” Proceedings of the 2025 IEEE/ACM 47th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP), 2025, 12–22. https://doi.org/10.1109/ICSE-SEIP66354.2025.00007.
  3. Butler, Jenna, Brian Houck, Margaret-Anne Storey, Travis Lowdermilk, Steven Clarke, and Emerson Murphy-Hill. “Eight Myths on Software Engineering and GenAI.” Queue 24, no. 2 (2026). https://doi.org/10.1145/3807963.
  4. Ralph, Paul. “The Sensemaking–Coevolution–Implementation Theory of Software Design.” Science of Computer Programming 101 (2015): 21–41. https://doi.org/10.1016/j.scico.2014.11.007.
  5. Ralph, Paul. “Software Engineering Process Theory: A Multi-Method Comparison of Sensemaking–Coevolution–Implementation Theory and Function–Behavior–Structure Theory.” Information and Software Technology 70 (2016): 232–50. https://doi.org/10.1016/j.infsof.2015.06.010.
  6. Reeves, Jack W. “What Is Software Design?” C++ Journal, 1992. https://www.developerdotstar.com/mag/articles/reeves_design.html.
  7. Zhang, Fengji, Bei Chen, Yue Zhang, et al. “RepoCoder: Repository-Level Code Completion Through Iterative Retrieval and Generation.” Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing (Singapore), 2023, 2471–84.
  8. Yang, John, Carlos E. Jimenez, Alexander Wettig, et al. “SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering.” Advances in Neural Information Processing Systems 37, 2024.
  9. Zhang, Yuntong, Haifeng Ruan, Zhiyuan Fan, and Abhik Roychoudhury. “AutoCodeRover: Autonomous Program Improvement.” Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA ’24) (New York), 2024. https://doi.org/10.1145/3650212.3680384.
  10. Ruan, Haifeng, Yuntong Zhang, and Abhik Roychoudhury. “SpecRover: Code Intent Extraction via LLMs.” Proceedings of the 47th IEEE/ACM International Conference on Software Engineering, 2025. https://doi.org/10.1109/ICSE55347.2025.00080.
  11. Koch, Christopher. From Governance Norms to Enforceable Controls: A Layered Translation Method for Runtime Guardrails in Agentic AI. arXiv preprint arXiv:2604.05229, 2026. https://arxiv.org/abs/2604.05229.
  12. Kaptein, Maurits, Vassilis-Javed Khan, and Andriy Podstavnychy. Runtime Governance for AI Agents: Policies on Paths. arXiv preprint arXiv:2603.16586, 2026. https://arxiv.org/abs/2603.16586.
  13. Shlomov, Segev, Iftach Shoham, Alon Oved, et al. Governance by Construction for Generalist Agents. arXiv preprint arXiv:2605.20874, 2026. https://arxiv.org/abs/2605.20874.
  14. Rich, Charles, and Richard C. Waters. “The Programmer’s Apprentice Project: A Research Overview.” Computer 21, no. 11 (1988): 10–25. https://doi.org/10.1109/2.86782.
  15. Chikofsky, Elliot J., and James H. Cross II. “Reverse Engineering and Design Recovery: A Taxonomy.” IEEE Software 7, no. 1 (1990): 13–17. https://doi.org/10.1109/52.43044.
  16. Ducasse, Stéphane, and Damien Pollet. “Software Architecture Reconstruction: A Process-Oriented Taxonomy.” IEEE Transactions on Software Engineering 35, no. 4 (2009): 573–91. https://doi.org/10.1109/TSE.2009.19.
  17. Cornelissen, Bas, Andy Zaidman, Arie van Deursen, Leon Moonen, and Rainer Koschke. “A Systematic Survey of Program Comprehension through Dynamic Analysis.” IEEE Transactions on Software Engineering 35, no. 5 (2009): 684–702. https://doi.org/10.1109/TSE.2009.28.
  18. Cabot, Jordi. Vibe-Driven Model-Based Engineering. arXiv preprint arXiv:2604.10645, 2026. https://arxiv.org/abs/2604.10645.
  19. 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.
  20. Greiler, Michaela. “From Peer Review to Self-Review: The Epistemic Risk of Agentic Development.” July 2026. https://www.michaelagreiler.com/code-reviews-from-team-to-individual/.
  21. Monperrus, Martin. The End of Code Review: Coding Agents Supersede Human Inspection. arXiv preprint arXiv:2606.13175, 2026. https://arxiv.org/abs/2606.13175.
© James C. Davis, 2026–present