AI Coding Agents: More Code, But Why Not More Software?

Code Output Soars, But Why Isn't Software Delivery Keeping Up?

A recent episode of the Artificial Developer Intelligence podcast (ADI Pod #43) tackled a topic that's both familiar and frustrating for developers: AI coding agents have caused code output to explode, but the software actually delivered hasn't grown in proportion. The episode cited an Ars Technica report on a study led by Harvard researchers Fiona Chen and James Stratton, based on Jellyfish data, tracking changes in engineering efficiency over 12 months after enterprises adopted AI coding agents.

The conclusion is direct: after introducing agents, total lines of code increased by an average of 30%, commits rose 20%, and pull requests (PRs) increased 23%. But end-to-end delivered software did not grow proportionally. Podcast host Shemin Zhang's complaint hit the nail on the head: "If we're producing this much, why aren't we shipping faster?"

The Bottleneck Isn't Writing Code—It's Merging It

The explanation the study offers isn't surprising: code review is still done manually, and as agent adoption deepens, change requests initiated by reviewers grow almost linearly. In other words, the more agents write, the more often human reviewers get called in to "clean up the mess." Dan's summary on the podcast was incisive: "Your code review is killing everything."

This explains a widespread feeling: AI makes writing code faster, but the PR queue gets longer, and waiting time for merges cancels out the time saved on coding. For teams already accustomed to letting AI generate large chunks of code, the review stage has instead become the new bottleneck.

Pull Request (PR) is a mechanism in code collaboration platforms (such as GitHub, GitLab) for proposing changes and requesting they be merged into the main branch. After completing a piece of code, a developer opens a PR, which other engineers review line by line, comment on, and request changes to before it can be merged. PRs increasing while end-to-end delivery stays flat means the human review time per PR has essentially not changed—or has even increased because change sizes have grown. This is precisely the core mechanism in the study: agents generate code in bulk, and human review and change requests inflate linearly along with it, lengthening the PR queue and raising wait times, so the time saved in coding gets eaten by the review stage. Understanding this makes it clear why looking only at lines of code or commit counts severely overestimates AI's actual impact on delivery speed.

OpenAI Fires Safety Researchers: The Safety Mechanism Itself Becomes the Controversy

The biggest news in this episode's news segment was that OpenAI fired three safety researchers—Jasmine Wang, Tomek Korbach, and Nikita Balenci. The official reason given was that the three had communicated with external safety organizations, violating the company's sensitive information access and handling policy. But the three researchers subsequently published an open letter stating that internal and external communications surrounding the firings had left former colleagues "afraid to speak," and that their collaboration with external experts was precisely an indispensable part of safety work.

One line from the open letter was repeatedly quoted on the podcast: "AI is not ordinary technology, and OpenAI is not an ordinary company."

According to an internal memo obtained by TechCrunch, the firings were actually related to leaking to the media information about an "unmonitorable architecture" (i.e., loop transformers, a model structure whose chain of thought is difficult to observe). The three researchers denied in their open letter any connection to the leak. Podcast guests noted that a third-party organization's report on the Hugging Face agent escape incident was unusually detailed, and was praised at the time as a model of transparent safety collaboration—but now it may not have been entirely voluntary.

Divergence Among Frontier Labs: To "Pace" or Not?

The news segment also contrasted the attitudes of two giants. Microsoft CEO Satya Nadella posted about "models as an internal risk in the age of superintelligence," emphasizing model diversity, independent verification, and incident disclosure, but did not call for slowing frontier model development. Meta's Zuckerberg was more direct, saying Meta has reached the AI frontier and believes AI can be engineered with "normal guardrails" rather than an "anthropomorphized" loss-of-control narrative.

The hosts' judgment: if "frontier pacing" is a collective action problem, then Meta and Microsoft already count as "defectors," and the current U.S. government is unlikely to step in with regulation. The conclusion is "buckle up."

Deconstructing Agentic Primitives: Doing Work, Continuing Work, Delegating Work

The tools segment discussed Charlie Goh's three-layer breakdown of agentic primitives in the Artificial Ignorance newsletter, which is very helpful for understanding the design logic of current AI coding tools.

Layer One: Doing Work

This includes system instructions (e.g., "don't rm -rf my root directory"), skills loaded on demand (skills should not all be stuffed into context), tools and connectors (accessing local or third-party capabilities), and sandbox environments (isolating dangerous operations in the cloud, startable and stoppable on demand). Podcast guests specifically mentioned that sandboxes let agents avoid "dangerously skipping permissions" on the developer's own machine.

Layer Two: Continuing Work

The core is sessions and context compaction. The podcast noted that an ideal agent should not rely on workarounds like "slash compact," but should automatically dispatch sub-agents to handle suitable subtasks, avoiding filling up the main context. Another noteworthy pattern is scheduling and event triggering: OpenClaw^Ad's explosive popularity is partly due to its support for trigger-based tasks rather than dumb cron polling.

Layer Three: Delegating Work

Sub-agents and agent swarms are seen as a new form of "test-time compute scaling"—not by running a single agent longer, but by running more agents in parallel. The podcast mentioned reports that the AI system that solved the Navier-Stokes Millennium Prize problem consisted of roughly 10,000 agents (single source; treat with caution). But the industry is still figuring out: which problems suit swarms and which don't.

Test-time compute scaling refers to investing more compute at the inference stage to improve output quality, rather than relying solely on scaling up training. Common approaches include having the model generate multiple candidate answers and then filter them, extending chain-of-thought reasoning, or iterating repeatedly with search and self-verification. The article treats agent swarms as a system-level extension of this idea: rather than running a single agent longer, let multiple agents try in parallel and check each other. This also explains why swarms work on some problems—it amounts to distributing inference compute across multiple independent execution paths; but parallelism also brings coordination costs and result-aggregation challenges, so which tasks suit swarms still needs exploration.

Three Emerging Challenges: Memory, Proactivity, Identity

The podcast distilled three frontier problems mentioned in Charlie's article. On memory, the current simple approach is storing in Markdown files, but for long-horizon tasks at the day, week, and month level, deciding what to keep and what to discard remains difficult; continuous weight fine-tuning seems ideal but easily destabilizes the model by overfitting to recent inputs. On proactivity, event-driven is more reasonable than polling, but agents need to model both users' "stated preferences" and "behavioral preferences," which often diverge. On identity, whether an agent "impersonates the user" or "is delegated to under its own identity" directly affects whether responsibility can be traced when problems arise.

Context compaction is a technique for managing a limited context window during agent runtime. Conversations and tool calls keep accumulating, and once they exceed the model's window they get truncated or throw errors. Compaction works by summarizing earlier history into brief summaries, discarding redundant details, or handing subtasks to sub-agents and only passing back conclusions. The "slash compact" criticized in the article refers to a workaround in which the user manually triggers compaction; the ideal approach should automatically decide when to compact and what information to keep. This is directly related to the memory challenge: what is kept and what is discarded determines whether an agent can handle long-horizon tasks at the day, week, and month level, and whether it will forget key constraints.

Gemini Model Hands-On: Vision and Proactivity Stand Out

The model evaluation segment demonstrated the latest version of Gemini. Using the same "Hamlet soliloquy" SVG generation prompt for comparison, the Gemini version not only generated a complete stage with a sidebar, emotional beat annotations, and background sound effects, but also provided slider panels for adjusting facial expressions and gestures—furrowed brows and tear reflections could all be adjusted.

Podcast guests' assessment: on reasoning and creative output, Gemini is already hard to distinguish from frontier models like GPT-6 and Opus 5.5. One interesting observation is that Gemini tends to return to a "what makes us human" narrative, which may be a feature brought by fine-tuning or reinforcement learning. Another highlight is that it very proactively builds UI widgets and flowcharts for users, echoing the view that "interfaces shouldn't just be text."

On second- and third-order effects, Gemini offered some interesting predictions: code review will be replaced by multi-agent adversarial testing frameworks; knowledge work will see "flight simulators"; and "high-agency outliers" will enter a golden age.

Voice Cloning Prank: The Safety Boundary of Vibe Coding

The most unexpected segment of this episode was Rahul's "mystery vibe intel"—he built a real-time voice cloning pipeline with open-source tools and, live on air, "became" Dan using his own voice. The process included: separating each person's vocal track from podcast audio, extracting identity features with a content encoder, pitch-shifting by about six semitones, then synthesizing with a vocoder, and finally routing the output through the BlackHole virtual audio device directly into the podcast recording software.

Rahul said when he tested it on Google Meet, his wife said it "sounds just like Dan." Podcast guests noted that this entire pipeline was cobbled together with vibe coding, without using any ready-made all-in-one app—"that's both exciting and a little scary." Defensive measures discussed included: pre-arranging code words with family members and making a second phone call to confirm suspicious voice requests.

AI Bubble Clock: The $6 Trillion Revenue Gap and Infrastructure Anxiety

The "two minutes to midnight" segment at the end of the episode (using the Bulletin of the Atomic Scientists' Doomsday Clock as a metaphor for the AI bubble bursting) remained at 4 minutes 15 seconds. Two financial signals discussed this episode are worth noting.

The first is Bain Capital data: AI needs $6 trillion in annual revenue to support the current data center construction boom. After interpreting the charts, the hosts believe the actual gap is about $4.2 trillion. Meanwhile, the largest single AI data center is expected to grow from 0.6 gigawatts in 2025 (about $24 billion to build) to 9 gigawatts by 2030 (about $200 billion). The podcast expressed doubt about whether power supply can keep up, and joked about the idea of "space data centers."

The second is OpenAI's revenue forecast revision. TechCrunch reported that OpenAI told investors its annualized revenue is close to $50 billion, rather than the previously rumored $70 billion—a gap of $20 billion. The podcast noted that OpenAI and Anthropic calculate revenue differently: Anthropic counts model revenue served through platforms like Google Cloud and AWS, while OpenAI does not count third-party hosted revenue. Ultimately, everything will be clear once actual financial statements come out.

Another signal mentioned was Character.ai filing for bankruptcy. This chatbot platform, founded in 2022 and a unicorn within a year, was acquihired by Google for $2.4 billion; founder Noam Shazeer reportedly cashed out $750 million to $1 billion, then left to join OpenAI in 2026, and the company ultimately sold its assets to Disney for $20 million and went bankrupt. This may affect the market's valuation logic for existing AI unicorns.

The Next Step for Software Engineering: From Writing Code to Running a Software Factory

Back to the core topic: more code but not more software—how will this problem evolve? Podcast guests offered several judgments.

In the short term, the code review bottleneck is being actively addressed, with multi-agent adversarial review being one direction. In the medium term, if review is no longer the bottleneck, the next challenge is operating thousands of highly customized software instances—the operational burden of a "software factory" may need to be solved by burning tokens. In the long term, software engineers' work will shift from "translating business requirements into code" to judging what to build, how to maintain it, and how to run the factory itself.

One exchange on the podcast is worth noting: one guest said much development work is essentially "translating business requirements into code," not computer science research; another responded that people who understand underlying systems still have an advantage in solving problems that non-technical users can't—"but can that advantage last another year? Maybe not even six months."

Human judgment, creative problem-solving, and interpersonal trust may be more durable values. As one half-joking line on the show put it: "There will always be someone willing to pay for a person who can pick up the phone and yell at a problem."

One-line Summary

AI has caused code output to surge by 30%, but manual review has become the bottleneck, and software delivery hasn't sped up in step.

Paragraph Summary

Harvard researchers tracked efficiency changes over 12 months after enterprises adopted AI coding agents, based on Jellyfish data, finding that lines of code increased 30%, commits rose 20%, and PRs increased 23%, but end-to-end delivered software did not grow proportionally. The reason is that code review is still done manually; the more agents write, the more change requests reviewers initiate, and longer PR queues cancel out the time saved on coding. The podcast also discussed the controversy over OpenAI firing three safety researchers, the "doing work/continuing work/delegating work" three-layer breakdown of agentic primitives and the three major challenges of memory, proactivity, and identity, Gemini's performance on vision and proactivity, and AI bubble signals such as Bain Capital's estimated $6 trillion revenue gap and OpenAI's downward revenue forecast revision.