Sourcegraph's 2026 Big Code report examines how enterprise teams understand, maintain and change large codebases as AI becomes part of everyday development.
Among respondents at AI-using organizations in Sourcegraph's 2026 Big Code survey, 79% report moderate, considerable or intense pressure to demonstrate a return on their AI investment. Meanwhile, 54% estimate that more than 60% of AI-generated engineering work needs significant human rework before release.
79%
report moderate to intense pressure to demonstrate AI ROI
54%
estimate that more than 60% of AI-generated engineering work needs significant human rework before release
Respondents at AI-using organizations. Self-reported estimates and views. Separate survey questions.
For the report, Dimensional Research surveyed 1,028 people responsible for software development at organizations with more than 250 developers in September 2026. Respondents describe their experiences and estimate the effort involved.
58% of respondents name scaling AI and agent adoption as an engineering priority for the next twelve months. As more AI-generated changes enter development, teams will need to manage the investigation, correction and review they require.
DORA's 2025 research found that organizations using more AI tended to deliver changes faster and report better product performance, but also experienced less stable software delivery. To understand whether an AI rollout is helping, teams should look at how much effort changes take to review and how often they cause problems after release, alongside how quickly they ship.
Understanding code takes a large share of engineering time
An agent can produce a change quickly. Reviewing it may require a senior engineer to trace dependencies across repositories, check local conventions and work out which tests would catch a regression. That investigation can take hours and draw in colleagues who know the affected systems. Those are hours the same engineers could spend on roadmap work and security fixes. As more patches arrive, review can become a bottleneck.
Understanding code already takes a substantial share of engineering time. 65% of respondents estimate that reading, searching and understanding existing code or proposed changes takes more than a quarter of their team's time. For 25%, it takes more than half.
For scale, if a 1,000-developer organization spends a quarter of its engineering time understanding code, that is equivalent to 250 full-time developers' effort. The opportunity is to reduce repeated searching and rediscovery within that work.
Across the sample, 51% report at least 1,000 repositories. Questions about a change can reach well beyond the repository where it starts: what depends on this code, which exceptions matter and whether every affected service has been handled.
Difficulty finding code also leads to duplicated work. 41% of respondents say engineers regularly or frequently recreate functionality that already exists because they cannot find it. Finding an existing implementation before starting another can save both development work and future maintenance.
A critical dependency fix can reach across the codebase
The stakes rise when a dependency has a critical vulnerability. Asked how long it would take to find and fix every affected instance across their codebase, 54% of respondents estimate days or longer, or say they could not complete it.
That work includes locating the dependency, accounting for differences between services and tracking which repositories still need a fix. A merged fix then needs deployment and checks in the running system.
The review has to cover every affected service
A dependency upgrade can require different changes in different services. Reviewers need to check how each service uses the API, which rely on behavior that changed and why a repository might pin an older version. Tests need to cover those differences.
Asked about the challenges of making large-scale code changes, respondents most often selected three areas: understanding dependencies and impact (43%), making changes consistently across repositories (42%), and testing and validation (42%). Respondents could select multiple challenges. An agent working from one repository can leave the reviewer to discover a missed service, a different implementation requirement or a gap in test coverage.
Sourcegraph's Deep Search investigates code and history across indexed repositories and shows the sources behind its answers. Before agreeing on the work, a reviewer can examine which implementations may be affected and why they need different treatment.
For a dependency upgrade, this means locating callers outside the initial workspace and checking how they use the API. That wider view helps the reviewer identify services that would otherwise remain dependent on the old behavior.
Agents need a way to find the code they were not given
Only 10% of respondents to the survey's agent-context question say all their agents share a common view of the codebase, dependencies and history. The rest describe partial sharing or context supplied separately to each agent.
10%
say all their agents share a common view of codebase, dependencies and history.
Base: question labeled for AI and AI coding-agent users, 97% of sample.
Preparing that context takes work on each task. Among respondents at AI-using organizations, 33% say developers must explain extensive background on architecture, dependencies, conventions or history before a tool or agent can work effectively on a new task. DORA's research on AI-accessible internal data also found a stronger link between AI adoption and individual effectiveness and code quality when tools could access relevant internal information.
Through Sourcegraph's MCP server, compatible agents such as Claude Code, Codex and Cursor can search the organization's indexed code as questions arise during a task. They can investigate dependencies beyond the files in their initial workspace.
The server applies existing repository permissions and lets administrators control who can use it and which tools are available.
Engineers can inspect the retrieved code alongside the proposed change. When something goes wrong, that record helps them determine whether the agent missed relevant code, misunderstood an exception or made an implementation error.
Making large-scale changes easier to review
An upgrade or migration gives a team a concrete way to examine how work moves across its codebase. The first challenge is finding every affected repository. From there, engineers need to understand the differences between services, make the changes, and track them through testing and review.
Sourcegraph's Agentic Batch Changes can coordinate that work across repositories and give engineers a shared view of the changes and their progress. Teams can compare the effort and time involved with previous upgrades, including the work of finding dependencies, preparing context, correcting changes, and reviewing the results.
As organizations expand their use of coding agents, that visibility will matter. In the survey, 77% of respondents expect AI-authored changes to merge with less human review in the future. Understanding which changes are ready for that level of autonomy starts with seeing where agents succeed and where engineers still need to step in.
Read the full 2026 Big Code report for the complete findings.