§4.4 Engineering the Environment
The engineering environment accumulates models, controls, procedures, and evidence. Maintaining its usefulness requires four kinds of work: equip the reasoner, evaluate proposed work, operate the supporting machinery, and maintain what later tasks inherit.
4.4.1 Equip the Reasoner
There are two complementary ways to improve recurring engineering work. One is to improve the conditions under which a reasoner makes a judgment: give it better representations, domain knowledge, examples, procedures, tools, and context so that a satisfactory realization becomes more likely. The other is to enforce selected obligations in the environment so that satisfying them does not depend entirely on the reasoner choosing correctly.
Both effects can come from the same artifact. A model can guide an agent and state properties consumed by a validator. A runbook can brief a reasoner and trigger a gate. Evidence can inform a decision or feed a gate. A governed engineering environment composes these roles rather than assigning each artifact permanently to one side.
Distributed cognition provides a useful frame for this composition: reasoning can be performed by a system of people, representations, procedures, and artifacts rather than one isolated individual. The inset explains the connection 1.1. Edwin Hutchins, Cognition in the Wild (MIT Press, 1995).
COGNITIVE SCIENCEInset — The GEE as a Distributed Cognitive System
Studies of distributed cognition ask us to move the boundary of analysis outward. Edwin Hutchins's classic study of ship navigation, for example, does not explain navigation solely by asking what one navigator knows. Position is established through a system of people with different roles, instruments, charts, procedures, communications, and intermediate representations. The relevant cognitive system is larger than any individual participating in it 1.
The same perspective is useful for agentic engineering. A coding agent need not carry the whole engineering problem inside its context window. Models preserve selected facts about the system; skills preserve procedures; tools perform operations that need not be approximated through language-model reasoning; evidence records what occurred; people or agents supply judgments that remain difficult to evaluate mechanically. The capability of the resulting engineering system is therefore not simply the capability of its foundation model.
External representations matter for more than storage. Work on distributed cognitive tasks shows that the form of an external representation can change the operations required to solve a problem 2.2. Jiajie Zhang and Donald A. Norman, “Representations in Distributed Cognitive Tasks,” Cognitive Science 18, no. 1 (1994): 87–122, https://doi.org/10.1207/s15516709cog1801_3. A state machine exposes legal transitions; a dependency graph exposes reachability and coupling; a measurement model exposes a bound. The representation changes the reasoning problem presented to whoever—or whatever—reasons next.
A GEE adds another step. Its surrounding machinery can sometimes act on the represented property. A dependency model may help an agent understand the architecture, but a validator can also compare an observed dependency with an architectural obligation, and a gate can refuse the change. The environment therefore does not merely distribute cognition across reasoners and artifacts. For selected obligations, it can enforce what those representations express.
Organizational-learning research distinguishes correcting an error from changing the assumptions or rules that shape later action 3.3. Chris Argyris and Donald A. Schön, Organizational Learning: A Theory of Action Perspective (Addison-Wesley, 1978). Governance conversion is a concrete engineering move within that broader concern: a recurring gap becomes a model, procedure, check, or permission that later work inherits.
Some recent work automates parts of this improvement: analyzing traces to distil reusable skills, 44. Jingwei Ni et al., Trace2Skill: Distill Trajectory-Local Lessons into Transferable Agent Skills, arXiv preprint arXiv:2603.25158, 2026, https://arxiv.org/abs/2603.25158. diagnose harness defects, 55. Mengzhuo Chen et al., From Failed Trajectories to Reliable LLM Agents: Diagnosing and Repairing Harness Flaws, arXiv preprint arXiv:2606.06324, 2026, https://arxiv.org/abs/2606.06324. or revise the harness from observability data 6.6. Jiahang Lin et al., Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses, arXiv preprint arXiv:2604.25850, 2026, https://arxiv.org/abs/2604.25850. Such techniques can supply candidates; engineers still decide which lessons and obligations the environment should preserve.
Some recurring judgments should remain qualitative. Others contain narrower obligations that can be enforced while the larger decision stays open. The unit of that decision is the obligation, not the entire task.
Package Recurring Judgment
Skills preserve recurring procedures and judgment. Package the representations, examples, heuristics, decision procedures, and tools that help later work avoid reconstructing the same practice from general knowledge.
A skill can range from a compact procedure to a substantial body of domain knowledge and tools. It needs the representations used to reason about the work, the recurring decisions that matter, and a procedure for making them. What matters is what a fresh agent can use, not the package’s length or file format.
Prose, examples, models, and decision procedures make satisfactory judgments more likely. A skill can also invoke enforcing mechanisms or carry the models and correctness conditions they consume. Where an obligation requires independent enforcement, a constraint or gate must control the relevant action or admission decision; a checker may supply the evaluation used by that gate.
Delivering the packaged knowledge is its own engineering problem. Loading everything all the time is the obvious solution, and often a bad one: every rule, model, example, and failure lesson competes for attention, so a larger context can make navigation harder rather than easier. Separate the small standing context that must remain continuously salient from the richer slices retrieved when the task makes them relevant, and treat the delivery as an intervention whose effect can be measured. Context delivery changes what the reasoner can see; by itself, it does not change what the environment permits.
4.4.2 Evaluate the Work
Every engineering process must decide what evidence justifies accepting a change. Code review, testing, analysis, measurement, and expert judgment remain available; agentic implementation increases the rate at which the environment must use them. Start with the obligation the evidence must establish.
Validation begins with an obligation. If the obligation is settled, evidence can test whether the change satisfies it. If the obligation is still a hypothesis — whether users want the feature, which workflow they prefer, which tradeoff is acceptable — no test suite can manufacture the missing product knowledge. In that regime the evidence is experimental. MAGE can govern the experiment and preserve known constraints; it cannot turn an open question into a mechanical truth.
The obligation determines what must be represented; the representation determines which judgments are feasible. Start with the obligation and ask what representation makes it tractable, then use the cheapest judge adequate to the representation and the decision at hand. Representation can change that allocation: a judgment that initially requires expensive interpretation may become mechanically decidable once the relevant states, relations, or invariants are explicit. The converse failure also exists. A cheap judge can be perfectly reliable over an inadequate representation and still answer the wrong engineering question. In DocAble, pixel variance was easy to measure but could not decide whether a low-variance image carried semantic content; the representation had discarded the distinction the obligation required. Tightening the pixel-variance threshold would not recover the missing semantic distinction. DocAble instead routed that question to a judge capable of evaluating semantic content.
Use the weakest representation that preserves the distinction the obligation requires, and the cheapest judge adequate to decide it. Then decide, separately, whether the resulting judgment warrants enforcement. A deterministic check may remain advisory; a probabilistic evaluator may sometimes be reliable enough to support enforcement.
For a settled obligation, the producer's own report is rarely enough. A human says the change is correct; an agent says the tests pass; a tool announces completion. Each claim may be useful, but the strongest assurance comes from evidence generated independently of the judgment seeking admission. For consequential changes, prefer evidence that can challenge the producer's own claim rather than relying on self-report alone. Where the consequence warrants it, place admission control outside the producer's ability to redefine success.
That evidence can come from several sources. Where a model exposes a consequential property — a transition rule, a permitted edge, a declared bound — an appropriate analysis can produce evidence about whether that property holds; other models support navigation or reconstruction and need not carry an invariant at all. A model need not be an oracle to be useful. Evidence can equally come from outside a model: a test exercises a behavior, a compiler or type system rejects an illegal state, a reference implementation supplies a differential oracle, a metric reveals degradation, a human reviewer decides a property that remains judgment-laden. MAGE requires only that the obligation and the evidence be adequate to the claim.
In software testing, an oracle is the means of deciding whether an observed result is correct. It may be an expected output, a property the result must satisfy, a reference implementation, or a human judgment. An oracle is useful only to the extent that its verdict addresses the intended obligation. A perfectly reliable check of the wrong property is still an inadequate oracle.
SOFTWARE ENGINEERINGInset — The oracle problem
A longstanding difficulty in software testing is that executing a program can be much easier than deciding whether its result is correct. Testing research calls this the oracle problem 7.7. Earl T. Barr et al., “The Oracle Problem in Software Testing: A Survey,” IEEE Transactions on Software Engineering 41, no. 5 (2015): 507–25. For a sorting function, checking that the output is ordered is insufficient: an implementation that returns an empty list would pass that check. The oracle must also establish that the output contains the same values, with the same multiplicities, as the input.
Complex behavior may require properties, reference implementations, metamorphic relations, models, runtime evidence, or human judgment. Agents can cheaply produce implementations and test inputs, but more candidates do not supply the criteria for accepting them. Before expanding the search, the engineer must identify evidence that can distinguish an acceptable result from a plausible but incorrect one.
Existing behavior can stand in for a surprising amount of written specification. In a compatibility port or a structure-preserving migration, a reference implementation supplies an executable oracle: challenge a new realization with the same inputs and compare it against known behavior 891011.8. Anthropic, “How Anthropic Runs Large-Scale Code Migrations with Claude Code,” Anthropic, July 16, 2026, https://claude.com/blog/ai-code-migration.9. Nicholas Carlini, “Building a C Compiler with a Team of Parallel Claudes,” Anthropic, February 5, 2026, https://www.anthropic.com/engineering/building-c-compiler.10. Steve Faulkner, “How We Rebuilt Next.js with AI in One Week,” Cloudflare, February 24, 2026, https://blog.cloudflare.com/vinext/.11. Stephen Toub, “Migrating the GitHub Copilot Runtime to Rust, Using Copilot,” GitHub, September 16, 2026, https://github.blog/ai-and-ml/generative-ai/migrating-the-github-copilot-runtime-to-rust-using-copilot/. Tests, benchmarks, compatibility suites, and production traces close the target further. The implementation problem may stay enormous, but much less of the engineering question remains open.
Generative validation searches for counterexamples to a property, as discussed in §3.3. For sorting, generated empty lists, duplicates, and different input orders can test whether the result is an ordered permutation. A failure may reveal a law worth checking beyond the original example. A run without a counterexample still depends on which inputs the generator could reach; test count and line coverage alone do not establish that the property holds.
Docker's autonomous coding fleet separates producer from grader: the agent that writes a change does not grade it. An independent reviewer with its own model invocation, a determinized test suite, and a human gate stand between a pull request and main. The fleet may open a pull request; it may not merge one 12.12. Manuel de la Peña, “A Virtual Agent Team at Docker: How the Coding Agent Sandboxes Team Uses a Fleet of Agents to Ship Faster,” Docker, May 1, 2026, https://www.docker.com/blog/a-virtual-agent-team-at-docker/.
Model-Aware Change Impact
As agents produce changes faster than engineers can evaluate them, validation can become a bottleneck. One way to reduce that burden is to determine which obligations a change might affect, then select the evidence needed to establish that they still hold. The models and traceability relationships developed through MAGE offer a basis for doing so: explicit relationships among models, implementation elements, and obligations can guide the selection of tests, analyses, and measurements.
Consider a proposed increase in DocAble’s worker concurrency. The changed code may be confined to the executor, but its consequences extend beyond it. The execution model describes which operations can run together; the memory model constrains the resources consumed by concurrent work; and the latency model predicts how scheduling choices affect completion time. Figure 4.4-1 follows these relationships from the proposed change to potentially affected obligations and the evidence needed to evaluate them. Correct execution order, peak memory, and latency may require different checks, even though the change originated in one part of the implementation.
This approach builds on established work in software change-impact analysis, requirements traceability, model-based impact analysis, and regression test selection 13141516.13. Shawn A. Bohner and Robert S. Arnold, eds., Software Change Impact Analysis (IEEE Computer Society Press, 1996).14. Orlena C. Z. Gotel and Anthony C. W. Finkelstein, “An Analysis of the Requirements Traceability Problem,” Proceedings of the First International Conference on Requirements Engineering, 1994, 94–101, https://doi.org/10.1109/ICRE.1994.292398.15. L. C. Briand et al., “Automated Impact Analysis of UML Models,” Journal of Systems and Software 79, no. 3 (2006): 339–52, https://doi.org/10.1016/j.jss.2005.05.001.16. Gregg Rothermel and Mary Jean Harrold, “A Safe, Efficient Regression Test Selection Technique,” ACM Transactions on Software Engineering and Methodology 6, no. 2 (1997): 173–210, https://doi.org/10.1145/248233.248262. Its value in MAGE is that the models identify engineering questions, not merely implementation dependencies. A change to concurrency may warrant renewed memory analysis even if no memory-management code was modified. Conversely, sufficiently complete model relationships may justify omitting evaluations for obligations unaffected by the change.
The limitation is the completeness of the relationships being used. A missing dependency, an outdated model, or an incorrect link between a model and its implementation can conceal an affected obligation. Model-aware impact analysis therefore supplies evidence for selecting evaluations, not a guarantee that unselected checks are unnecessary. Where the relevant relationships are incomplete or uncertain, broader validation remains appropriate. An affected obligation may also require human judgment rather than an automated check.
Model-aware impact analysis extends the role of engineering models beyond directing implementation and evaluating its results. By connecting changes to the obligations they may disturb, those models can also help determine where evaluation effort is needed. The benefit grows as the rate of implementation increases, provided the cost of maintaining the relationships remains justified by the evaluation work they save.
4.4.3 Operate the Environment
A method has to survive terrible, horrible, no good, very bad days, too. Full disks, conflicted branches, vanished agents, stalled queues, flaking tests—the quotidian catastrophes of software engineering. Engineers often know how to recover, but that knowledge may live only in someone's head, where an autonomous agent cannot reliably reach it. Do not neglect operations when applying Modeling and Alignment.
Lifecycle models represent healthy progress and important failure states. Events make consequential transitions observable. Runbooks preserve sanctioned reactions, including where judgment remains. Metrics expose the quantities needed to judge whether the loop is healthy. Together they support an operating loop: recognize the state, surface the right reaction, take the appropriate action, and observe what happened next.
A lifecycle model starts with the healthy path of a recurring activity — how a bug moves from reported to fixed, how an agent moves from dispatched to landed — then names the failure states that matter and the sanctioned recovery from each. Pair prohibitions with recovery paths. "Never use this destructive merge command" leaves a stuck agent with a prohibition and no exit; "when this state occurs, do not use X; use Y because it preserves the already-applied work" supplies the missing path. DocAble learned this when agents used a destructive Git escape during stuck merges: the durable rule named both the forbidden action and the recovery that preserved already-applied work.
Operation improves further when an important transition can make the right procedure arrive at the right moment. Do not rely on an actor to remember to inspect the lifecycle, notice that a transition happened, retrieve the right procedure, and invoke it. Where a recurring event is mechanically observable and a standard response is useful, bind the reaction to the event. A mechanical trigger does not require a mechanical response: the firing can be deterministic while the payload still contains judgment. An agent reaches a context threshold, and a hook deterministically requests a handoff the agent must still compose. A deployment fails a health check, and the event opens a recovery path an engineer must still judge. Automate the arrival of the decision procedure, not every decision.
Runbooks preserve how an experienced engineer reasons through a recurring situation. Their steps can require different kinds of decisions:
- Execute when a step is mechanically determined and can become an executable operation.
- Delegate when a step requires bounded judgment. Supply the relevant state, choices, criteria, and required output.
- Escalate when a decision requires human judgment or authority. Prepare the evidence and surface the decision explicitly.
Where possible, surround a step requiring judgment with deterministic work. Prepare the data mechanically before the decision, then execute and measure mechanically afterward. Preserve the rationale separately from the execution trace. The judgment remains judgment, but its inputs and consequences become easier to replay and check. Runbooks can drift, so their procedures need the same maintenance discipline as other engineering models.
Operational measurement should expose the state the decision actually depends on. A worker count may be a poor proxy for memory pressure; measure the pressure. A marker on disk may not establish liveness; record lifecycle state explicitly. Ousterhout's rule from §4.2 applies to operations unchanged: 1717. John Ousterhout, “Always Measure One Level Deeper,” Communications of the ACM 61, no. 7 (2018): 74–83. measure one level deeper. A whole-project cloud bill tells you what you spent; cost by service may tell you what to change. Keep measurement separate from enforcement: a metric supplies evidence, a validator may interpret that evidence against an obligation, and a gate may act on the resulting verdict.
Scheduling Validation
Model-aware change-impact analysis addresses which evaluations a change requires. A separate problem is how to execute those evaluations without unnecessarily delaying engineering work. Even when the right checks have been selected, they consume time and computational resources. Running them synchronously can delay dispatch of subsequent development work—underutilizing agent capacity—while running them asynchronously can overwhelm the available infrastructure. The engineering environment must therefore determine when evaluations run, how they share resources, and which results must block further work.
DocAble’s agents eventually outpaced the infrastructure that checked their work. Before a November 2026 redesign, completed changes arrived in batches roughly every ten minutes, while the full test suite took about thirty minutes. The validation queue grew even though implementation was progressing well. I therefore asked which checks had to pass before each merge and which could examine several changes together.
An initial asynchronous arrangement launched expensive checks in the background after each merge. That removed the wait before the next merge, but it did not reduce the work being requested. Each merge still started another expensive run. A burst of merges therefore launched a burst of validation workers and overloaded the host. Moving validation off the critical path had exchanged waiting for resource contention.
The redesign separated broad validation from the arrival of individual changes, as Figure 4.4-2 shows. Inexpensive checks still ran before each merge. Broad repository checks ran every thirty minutes against the main branch, in an isolated worktree, with a lock permitting only one sweep at a time. Several merges could therefore be evaluated together. A blocking failure raised an alert and stopped new agent dispatch until the orchestrator acknowledged or handled it; acknowledgment permitted work to resume while repair was tracked separately. Before deployment, the full validation suite ran against the candidate being shipped.
The arrangement distinguishes three enforcement boundaries. Per-merge checks protect rapid integration, scheduled checks examine the accumulated changes without blocking each merge, and predeployment validation protects the released artifact. Asynchronous evaluation does not mean that its results are ignored: a scheduled failure can still interrupt subsequent work. The engineer chooses which obligations require immediate evidence and which can tolerate delayed evaluation, taking account of the consequences of failure.
The gain came at the cost of delayed defect detection and harder diagnosis. A defect could remain on the main branch until the next sweep found it. If several changes had merged since the last successful check, the failure had to be traced to one of them. The appropriate schedule therefore depends on how long the project can tolerate a broken main branch and how effectively the environment can diagnose and repair it. The same bottleneck reasoning used for document processing in §4.2 applies to the engineering environment itself: measure where work accumulates, distinguish latency from aggregate resource demand, and account for the consequences of changing the execution schedule.
Other stalls require different diagnoses. Before adding another mechanism, establish what kind of problem you have.
PRACTICEInset — When work stalls, diagnose before adding machinery
Repeated failure does not always call for another control. Before you build one, ask which part of the loop is limiting the work. Table 4.4-1 distinguishes four possible limits and the changes each calls for.
Table 4.4-1. Diagnosing stalled work. Four possible limits on engineering work and the changes each calls for. What may be limiting The question If that is the gap Searcher Can the available intelligence find a good candidate? Change the foundation model, tools, decomposition, or search strategy. Model Is consequential structure missing from the representation? Make it explicit. Oracle Can the environment tell good candidates from bad? Strengthen the evidence, validation, or simulation. Target Do we know what "good" even means? Stop building and learn. A stronger reasoner does not settle an unknown requirement; another validator does not supply a missing abstraction; more modeling cannot answer a product question whose answer must come from users or deployment.
4.4.4 Maintain the Machinery
As engineers develop the governed environment, they create reusable models, controls, procedures, and evidence pipelines that make subsequent work easier to direct and evaluate. Keeping this engineering capital useful requires maintenance. A model may drift from the implementation, while a gate continues to enforce an obsolete policy. Noisy controls and broken evidence pipelines can make their verdicts difficult to trust; skills can preserve procedures whose assumptions have expired. Engineers therefore need to observe, reconcile, repair, and sometimes retire these structures, just as they do for the system those structures govern.
An audit of DocAble’s models found that ten providers appeared to have the required uniqueness checks. Every test passed. Closer inspection showed that all ten checks examined identifiers in a shared graph, where uniqueness was already guaranteed, rather than the source records belonging to each provider. Duplicate source records could therefore overwrite one another without triggering a failure. The checks established a true property of the wrong collection.
The repair changed both the checks and the evidence for trusting them. Each check examined its provider’s source records, and a test deliberately introduced a duplicate that the check had to reject. This suggests a general maintenance practice: construct a violation of an obligation, run the actual check, and establish that it detects the violation. Where enforcement is intended, also test whether the resulting verdict prevents the work from proceeding. A passing control should have evidence that it can fail for the right reason. In §3.3, the consumer mistook an incomplete validation for a clean result; here, the uniqueness checks examined the wrong records.
Audit models, mechanisms, procedures, and evidence pipelines together:
- Does it still describe or govern the intended system? Check for changed assumptions, obsolete obligations, and evidence whose revision or operating conditions no longer match the work.
- Who uses it, and for what decision? A representation may support reasoning, queries, generation, or checking. Where enforcement is intended, verify that the mechanism still consumes the current model and acts on violations.
- Does its benefit justify its cost? Consider maintenance effort, false alarms, delayed work, and the consequence and recurrence of the failure it addresses.
- Should it be repaired, replaced, or retired? Preserve useful knowledge while removing machinery whose original purpose no longer warrants its upkeep.
Retirement belongs to the same discipline as governance conversion. §4.3 applies the same test when deciding what inherited structure to recover.
4.4.5 Summary
The DocAble episodes illustrate engineering moves that apply beyond this particular system and the agent harnesses used to develop it.
- Leave a degree of freedom open while variation is producing useful information; govern it when the choice becomes consequential and sufficiently understood.
- Establish an alignment kernel before transformations that could damage properties already known to matter.
- Use implementation as an instrument of inquiry, not as a substitute for explicit knowledge.
- In a brownfield system, recover latent structure before inventing replacement structure.
- Audit → Drain → Promote when turning an existing obligation into blocking enforcement.
- Use the weakest representation that preserves the distinction the obligation requires, and the cheapest judge adequate to decide it.
- Prefer independent evidence capable of challenging the producer's claim.
- Retain engineering structure only while the questions or failures it addresses justify its cost.
Appendix B develops procedures for adopting and operating this environment. The method itself can also become the kind of asset this section described: MAGE's recurring distinctions and procedures can be packaged as a self-governance skill an agent can inherit rather than reconstruct.
Chapter 5 changes the unit of analysis. It examines these agents, models, controls, and operating arrangements as a production system, asking how engineers organize controlled change when capable realization becomes cheap.
Works Cited
- Hutchins, Edwin. Cognition in the Wild. MIT Press, 1995.
- Zhang, Jiajie, and Donald A. Norman. “Representations in Distributed Cognitive Tasks.” Cognitive Science 18, no. 1 (1994): 87–122. https://doi.org/10.1207/s15516709cog1801_3.
- Argyris, Chris, and Donald A. Schön. Organizational Learning: A Theory of Action Perspective. Addison-Wesley, 1978.
- Ni, Jingwei, Yihao Liu, Xinpeng Liu, et al. Trace2Skill: Distill Trajectory-Local Lessons into Transferable Agent Skills. arXiv preprint arXiv:2603.25158, 2026. https://arxiv.org/abs/2603.25158.
- Chen, Mengzhuo, Junjie Wang, Zhe Liu, Yawen Wang, Haiming Zheng, and Qing Wang. From Failed Trajectories to Reliable LLM Agents: Diagnosing and Repairing Harness Flaws. arXiv preprint arXiv:2606.06324, 2026. https://arxiv.org/abs/2606.06324.
- Lin, Jiahang, Shichun Liu, Chengjun Pan, et al. Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses. arXiv preprint arXiv:2604.25850, 2026. https://arxiv.org/abs/2604.25850.
- Barr, Earl T., Mark Harman, Phil McMinn, Muzammil Shahbaz, and Shin Yoo. “The Oracle Problem in Software Testing: A Survey.” IEEE Transactions on Software Engineering 41, no. 5 (2015): 507–25.
- Anthropic. “How Anthropic Runs Large-Scale Code Migrations with Claude Code.” Anthropic, July 16, 2026. https://claude.com/blog/ai-code-migration.
- Carlini, Nicholas. “Building a C Compiler with a Team of Parallel Claudes.” Anthropic, February 5, 2026. https://www.anthropic.com/engineering/building-c-compiler.
- Faulkner, Steve. “How We Rebuilt Next.js with AI in One Week.” Cloudflare, February 24, 2026. https://blog.cloudflare.com/vinext/.
- Toub, Stephen. “Migrating the GitHub Copilot Runtime to Rust, Using Copilot.” GitHub, September 16, 2026. https://github.blog/ai-and-ml/generative-ai/migrating-the-github-copilot-runtime-to-rust-using-copilot/.
- Peña, Manuel de la. “A Virtual Agent Team at Docker: How the Coding Agent Sandboxes Team Uses a Fleet of Agents to Ship Faster.” Docker, May 1, 2026. https://www.docker.com/blog/a-virtual-agent-team-at-docker/.
- Bohner, Shawn A., and Robert S. Arnold, eds. Software Change Impact Analysis. IEEE Computer Society Press, 1996.
- Gotel, Orlena C. Z., and Anthony C. W. Finkelstein. “An Analysis of the Requirements Traceability Problem.” Proceedings of the First International Conference on Requirements Engineering, 1994, 94–101. https://doi.org/10.1109/ICRE.1994.292398.
- Briand, L. C., Y. Labiche, L. O’Sullivan, and M. M. Sówka. “Automated Impact Analysis of UML Models.” Journal of Systems and Software 79, no. 3 (2006): 339–52. https://doi.org/10.1016/j.jss.2005.05.001.
- Rothermel, Gregg, and Mary Jean Harrold. “A Safe, Efficient Regression Test Selection Technique.” ACM Transactions on Software Engineering and Methodology 6, no. 2 (1997): 173–210. https://doi.org/10.1145/248233.248262.
- Ousterhout, John. “Always Measure One Level Deeper.” Communications of the ACM 61, no. 7 (2018): 74–83.