Cheap Code, Costly Judgment: A Case Study on Governable Agentic Software Engineering

Abstract: Generative AI is shifting software engineering from a practice organized around scarce implementation effort toward one organized around abundant, low-cost code production. This shift changes the central engineering problem: not whether AI can generate useful code, but how engineers organize architectures, tools, evidence, and feedback loops so that AI-mediated development remains inspectable, correctable, and maintainable. We study this problem through a first-person case study: a 12-week development effort in which a single expert software engineer used frontier AI coding agents to build a document accessibility remediation system. The empirical record comprises 88 contemporaneous field notes, 420 KLOC of production code, and 1.16 MLOC of tests, lints, supporting documentation, and agent tooling. From this record, we develop a candidate middle-range theory of governance conversion, expressed as a process model explaining how high-velocity agentic implementation becomes governable. The model explains how agentic implementation velocity surfaces recurring structural failure classes, and how engineering judgment sustains velocity by converting those failures into durable governance mechanisms. In contrast to existing governance models that derive controls from known obligations, governance conversion explains how controls are discovered from failures that become visible only during agentic work. We use our model to make testable predictions and to describe implications for software engineering research and practice.

• The paper's main contribution is demonstrating that as AI-generated code becomes abundant, engineering bottlenecks shift from implementation to governance and contextual judgment.
• It employs a 12-week empirical study with 88 field notes and over 18.6k repository commits to analyze evolving control mechanisms in agentic software systems.
• Findings reveal that iterative control mechanisms and failure-to-governance loops are essential for sustaining high-velocity, AI-mediated software development.

Cheap Code, Costly Judgment: A Case Study on Governable Agentic Software Engineering

Introduction

The case study "Cheap Code, Costly Judgment: A Case Study on Governable Agentic Software Engineering" (2607.01087) interrogates the software-engineering implications of generative AI systems that shift code production from a scarce resource to an abundant, low-cost operation. Through a 12-week intensive empirical study, the authors dissect the evolving bottlenecks within agentic software engineering by deeply instrumenting the development of a document accessibility remediation system. Their central thesis is that as code generation becomes algorithmically trivial and abundant, engineering bottlenecks migrate upstream—away from implementation and towards explicit governance, contextual judgment, and the building of substrates that make rapid AI-mediated implementation governable, inspectable, and maintainable over time.

Case Study Design and Methodology

The work deploys a first-person, analytic case-study paradigm: a single, expert software engineer ("Subject") utilized frontier AI coding agents (primarily Anthropic Claude) to construct a production-oriented remediation system supporting PowerPoint, Word, Excel, and PDF input. The engineer delegated all implementation to agents, emphasizing minimal code inspection—a deliberate rejection of the oversight-centric paradigm in favor of deterministically enforced governance.

The empirical record includes 88 contemporaneously captured field notes, approximately 18.6k repository commits (across 1.6M lines of code, tests, and artifacts), and exhaustive incident-level and longitudinal analysis. The analysis proceeds through critical incident coding, codebook development, and triangulation between field notes and repository artifacts. This approach enables the distillation of qualitative constructs (such as architecture, controls, failure interpretation) and enables identification of governance mechanisms, their evolutionary triggers, and their operational efficacy.

Process Models and Knowledge Gaps

The study presents, contrasts, and problematizes three conceptual process models in agentic software engineering:

• Velocity-centric models optimize for implementation throughput by orchestrating multiple agents, but they often lack durable quality controls and are prone to architectural drift and brittle integration.
• Oversight-centric models rely on continuous human gating and review for quality, which saturates as volume increases, rendering human attention the ultimate bottleneck.
• Governance-centric models advocate for proactive translation of obligations (regulatory, product, organizational) into enforceable controls, but typically focus only on ex-ante obligations.

The authors identify a critical gap: prior work fails to specify how controls are discovered or evolve during high-velocity, sustained agentic development, particularly when failures and architectural weaknesses surface that were not previously specified or anticipated.

Empirical Results: Failure-Driven Governance Accumulation

A central empirical finding is the repeated emergence of a failure-to-governance conversion loop. High implementation velocity, enabled by coding agents, surfaces previously invisible or deferred architectural failures, ambiguities, interface mismatches, and validation lapses. The human architect, rather than repairing each instance directly, iteratively responds by embedding controls that either:

• Eliminate the recurrent failure class by construction (e.g., introducing strongly-typed models, closed vocabularies, bounded service interfaces).
• Mechanically detect the failure class (e.g., new lints, property-based tests, staged validation, mandatory brief conformance checks).

