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.

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 opportunity 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.

How It Works

The skill surveys the whole instance and progresses through five phases:

  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 Avoidable Misses: Scans the corpus for cacheable work that produces more than one cache key at a single commit, or that diverges across enough commits to be worth fixing.

  4. 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).

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

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, and cannot run without either. 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. It skips such a project, and stops only when no project records one.

Run the Skill

The Build Caching Report runs corpus-scale analytics queries and several build comparisons against a live Develocity server, 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:

/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 three things: another time window, another target of confirmed misses, or the build custom value that records the commit.

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'

Results

The skill writes an HTML report in your working directory and ends the run on it, after printing a ranked summary of the report in the conversation. The report ranks the confirmed avoidable cache misses by the CI time they waste, and each row carries:

  • 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.

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 opportunity 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 executes corpus-scale queries and several build comparisons, and typically takes 10 to 20 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.