{"id":11875,"date":"2026-10-05T14:22:39","date_gmt":"2026-10-05T14:22:39","guid":{"rendered":"https:\/\/justfineinfotech.com\/dan-adler-warns-ai-coding-agents-are-flooding-legacy-codebases-with-code-no-one-understands-biggo-finance\/"},"modified":"2026-10-05T14:22:43","modified_gmt":"2026-10-05T14:22:43","slug":"dan-adler-warns-ai-coding-agents-are-flooding-legacy-codebases-with-code-no-one-understands-biggo-finance","status":"publish","type":"post","link":"https:\/\/justfineinfotech.com\/fr\/dan-adler-warns-ai-coding-agents-are-flooding-legacy-codebases-with-code-no-one-understands-biggo-finance\/","title":{"rendered":"Dan Adler Warns AI Coding Agents Are Flooding Legacy Codebases With Code No One Understands \u2014 BigGo Finance"},"content":{"rendered":"

Dan Adler Warns AI Coding Agents Are Flooding Legacy Codebases With Code No One Understands
\nAdd preferred source<\/a>3
\nThe software that runs the world \u2014 banking systems, insurance calculations, warehouse logistics, airline routing \u2014 lives in massive, decades-old codebases that are, by most accounts, unattractive and poorly understood. Dan Adler, CEO of SourceCraft, argues that AI coding agents are now producing code faster than these sprawling systems can absorb it. The result: duplicate code, drifting standards, fragile dependencies, and hidden defects accumulating at an unprecedented rate.<\/p>\n

Adler’s central thesis, delivered in a keynote on the AI Engineer podcast, is that the same tools that let engineers<\/a> write more code faster are creating the conditions under which massive codebases begin to break down. The bottleneck, he contends, is not model quality but infrastructure: no major agent vendor is building tooling that can search, understand, and modify code across tens of thousands of repositories at once.<\/p>\n

The talk includes a product announcement \u2014 Sourcegraph’s new batch-changes agent, launched in beta the same day \u2014 and a case study from Merkari, where an early-access user started with two known vulnerability locations and the agent discovered 80 more across the codebase. Adler frames the core question as one of visibility: “You can’t search for something you literally can’t see.”<\/p>\n

For investors, the implications are direct. If Adler is right, the adoption curve for AI coding tools will increasingly depend on enterprise-scale code management infrastructure \u2014 not just smarter models. Whether that infrastructure becomes a durable independent layer or simply a feature absorbed by frontier labs remains an open question.<\/p>\n

Key Elements<\/h5>\n
\n<img src="https:\/\/justfineinfotech.com\/wp-content\/uploads\/2026<\/a>\/10\/aHR0cHM6Ly9pbWcuYmdvLm9uZS9uZXdzLWltYWdlL2FpX2dlbmVyYXRlZC8yMDI2LTEwLzc3Y2ExODY5OTFhODIyMWFfMTc5MTE0NjU2OV9jb3Zlci5qcGc.webp” alt=”Dan Adler Warns AI Coding Agents Are Flooding Legacy Codebases With Code No One Understands”>
\n<\/figure>\n

One of the most senior technical leaders at a top-ten automaker said something recently that should stop anyone who thinks AI coding tools are a solved problem: “I don’t know what this code does. AI wrote it for me.” The context was autopilot code, with thousands of engineers to manage and resource. Dan Adler, CEO of SourceCraft, told this story on the AI Engineer podcast, and it captures the collision he sees coming for every company running large, legacy software systems.<\/p>\n

Adler’s argument is counterintuitive: the AI tools that are making developers dramatically more productive are simultaneously undermining the stability of the codebases that run the world. He calls it “a tsunami of code” \u2014 code being generated faster than enterprises can review, understand, or integrate it<\/p>\n

The World Runs on Big, Old, Unattractive Code<\/h3>\n

Adler opens with a demographic point that reframes where software actually lives. By his account, 72% of software industry workers are employed at companies with more than 500 employees \u2014 large global corporations managing thousands of repositories and decades of accumulated code. The public image of software as a startup-and-solo-founder industry, he argues, describes almost none of the real workforce.<\/p>\n

The systems these engineers maintain are unglamorous but critical: real-time transaction rejection at a bank, reimbursement-rate calculation for a dual-coverage insurance policyholder, warehouse scanning behind Amazon deliveries, Uber arrival estimates, radar-based flight-path adjustment, payroll issuance, office air conditioning running continuously<\/p>\n

“The software that runs the world is not attractive. It is not new. It is not clean. This is how everything really works,” Adler said<\/p>\n

He frames the session explicitly as “a call to honor the people, the owners of these codebases” \u2014 the maintainers doing what he describes as “the thankless but fundamental work.”<\/p>\n

The Failure Modes of AI-Generated Code at Scale<\/h3>\n

The core tension Adler identifies is between generation speed and comprehension capacity. Agents are writing more code, faster, and he acknowledges their quality is improving. But the codebases receiving this output are too large to review efficiently<\/p>\n

He rejects the obvious counterarguments \u2014 that agents can check code, that codebase-health tools exist, that model quality keeps improving \u2014 as “local maxima,” dams built to contain a flow that keeps rising<\/p>\n

The specific problems he names:<\/p>\n\n\n\n\n\n\n\n\n\n
Failure mode<\/th>\nDescription<\/th>\n<\/tr>\n<\/thead>\n
Standards drift<\/td>\nDifferent agents apply different programming standards in different parts of the codebase<\/td>\n<\/tr>\n
Duplicate code<\/td>\nCode is propagated even when an existing library already does the job, because the agent doesn’t know it exists<\/td>\n<\/tr>\n
Fragile dependencies<\/td>\nInter-service dependencies become increasingly brittle<\/td>\n<\/tr>\n
Hidden defects<\/td>\nMinor deviations from standards create “more insidious hidden problems” throughout the code<\/td>\n<\/tr>\n
Vulnerability discovery<\/td>\nAgents find new vulnerabilities daily, requiring constant oversight of legacy codebases nobody wants to touch<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The root cause is scale. Millions of lines of code across tens of thousands of repositories cannot fit in a context window or even be cloned and processed in real time. Adler calls this “simply impossible.”<\/p>\n

\"\"<\/p>\n

The Comprehension Gap Is an Infrastructure Problem<\/h3>\n

Adler’s most technically specific argument concerns how large language models actually navigate code. They “just love to search,” he noted \u2014 comparing an agent to a new employee getting comfortable with a codebase \u2014 and this search behavior is how agents build their understanding<\/p>\n

His claim is that repository architecture documented in agents.md files “changes almost nothing” in practice. The agent will search its way to understanding regardless of what documentation says<\/p>\n

But there is a hard limit: “You can’t search for something you literally can’t see.”<\/p>\n

Understanding requires context, and context at repository scale \u2014 500, 5,000, 50,000, or half a million repositories \u2014 requires tooling that Adler says does not exist. He names the vendors he claims are not solving this: OpenAI, Anthropic, Cursor, and “anyone else.” His concession is that their agents are “so incredibly good at solving the small tasks that most developers face every day” that demand is growing faster than ever \u2014 which is precisely why the large-scale breakdown goes unnoticed.<\/p>\n

The second unnamed quote Adler surfaces comes from a technical leader at a top-ten US bank, described as holding tens of trillions of dollars in assets in custody or under management: “Of course Claude Code can make this change, but I need to do it in 90,000 repositories.” The context was a supply-chain vulnerability related to npm<\/p>\n

The point: when agents discover and create vulnerabilities at unprecedented rates, telling a bank to use a coding agent to fix them doesn’t address the problem of mapping how 90,000 repositories interact across all products<\/p>\n

Sourcegraph’s Bet: Visibility as Infrastructure<\/h3>\n

Adler’s prescription is a fundamental graph of the codebase \u2014 including search and accurate compiler output \u2014 sitting in front of the agent. His formulation: “Visibility is infrastructure.”<\/p>\n

The claim is that if you conduct this analysis, you empower agents to make changes effectively across the whole system rather than within a single repository. He predicts the code volume only grows: “These huge code bases are not going anywhere. In fact, there will be even more code.”<\/p>\n

The question Adler does not fully answer is whether this visibility layer becomes a durable independent infrastructure business or simply a feature that frontier labs eventually fold into their own products. He acknowledges that model quality keeps improving and that major vendors will eventually add such capabilities. The tension sits unresolved<\/p>\n

Batch Changes: One Prompt Across Thousands of Repositories<\/h3>\n

Adler announced that day of the talk. The product is designed to let an owner of a massive codebase commit changes to hundreds or thousands of repositories simultaneously from a single prompt<\/p>\n

The design principle is a split between agentic and deterministic execution:<\/p>\n

The product iteratively implements changes across the codebase, independently fixes errors, responds to CI status and pull request comments, and uses code agents where judgment is required and deterministic scripts where consistency is required. Adler emphasizes the tracking and auditing capability: confirming 100% coverage of locations needing a patch or change<\/p>\n

The Merkari Case: Two Known Repos Became 80 More Vulnerabilities<\/h3>\n

The one customer proof point Adler offered comes from an early-access user at Merkari, which he describes as a global trading service from Japan with hundreds of independent microservices in production<\/p>\n

The user was fixing a code injection issue on GitHub involving environment variables. He ran the product on two repositories where he already knew the problem existed, then let the agent explore the rest of the codebase. It found 80 more potential vulnerabilities \u2014 all in configuration files<\/p>\n

Adler frames this as scanning and fixing in one pass ross hundreds of locations. “This is where confidence lies in the age of agent programming,” he said<\/p>\n

The unresolved question is whether this audit-and-coverage guarantee holds up at the 90,000-repository scale Adler cites as the bank’s requirement. The only published proof point is a two-repository seed expanding to 80 findings<\/p>\n

The Threat Comes From Within<\/h3>\n

Adler’s most striking framing deserves mention on its own terms: “The threat comes from within. The same tools that speed up our work and allow us to write more code faster than ever before are also creating the conditions under which these vast codebases that run our world are starting to break down.”<\/p>\n

This is not an anti-AI argument. It is an argument that the adoption of AI coding tools without corresponding investment in codebase-level infrastructure is silently degrading the systems on which the global economy<\/a> depends. The engineers who maintain these systems are, in Adler’s words, under siege from a flood of generated code they cannot fully understand or review<\/p>\n

Adler ends with a diagnostic for codebase owners: how many repositories do you have, how many forks, how many copies, and how many repositories have your developers brought into the company that are now used as a library or API somewhere in production without your knowledge?<\/p>\n

For the software industry, the stakes are concentrated: the same companies driving AI adoption \u2014 large enterprises with thousands of repositories \u2014 are the ones least equipped to absorb the output. Whether Sourcegraph’s visibility infrastructure, or an equivalent from another vendor, becomes the standard layer for managing AI-generated code at scale will determine whether the productivity gains from AI coding tools translate into durable software quality, or into a maintenance burden that compounds with every passing day.<\/p>\n

Full content available at:AI Coding Agents Are Breaking Big Codebases \u2014 Dan Adler, Sourcegraph<\/p>\n

References:<\/p>\n