As senior engineers and engineering leaders, we are constantly chasing speed and stability. The introduction of Agentic AI has certainly accelerated code production. So we’re creating a lot more code, which is great, but we have to consider the human costs associated with this explosion in code volume.
The dream, of course, is that developers can focus on the interesting and satisfying parts of creating software, and that AI can handle the rest. Yet recent data, like the DORA report, demonstrates our current reality is in conflict with that dream: the more we adopt AI, the more we increase our software delivery instability. This means that developers are spending more time than ever before on fixing versus creating.
What’s really happening here? As more code gets written entirely by AI, we developers don’t automatically understand what our code does, and it becomes harder to repair when it fails. Developers are now spending the majority of their time reviewing code, fixing broken builds or tests, or often just trying to understand the problem itself. As a result, troubleshooting is the new bottleneck in software delivery.
If we want to deliver more value—not just more code—we have to unblock the troubleshooting phase. This post will show you how we can tackle the troubleshooting bottleneck directly from within the IntelliJ ecosystem.
With the free Develocity IntelliJ Plugin (with over 33,000 downloads), you can already get immediate insight into your builds. And Develocity customers get to leverage Develocity’s deep, comprehensive build data and agentic AI (via the Develocity MCP server) to rapidly solve the toughest yet most common build problems, the ones that drain developer time and happiness.
If you prefer watching a video to reading a post, check out our recent webinar: Using IntelliJ with Develocity AI for faster troubleshooting.
The Develocity IntelliJ Plugin cuts out the frustrating cycle of the inner development loop and brings build performance analysis right to us, where we spend most of our time: inside an IntelliJ Platform IDE, like IntelliJ IDEA or Android Studio.
If you don’t have a Develocity subscription, you can still experience some of the power of this plugin with immediate local build analysis.
Let’s walk through how to get started.
The first step is getting the plugin into your IDE:
- Go to File > Settings (or IntelliJ IDEA > Settings on macOS)
- Navigate to Plugins > Marketplace
- Search for “Develocity”
- Click Install and restart your IDE when prompted
One of the standout features is the Live Build Timeline. As tasks run, they appear in the timeline in real time, providing immediate insights into task execution and resource consumption (CPU and memory).
This real-time visualization helps you quickly identify bottlenecks, such as a single task taking an unusually long time, suggesting it might benefit from parallelization.
This feature requires the Develocity Gradle plugin 4.1 or newer to be applied to your Gradle build so the IntelliJ plugin can receive data from the build process
- Go to File > Settings (or IntelliJ IDEA > Settings on macOS)
- Navigate to Tools > Develocity
- Check Apply Develocity Gradle plugin
- Enter the version (e.g., 4.2) and press OK
While local analysis is great, connecting to a Develocity server (subscription required) is where the full power of troubleshooting, including access to agentic AI, is really unlocked.
- Go to File > Settings (or IntelliJ IDEA > Settings on macOS).
- Navigate to Tools > Develocity.
- Check Configure Develocity integration.
- Agree to the Terms of Use and press OK.
Now, every time you run a Gradle build, you’ll get a pop-up pointing you to the published Build Scan, and you can navigate deep into the scan directly from an individual task in the IntelliJ timeline.
If you’re an existing Develocity customer, you can contact our support team to get started with the MCP server.
We can ask an LLM to parse a stack trace, and it will give us decent results. But to do a good job, AI needs comprehensive data that provides both depth and breadth. This is where Develocity shines, because it contains information far beyond what a typical stack trace provides.
Develocity captures a Build Scan from all local and CI builds, providing essential context. Without this information—that’s both deep and wide—the LLM is more likely to hallucinate and mix things up.
This comprehensive data allows us to ask complex, contextual questions that an LLM with access only to a single build log could never answer, such as:
- Dependency resolution status
- Build flow and infrastructure details
- Cache hits
- Comparison of local vs. CI environment settings
- Identifying if other developers are facing the same issue
With the Develocity IntelliJ Plugin connected to the Develocity platform and leveraging its extensive data, we can now use agentic AI to solve the toughest yet most common build problems, the ones that drain developer time and happiness. The image below represents an example of a developer using plain language with agentic AI connected to the Develocity MCP server to summarize failures over the last 24 hours.
This is arguably the most annoying issue: your local build is green, but the CI pipeline is failing. Instead of hours of manual comparison, we simply ask the agent to compare the two environments.
Ask the agent: Please explain why my last build succeeded on my machine, but not in CI.
- The agent parses local branch information
- It connects to the Develocity server to fetch both the local and CI build data
- It compares the build environments and findings
The insight: In a demo, the agent quickly identified an operating system difference that was the "likely contributor to test failure, possibly due to the paths and case-sensitive issues.
“This gives me a really good direction on where to look for the failures. And these kinds of things like case sensitivity on one and not on the other can sometimes be difficult to track down because you're looking at the same commands and they don't mean the same thing in different operating systems.” Source
Sometimes the issue is reversed: the build fails locally but passes in CI. This often points to local environment issues, like missing variables, that are correctly set in the CI environment.
Ask the agent: My build just failed. Compare it with the same build in CI.
The insight: The agent quickly identifies that the build failed because it required an environment variable that was not set locally and then suggests a modification to fix the build.
Because Develocity gathers data from all developers, you can ask a powerful contextual question: Do other developers experience similar failures in this branch?
If the agent returns, "I did not find any evidence of other developers facing similar issues in your branch," then you know definitively that the issue is confined to your local setup, saving you from chasing global problems.
Flaky tests are productivity killers! They mask genuine failures and force unnecessary re-runs. Develocity’s breadth of data allows the agent to analyze historical runs to determine if a recent failure is genuine or just flakiness.
Ask the agent: My build is failing. Were there failing flaky tests during the day?
The insight: The agent differentiates between genuine failures and flakiness, sometimes even suggesting a fix for the genuine failure.
“The agent says the test is flaky, it fails randomly…whereas this one is actually a genuine failure. It fails because of something (the something doesn’t matter here) and then it says, I can suggest a fix for the genuine failure.” Source
When a build fails, the first step is triage: is this a central platform problem (infrastructure) or a development error (code)?
Ask the agent: My build failed. Is it due to an infrastructure issue?,
The insight: The agent investigates both local and CI failures and provides a clear breakdown: "Your build is due to two separate test failures. One failure points to an infrastructure issue due to an external service not being reachable, whereas the other one is a code related issue.” This clarity helps us immediately know whether to fix code ourselves or delegate the problem to the central platform team.
Dependency conflicts can be frustratingly hard to pinpoint, especially in large, complex projects. We can ask a very open question and let the agent leverage the dependency resolution data from the Build Scan.
Ask the agent: What is wrong with my build?
The insight: The agent can look into recent and past builds and determine, for example, that "Your build failure is due to dependency conflict with the Guava library." The agent explains the problem and even provides a suggested fix, like updating the library from version 17 to 21.
The utility of this system isn't limited to individual developer troubleshooting. Central platform and Developer Productivity Engineering (DPE) teams can use the agent to analyze the collective health of your organization's builds.
By querying the analytics data provided by Develocity's MCP (Managed Continuous Performance) server, a central team can quickly identify and prioritize massive organizational bottlenecks.
Ask the agent: Look at Develocity Analytics data… Present the data as a table so I can see where I should focus my efforts because things are broken.
The insight: The agent can list multiple projects and immediately categorize the primary failure type for each: "infrastructure is completely broken", "code generation logic", or "database connectivity". This is an extremely powerful way for central teams to quickly identify issues that impact the entire organization and so understand where to focus their efforts.
The Develocity IntelliJ plugin combined with a Develocity subscription makes interacting with LLMs simple and efficient, driving collaboration and speed. By deeply integrating AI and comprehensive build data right into the developer experience, we ensure that as more code is produced by AI, we can stabilize, understand, and deliver that code faster than ever before.
