AI Engineer World's Fair 2026
AI Coding Agents Are Breaking Big Codebases — Dan Adler, Sourcegraph
Loading slides…
Read the talk
AI Coding Agents Are Breaking Big Codebases
Dan Adler connects faster code generation to a growing maintenance burden, then explains why agents need codebase-wide search, compiler-informed context and coordinated changes across repositories.
From a talk by Dan Adler
At a glance
Ideas worth remembering
An agent can create duplicate functionality when it cannot discover an existing library. Codebase-wide visibility addresses the missing context behind that locally successful edit.
Enterprise remediation requires finding affected code and understanding what runs in production, as well as producing a correct patch in one repository.
Agentic Batch Changes combines coding agents where judgment is needed, deterministic scripts for repeatable edits, and CI, PR feedback and tracking for coordinated rollout.
The Mercari example illustrates how a search can expand two known problem repositories into 80 additional potential findings before a consistent configuration fix is applied.
The maintenance problem starts with software people already depend on
A bank rejecting a transaction at an account limit depends on a large, long-lived codebase. So do insurance reimbursements, warehouse scanners, arrival estimates and payroll. Dan Adler, CEO of Sourcegraph, opens with this everyday dependence: software accumulated over decades still performs the work people expect to happen reliably. Owning that code is “unglamorous but load-bearing.”
The scale matters because the glamorous picture of software development can obscure where maintenance happens. Adler cites 72% of software industry employment as being in companies with more than 500 people. That is an employment statistic, rather than a direct measure of repository size, but it establishes the population his talk addresses: engineers working inside large organizations, often with thousands of repositories and decades of history.
Faster generation increases the work of keeping code coherent
Coding agents accelerate the arrival of new code. Every addition still needs review for how it fits the surrounding system. Code review agents and tools that measure codebase health can help absorb that work; Adler expects coding tools to incorporate more of those capabilities as models improve. His “sandbags” analogy captures the limitation: local checks can hold back parts of the flood while the total volume continues to grow.
At enterprise scale, incomplete context creates several distinct maintenance problems:
- Duplicated functionality. An agent implements something the organization already has a library for because it cannot find that library. The new code adds another implementation to maintain.
- Drifting standards. Different agents apply different conventions in different places. Small deviations accumulate across a codebase, making consistency harder to preserve.
- Brittle service dependencies. Changes made locally can leave relationships between services harder to maintain when the wider system is outside the agent’s view.
- Security upkeep. Newly uncovered vulnerabilities create continuing work across legacy code, alongside the vulnerabilities that new changes may introduce.
The duplicate-library example shows the causal chain clearly. A useful implementation already exists elsewhere. The agent’s accessible context does not include it, so the agent writes another implementation. A locally successful change therefore leaves the organization with more code and another place where future fixes may be needed. Better generation alone does not resolve the missing information that caused the duplication.
Responsibility also becomes harder when engineers cannot explain the generated code they submit. Adler recounts a technology executive at a top 10 car manufacturer overhearing a developer say, “I don’t know what this code does. AI wrote it for me.” In the context of vehicle autopilot software and thousands of engineers, that disconnect between producing code and understanding it carries serious stakes. This anecdote and the maintenance mechanisms motivate Adler’s warning about decay; they do not establish a measured industry-wide rate of failure caused by agents.
Making one change and making it in 90,000 repositories are different jobs
Small-scale coding assistance already solves valuable daily problems. The harder infrastructure problem is seeing and understanding an organization’s whole codebase. Adler calls on agent harness builders and developer tools companies to supply that visibility, and to recognize the people who keep these systems running. His criticism of the named coding-tool vendors is scoped to this large-codebase infrastructure gap at the time of the talk.
A technology leader at a top 10 US bank gives the scale problem a concrete form: Claude Code can make a required change, but the bank has 90,000 repositories to make it in. The reported request concerned an npm supply-chain vulnerability. Producing a patch in one repository is only one part of the task. The organization must also find the affected repositories, understand how their code fits together and determine which code is actually running across its products.
That changes the meaning of completion. A correct edit in the repository currently open to an agent does not establish that the vulnerability has been addressed across the company. The owner needs both an effective transformation and a way to establish where that transformation belongs. Repository coverage becomes part of the security work.
Search can only build understanding from code the agent can see
Agents learn their way around a codebase much like a new hire: they search repeatedly, inspect results and build a working model of the system. Repository architecture notes in AGENTS.md can provide orientation, but Adler places much more weight on the agent’s repeated searches. The practical constraint is simple: “You can’t grep what you literally cannot see.”
Millions of lines across tens of thousands of repositories cannot all sit inside a context window. Adler also rejects cloning and grepping the whole estate in real time as a practical answer at that scale. The agent therefore needs infrastructure that makes relevant code searchable beyond its immediate checkout. Improving the model’s reasoning does not, by itself, give it access to an unseen library or service.
Sourcegraph’s proposed foundation is a code graph that combines search with compiler-accurate analysis where that analysis is performed. Search supplies a way to locate code; the analysis supplies structured information for understanding it and making changes effectively. The recording does not specify the graph’s schema or the extent of compiler analysis across languages and repositories, so the supported mechanism is this combination rather than a particular graph implementation.
“Visibility is infrastructure” names the dependency: agents need access to the code they must understand before they can evolve it responsibly. Adler’s forecast is that these large codebases will persist and contain much more code. In that future, discovering existing implementations and relationships becomes more valuable as generation adds to the estate.
Batch changes combine agent judgment, repeatable edits and feedback
Agentic Batch Changes, announced in beta during the talk, builds coordinated execution on top of this visibility. Its stated job is to start from a single prompt and carry out changes across hundreds or thousands of repositories. The rollout is iterative: it responds to CI status and pull request comments, repairs problems and continues the change process.
The design separates work by what it requires:
- Coding agents for judgment. Use an agent where a change needs interpretation or a decision about the surrounding code.
- Deterministic scripts for repetition. Use a script where the transformation can be specified consistently, avoiding a fresh discretionary edit at every occurrence.
- Tracking for coverage. Record the progress of the change across the places that need it, so the owner can audit completion.
How does one request become a coordinated rollout rather than a collection of isolated edits? The diagram shows the two execution methods feeding the same feedback loop. CI and review comments can send work back for revision, while tracking makes progress across repositories inspectable. Adler presents 100% coverage as the product’s intended assurance; that assurance depends on identifying the full set of places requiring the patch.
One batch request, two execution methods, a shared feedback loop
Read the diagram as text
- Single prompt. Request a change across hundreds or thousands of repositories.
- Coding agent. execution — Handle edits requiring judgment.
- Deterministic script. execution — Apply specified transformations consistently.
- CI status and PR comments. Supply feedback for iterative repair and rollout.
- Coverage tracking. Make progress across required change locations auditable.
- Single prompt → Coding agent: Where judgment is needed.
- Single prompt → Deterministic script: Where a repeatable edit suffices.
- Coding agent → CI status and PR comments: Evaluate changes.
- Deterministic script → CI status and PR comments: Evaluate changes.
- CI status and PR comments → Single prompt: Revise and continue rollout.
- Coding agent → Coverage tracking: Track change coverage.
- Deterministic script → Coverage tracking: Track change coverage.
Mercari expands a known fix into a codebase-wide search
The Mercari early-access example follows the change from known locations to newly discovered ones. An engineer began with two repositories known to contain a GitHub code-injection issue involving environment-variable configuration. The engineer then expanded the request to explore the rest of the codebase. Adler reports that this search found 80 other potential vulnerabilities across an estate with hundreds of independent microservices in production.
The observable change is the scope of the work: two known repositories became a much wider set of candidate locations. Because the issue involved configuration files and a repeatable correction, a deterministic script could carry the fix across matching locations consistently. Search discovers where the pattern occurs; the script applies the specified transformation. The 80 findings are described as potential vulnerabilities, and Adler’s subsequent reference to 100 patch locations does not reconcile with the earlier counts. The example supports expanded discovery and consistent batch editing, rather than a precise total of confirmed remediations.
The ending returns to the inventory that makes such work possible. How many repositories exist? How many forks and copies? Which imported repositories now supply a library or API used in production without the codebase owner knowing? A scan cannot establish complete coverage if the organization’s view omits code that is actually deployed. Keeping the estate updated begins with finding that estate.
That is the practical question Adler leaves with codebase owners: can you see the code running across your company, scan it and update all the places that need a change? His invitation to bring their “gnarliest” codebase stories fits the subject. The difficult cases are the accumulated systems people already rely on, now receiving code faster than their owners can comfortably absorb.
Full transcript
Loading transcript…