When AI code overloads CI, Universal Cache keeps builds fast and costs in control

We’re excited to share the launch of Develocity Universal Cache, a critical new capability designed to supercharge Continuous Integration (CI) pipeline efficiency, speed, and reliability. 

But first, the problem Universal Cache is addressing…

AI is introducing new pressures on CI efficiency

The software delivery ecosystem is currently at an inflection point, driven largely by the sheer volume of code generated by AI. GenAI is magnifying challenges for engineering organizations, leading to an explosion in code output, test volume, and overall build complexity. As a result, CI pipelines are becoming overloaded, inefficient, and expensive. 

Several factors are contributing to slow CI systems:

• Build volume explosion: AI has introduced more code more quickly (which also means more tests), all of which must be built and executed, putting tremendous strain on CI resources.
• Ephemeral build overhead: The increasing reliance on ephemeral build environments means that every build starts on a blank slate. This forces massive, repeated overhead, where dependencies, JDKs (toolchains), and build intermediaries are constantly re-downloaded and recalculated.
• Escalating costs: Historically, performance issues were mitigated by scaling CI infrastructure, but this approach is often no longer financially bearable. And now, consumption-based services, such as external dependency repositories or cloud artifact storage, drive financial costs linearly.
• The vicious feedback loop: This strain extends to dependent systems, leading to a loss of Quality of Service (QoS). Higher load across dependencies can lead to slower feedback cycles, which yields increasing test flakiness, which in turn necessitates even more reruns—all of this further strains your already overloaded systems and creates a vicious feedback loop.

The solution: Universal Cache

The clear path back to CI efficiency is comprehensive caching. Caching relieves pipeline pressure by reusing previous work (calculations, generations, and downloads), thereby reducing the load on CI and its dependent systems.

Develocity Universal Cache is the unified, highly-available, and globally distributed caching layer that spans your entire organization, accelerating software delivery. Universal Cache efficiently stores build inputs, setup tasks/goals, and build outputs. By reusing data from jobs already run on CI, this solution dramatically reduces build times and removes one of the biggest sources of instability in the delivery pipeline.

Artifact Cache: Caching inputs before the build 

Until now, development teams have focused primarily on caching the outputs of the build (using a build cache). But to truly optimize CI resources, we must start caching before the build even starts—in other words, start focusing on inputs.

Artifact Cache is designed to efficiently store and restore critical build inputs such as dependencies, toolchains (like JDKs), and build system (eg. Maven, Gradle) artifacts. Downloading all of these files in one connection—versus many separate downloads over the course of the build—further boosts efficiency. 

Setup Cache: Caching environments at build time 

Setup Cache provides a fast, reliable, pre-configured build environment, ensuring every CI run is identical, fast, and stable from the moment it begins.

Some build tools require an initial setup phase. This often involves compiling build source or scripts—for example, when Gradle compiles files like build.gradle.kts. While features like the Gradle Daemon (which keeps in-memory caches) and the Configuration Cache (which reuses previous configuration work) help speed up subsequent builds on a local machine, this initial work still needs to be done.

Setup Cache solves this by making the prepared configuration result available to your entire team. This eliminates the initial compilation step, ensuring all builds start faster and more consistently for everyone.

Build Cache: Caching outputs for future builds

Build Cache remains as critical as ever for accelerating feedback cycles—even more so with the AI-driven increase in code volume.

We introduced the concept of a build cache within Gradle Build Tool in 2017, as part of our mission to automate and accelerate the build process for developers. With Develocity, we took this idea of build caching even further with the remote (or distributed) cache. Develocity Build Cache doesn’t just allow developers to cache and reuse outputs on their local machines, it also automatically caches tasks/goals previously executed on CI for reuse across different machines. So the larger the team and the higher the build volume, the more time saved by avoiding redundant work.