From 3 Hours to 5 Minutes: Unlocking Productivity with SourceFS

More software is created than ever before. Developers can prototype and productize ideas faster, while AI agents can tackle work that teams previously struggled to prioritize, from fixing shallow bugs to keeping up with security updates.

In this blog post, GitHub described how it planned for a 10x capacity increase only to realize a few months later that it needed at least 30x to keep pace with the growth in code creation.

However, for large codebases, this surge in code creation has yet to translate into outsized business outcomes. Features are not reaching the market faster, productivity gains remain localized and delivering security fixes at a faster, more frequent cadence remains difficult. Why is that?

The AI-Driven Development Bottleneck

Once code is generated, it must be built, tested, and deployed before it reaches users. In practice, production pipelines are far more complex, with many validation and deployment stages code goes through before it is released.

An organization's throughput is determined by the speed of the entire pipeline, not by any single stage. If code is generated faster, it must also be built, tested, integrated, and released faster. Otherwise, the bottleneck simply moves downstream, to the next release stage.

Even before AI, checkout-and-build times of 3+ hours were a major constraint for teams working with large codebases. As AI increases the volume of code entering the pipeline, a fast checkout-and-build becomes essential to quick iteration.

The first step to the next level of productivity is a drastically faster checkout-and-build stage.

The Case for a Virtual Filesystem

One important observation when working on a large codebase is that each new change typically touches only a small fraction of the codebase. For example, looking at the number of files changed by the typical PR across the Android Open Source Project (AOSP) codebase, this pattern becomes clear.

The same principle applies beyond checkout. In a large organization, much of the required build work has already been performed elsewhere - by a colleague, an AI or CI agent, or a previous version of the change. If only the net new steps were executed, with everything else replayed, builds could be significantly accelerated.

Some of the world’s most advanced engineering organizations face the same challenges and use virtual filesystems to enable seamless iteration across codebases with billions of lines of code. However, these capabilities often require deep integration with custom source control, build systems, and even developer environments running custom kernels.

Applying these principles to device codebases built around Git, Repo, and existing build systems is much harder, especially without forcing disruptive migrations or custom software stacks on developer machines.

The SourceFS Virtual Filesystem

SourceFS achieves exactly that. It brings virtualized file access and build replay to existing codebases without requiring teams to migrate source control systems, rewrite build rules, or adopt a new build system. 

Instead of downloading the entire source tree upfront, SourceFS presents a complete virtual view of the codebase and materializes files only when they are actually accessed by a developer, CI job, build step, or AI agent. 

At the same time, SourceFS captures build execution in a lightweight sandbox, records inputs, outputs, and environment, and replays cached results whenever the same work has already been performed elsewhere in the organization. 

The result is a checkout-and-build workflow that matches how large codebases are actually used: only the small fraction of files required for a change are materialized, and only the truly new build steps are executed. Everything else is reused. This is what allows SourceFS to reduce checkout-and-build times from hours to minutes, while working with existing Git, Repo, Soong, Ninja, with support for more build systems coming soon.

The Results

The results are impressive. As detailed in a recent AWS blog post, SourceFS reduces AOSP checkout-and-build times from hours to under five minutes, transforming one of the biggest constraints in device development into a fast, repeatable workflow. That shift does more than reduce build times: it unlocks higher engineering throughput, faster AI-agent iteration, and significant infrastructure cost savings.

Get in touch if you would like to deploy SourceFS in your organization.