Source note2 min read
Cheap Code, Costly Judgment: A Case Study on Governable Agentic Software Engineering
Source
arXiv
arxiv.org/abs/2607.01087v1
Source
- Source name: arXiv
- Source kind: paper
- Authors / organization: James C. Davis, Paschal C. Amusuo, Tanmay Singla, Berk Çakar, Kirsten A. Davis
- Venue: arXiv: cs.SE
- Published: 2026-07-01
- Collected: 2026-07-02
- URL: http://arxiv.org/abs/2607.01087v1
- PDF: https://arxiv.org/pdf/2607.01087v1
- DOI: UNKNOWN
Plain-Language Brief
In the study titled 'Cheap Code, Costly Judgment', researchers examined a case study of a 12-week development effort where an expert software engineer used AI coding agents to build a document accessibility remediation system. The study outlines a middle-range theory of governance conversion, which explains how high-velocity agentic implementation can become manageable and governable by converting recurring failures into durable governance mechanisms.
What the Document Says
- The text discusses a shift in software engineering due to generative AI towards low-cost code production.
- A case study is presented involving a 12-week development effort using AI coding agents by an expert software engineer for building a document accessibility remediation system.
- The empirical record includes field notes, produced code, tests, supporting documentation, and agent tooling.
- A middle-range theory of governance conversion is developed from the study data, which explains how high-velocity agentic implementation can become manageable.
- The model details how agentic implementation velocity exposes recurring structural failure classes, and how engineering judgment sustains velocity by converting those failures into governance mechanisms.
- Governance conversion contrasts with existing models that derive controls from known obligations, as it explains control discovery from failures during agentic work.
Key Concepts Mentioned
- Generative AI
- Software Engineering
- Case Study
- Governable Agentic Software Engineering
- Document Accessibility Remediation System
Claims Made by the Document
- The shift in software engineering due to generative AI is changing the central problem from code generation usefulness to organization of architectures, tools, evidence, and feedback loops.
- A middle-range theory of governance conversion explains how high-velocity agentic implementation can become manageable.
Evidence Used
- 88 contemporaneous field notes, 420 KLOC of production code, 1.16 MLOC of tests, lints, supporting documentation, and agent tooling from a 12-week development effort.
Methods / Approach
UNKNOWN
Limitations Stated by the Authors
UNKNOWN
Limitations Noted by the Agent
Agent interpretation — not from the source.
UNKNOWN
Open Questions
UNKNOWN
Notes for Future Q&A
May include interpretation. Labeled where it does.
UNKNOWN
Raw Abstract / Excerpt
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.
