From 3 Hours to 5 Minutes: Unlocking Productivity with SourceFS

More software is created now than ever before. Developers can prototype and productise ideas faster, while AI agents can take on work that teams would previously struggle to prioritize, from fixing shallow bugs to more ambitious efforts like keeping up with security updates.

In a recent blog post, GitHub described how it planned for a 10x capacity increase only to realize that they should have planned for at least a 30x capacity increase, only a few months later, to be able to sustain the growth in code creation.

However, for large device codebase, this surge in code creation does not yet correlate to business outcomes. Devices are not reaching the market faster. Productivity gains remain limited. Security patches are still hard to deliver quickly and consistently. And the next generation of intelligent features we are all waiting for are slow to materialize. So 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 stages and deployment stages, the generated code goes through before it is released.

A device organization throughput is determined by the speed of the entire pipeline, not 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, and limits productivity gains.

Even before AI, checkout-and-build times, often taking 3+ hours, were a major constraint on device software development. As AI increases the volume of code entering the pipeline, fast checkout-and-build becomes essential to fast iteration - for both developers and AI agents.

To unlock a next level of productivity, checkout-and-build times need to shrink dramatically.

The Case for a Virtual Filesystem

When working on a large codebase, one important observation is that each new change stack typically touches only requires a very small fraction of the overall codebase. Looking at the number of lines and files changed for typical changes in key projects across Android 16, this pattern is clear.

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

Virtualized file access and build execution, deeply integrated with purpose-built source control, build systems, and developer environments, are how some of the world’s most advanced engineering organizations enable seamless iteration across massive, billion-line monorepos.

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

The SourceFS Virtual Filesystem

SourceFS achieves exactly that. It brings virtualized file access and build replay to existing device 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 work is executed. Everything else is reused. This is what allows SourceFS to reduce AOSP checkout-and-build times from hours to minutes, while working with existing Git, Repo, Soong, Ninja, and CI infrastructure.

The Results

The results are impressive. As detailed in a recent AWS blog post, SourceFS reduces AOSP 16 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.