This is illustrated concretely by two canonical incidents: one in which architectural drift due to inconsistent boundaries prompts the installation of a typed, agent-legible architectural catalog (statically enforced, eliminating whole failure classes), and another where dynamic context injection is used to select and inject the relevant constraints and validation prior to agent execution, preventing repeated violations up front.

The Governed Engineering Environment

The operationalization of governance conversion yields an environment in which process and product are saturated with controls. The study catalogues ten families of such mechanisms, including dynamic agent context dispatch, progressive incorporation gates, audit trails, agent observability constructs, deterministic validations, and property-based tests. Notably, the sheer volume and diversity of controls far exceed the production logic; the governance substrate (2.75x the source volume of production code) is required at scale to avoid regressions, architectural decay, or unbounded agentic technical debt ([Ehsani et al., 2026]).

Figure 1: Commits per week during the case study reveal the implementation velocity and subsequent hardening phases as governance substrate accumulates.

Process Model: Governance Conversion Theory

The authors synthesize the empirical findings into a formal middle-range process model (Figure 2). The essential mechanism:

1. Velocity exposes failures: Agent throughput surfaces previously occult structural failures rapidly.
2. Human classifies failure: The engineer classifies the failure as local vs. structural.
3. Governance conversion: Recurring failures are converted into explicit, durable controls (deterministic schemas, validations, architectural models).
4. Constrained iteration: Subsequent agent waves operate in an increasingly governed environment, constraining the action space and minimizing oversight.
5. Compound governability: The environment recursively self-hardens, increasing its absorption capacity for high-velocity, agent-mediated changes.

   Figure 2: The development workflow: Subject supplies goals and feedback, updating agentic and product governance in response to observed failures.

Key Theses and Contradictory Claims

Two central theses are articulated:

• Engineering governance thesis: Sustainable agentic velocity is possible only when governance mechanisms (and relevant abstractions, validation, and evidence) are embedded deterministically into the environment, not merely through probabilistic soft controls, prompts, or review rituals.
• Human judgment thesis: As implementation becomes cheap, judgment becomes the limiting reagent. The critical engineering labor consists of recognizing when failures indicate systemic governance gaps and externalizing those judgments as durable architectural or control artifacts.

A key, somewhat contradictory, observation is that increased agentic capability does not reduce the need for human intervention; rather, it amplifies the consequences of high-leverage governance and abstraction errors. Thus, the labor market for human engineers shifts upstream to system architecture, process control, and judgment—a clear break from "end-to-end automated" narratives.

Implications for SE Practice and Research

• Organizational Implications: Authority to alter the governance substrate is essential; in multi-team or organizational contexts, the transformation from local repair to system-wide enforcement is nontrivial and likely to be the limiting factor for agentic productivity scaling.
• Metrics: Implementation volume is a misleading indicator of productivity. The definitive measure becomes "governed throughput": the rate at which agent work survives incorporation without repeated governance failures.
• Technical Debt: The agentic setting accelerates both the appearance and compounding or serviceability of technical debt ([Ehsani et al., 2026]), underscoring the need for continuous, layered process control.

Broad Theoretical and Practical Impact

The study reconceptualizes agentic software engineering as a domain where classical SE methods (architecture, requirements, validation, process control) re-emerge in stricter, more explicit, and sometimes more formalized forms. It challenges the idea that agentic velocity or advanced LLMs relieve the need for engineering discipline, positioning externalized, agent-legible governance as the chief bottleneck and mechanical precondition for continued velocity.

The practical upshot is that control substrate engineering (and its evaluation, evolution, and automation) becomes a primary research and educational priority. Future directions include automated control hardening ([meta2025ach], [shields2026hardening]), refinement of agent-legible specification languages, and adaptive orchestration substrates, as well as reconsideration of software engineering curricula to emphasize failure interpretation, abstraction discovery, and governance design over hand-coded implementation.

Conclusion

This case study provides a formal, empirically grounded account of the evolving locus of engineering difficulty in the agentic era: judgment, not code, is the binding constraint on progress. The authors' process model and theoretical framing—cheap code, costly judgment—mark a paradigmatic shift and offer constructs, testable propositions, and governance mechanisms for the agentic software engineering research and practice communities.

---

References

For a detailed treatment of the mechanisms and theory, see "Cheap Code, Costly Judgment: A Case Study on Governable Agentic Software Engineering" (2607.01087).