Develocity Build Caching Report

The Develocity Build Caching Report is an agent skill that surveys a Develocity instance and produces a ranked HTML report of the avoidable cache misses costing the most CI time, across your Gradle and Maven builds. It also estimates the CI time that enabling the remote Build Cache would save the projects whose CI builds run with it disabled.

The skill works entirely from Develocity data, reading no source code and running no builds of its own. It detects cacheable work that ran when an identical run was already cached, confirms each candidate against Build Scan data, and ranks the confirmed misses by the CI time they waste. Each miss carries a paste-ready fix prompt. The Report finds and prioritizes the misses worth fixing. It applies no fix itself. You hand each confirmed miss to the Develocity Build Caching Optimizer, which reproduces the miss in the project and fixes it. The two skills together cover the path from finding an avoidable miss to fixing it.

When to Use It

The Build Caching Report finds where an instance is wasting CI time on avoidable cache misses, so you can target the most expensive ones. Common cases:

  • Finding the worst offenders: You want the ranked shortlist of avoidable cache misses across the instance, rather than investigating one project at a time.

  • A recurring review: Run the report on a schedule to catch new avoidable misses before they accumulate CI cost.

  • Feeding the Build Caching Optimizer: You want a queue of confirmed savings opportunities, each with a prompt you can paste into a project checkout to fix it.

  • Finding projects without the remote Build Cache: You want to know which projects run their CI builds with the remote Build Cache disabled, and what enabling it would save each of them.

How It Works

The skill surveys the whole Develocity instance for two kinds of savings opportunity: avoidable cache misses, and projects whose CI builds run with the remote Build Cache disabled. By default, a run looks for both. With skip cache-miss detection, a run looks only for projects without the remote Build Cache: it skips Finding Analyzable Projects, Detecting Avoidable Misses and Confirming Misses, compares no builds, and takes a few minutes. Run the Skill shows how to start each kind of run.

The skill does the following:

  1. Checking Access: Confirms the reporting data is readable, the window holds Gradle or Maven CI builds, and the build comparison tool is available.

  2. Finding Analyzable Projects: Resolves a build custom value that records each project’s source commit, so it can compare runs at the same commit.

  3. Detecting Disabled Remote Build Caches: Finds the projects whose CI builds run with the remote Build Cache disabled, and estimates what enabling it would save each of them.

  4. Detecting Avoidable Misses: Looks for cacheable work that produces more than one cache key at a single commit, or that diverges across enough commits to be worth fixing.

  5. Confirming Misses: Compares Build Scan data for each candidate in cost order, keeping the misses it can confirm until it reaches the target number of confirmed misses (10 by default).

  6. Writing the Report: Writes an HTML report of the savings opportunities, with a paste-ready fix prompt for each confirmed miss.

An avoidable miss is a cacheable task or goal that ran when an identical run at the same commit was already cached. The source was the same, so some other input must have varied between the two runs, such as a baked-in timestamp or an absolute path.

Prerequisites

The Build Caching Report reads Develocity data through a connected Develocity MCP Server. Confirm the following before you run it:

  • A running Develocity instance with the Develocity MCP Server enabled. The skill runs the Develocity Analytics queries and the build comparison tool through it, confirming each miss by comparing Build Scan data. It cannot run without the queries, and cannot confirm a miss without the build comparison tool. See the MCP Server installation manual.

  • An access key whose user can read build data across every project. The MCP tools require the Access build data via the API and MCP permission, and the instance-wide Develocity Analytics queries additionally require cross-project read access. Both are read permissions, so a read-only key is enough. See Permissions and the Develocity API user manual.

  • The Develocity skills installed in your AI agent. See Getting Started.

  • A custom value that records each project’s source commit, such as the Git commit ID recorded by the Common Custom User Data plugins. Grouping builds by commit is how the skill separates an avoidable miss from a legitimate rebuild, so a project that records no commit cannot be surveyed for avoidable cache misses. A project without any detectable commit is skipped.

Run the Skill

The Build Caching Report queries build data across the whole Develocity instance and compares Build Scan data for several pairs of builds, so it runs only when you start it by name. Start it with no arguments to survey the default window, the 7 full days ending yesterday (UTC), aiming for 10 confirmed misses and estimating what the remote Build Cache would save the projects whose CI builds run with it disabled:

/develocity-build-caching-report

The skill states what it will do and waits for you to confirm before it surveys anything. You can name any of four things: another time window, another target of confirmed misses, the name of the Build Scan custom value that records the commit, or skip cache-miss detection. Write them in plain words, not as flags, either after the command as in the examples below or in your reply when the skill asks you to confirm.

Survey a shorter window and aim for fewer confirmed misses:

/develocity-build-caching-report last 3 days, target 5 confirmed misses

Name the custom value that records the commit:

/develocity-build-caching-report commit field 'Git commit id'

List only the remote Build Cache adoption rows. The run looks for no cache misses, runs no build comparisons, and takes a few minutes:

/develocity-build-caching-report skip cache-miss detection

Results

The skill prints a ranked summary of the findings in the conversation, and ends the run with a full HTML report in your working directory. The report ranks avoidable cache misses and projects with the remote Build Cache disabled in one table, by the CI time each costs per week.

The report summarizes the Savings opportunities and the Recoverable CI time.

A savings opportunity is a fix that, if implemented, would improve the Build Cache savings in a particular project. This includes enabling the remote Build Cache if it is disabled.

Recoverable CI time is how much CI time per week would be saved if all of the opportunities are fixed. It is calculated from the time that cache misses spent running during CI builds. Where the remote Build Cache is disabled, the report shows a separate estimate of the savings that enabling it may bring.

The report then goes into detail, explaining each savings opportunity as its own row. If it is a confirmed avoidable cache miss, it includes:

  • the task or goal, a root-cause classification, evidence, and how much CI time it wastes, and

  • a paste-ready fix prompt. You open your AI agent in the affected project’s checkout and paste the prompt, which starts the Build Caching Optimizer on that miss.

Otherwise, if it is a disabled remote Build Cache, it includes:

  • an estimate of the CI time per week that enabling the remote Build Cache would save, from the cacheable tasks or goals that re-ran although an earlier CI build had already produced their cache key, and

  • an Enable remote Build Cache button, which opens the getting-started documentation of the Develocity Gradle plugin or Maven extension for the remote Build Cache.

The table lists at most 40 projects with the remote Build Cache disabled, but the totals include all of them. Projects that would save less than 0.5 CI hours over the survey window are not displayed. Remote Build Cache savings are estimates, marked with ~. Once a project enables the remote Build Cache on CI, the report can find its avoidable cache misses after about a week of CI builds.

A run over a clean instance reports few or no misses. That is a result, not an error.

Scope

The Build Caching Report surveys, confirms, and ranks. It does not:

  • read or change a project’s source. It works from reporting data and Build Scan comparisons only,

  • apply a fix. You hand each confirmed miss to the Build Caching Optimizer, which you run yourself in the affected project, or

  • survey anything but Gradle tasks and Maven goals.

Considerations

  • A run queries build data across the whole instance and compares Build Scan data for several pairs of builds, so it typically takes 10 to 20 minutes. With skip cache-miss detection, it takes a few minutes.

  • The skill uses your AI agent’s model, so each run consumes model tokens. Set budget and turn limits in your agent to bound a run.

  • Connectivity to Develocity is handled by the Develocity MCP Server, and configured when you set up that server.