AI Code Healer for Fixing Broken CI/CD Builds Fast
A deep dive into how GeekyAnts built an AI-powered Code Healer that analyzes CI/CD failures, summarizes logs, and generates code-level fixes to keep development moving.
The Problem Every Developer Knows
You are on vacation. Your phone buzzes. A build has failed.
You have no laptop, but the expectation is clear: find the problem and fix it. For developers who work with CI/CD pipelines, this scenario is routine. Pipelines fail at the worst moments, blocking releases and forcing engineers to sift through thousands of lines of diagnostic logs from wherever they happen to be.
Our internal engineering teams built a specialized Code Healer to address exactly this.
How the System Works
The solution is a centralized dashboard that connects to your GitHub or GitLab repositories. From this dashboard, developers can monitor their build pipelines, tracking progress, successes, and failures from any device, including a mobile phone.
The platform goes beyond simple monitoring. When a pipeline fails, the system analyzes the failure and guides developers toward a resolution, without requiring them to manually read through massive log files. It delivers AI-powered analysis and specific suggestions for fixing the problem at the code level.
The Two-Agent Architecture
At the heart of the Code Healer is a two-agent AI architecture — meaning two distinct AI systems that work in sequence to diagnose and solve build failures.
The two agents are:
A Local AI Agent: A lighter AI model that runs close to (or within) the developer's own infrastructure.
An Advanced AI Agent: A more powerful AI model capable of deeper reasoning.
When a developer clicks Analyze Failure, the full log from the failed build is sent to the backend. The first task is to strip out the "noise" — CI logs frequently run to thousands of lines, but only a fraction of that content is relevant to understanding what went wrong.
Once the log is cleaned and structured, it is passed to the Local AI Agent, which produces:
A failure summary: A plain description of what went wrong.
Impacted files: The specific files likely connected to the failure.
Possible solutions: Initial recommendations for fixing the issue.
A semantic prompt: A compressed, structured description of the problem context.
That semantic prompt is then forwarded to the Advanced AI Agent, which performs deeper analysis and returns refined failure summaries and detailed solution suggestions.
Code-Level Fixes
Once the initial diagnosis is complete, the developer can click Advanced Assist. At this stage, a specialized AI agent creates a code patch — a specific set of code modifications intended to fix the identified issue.
The same layered methodology is used in this patch generation process: the request goes via the Local Agent before arriving at the Advanced Agent. This ensures that the input the advanced model receives is well-structured, which in turn produces more precise and useful code fixes.
Why Use a Local Agent at All?
Our team implemented the Local Agent for two concrete reasons:
Cost and Speed: Build logs are massive. Sending them in their entirety to a sophisticated AI model results in high latency and costs. The Local Agent serves as a compression layer, extracting only the pertinent context.
Data Privacy: Many organizations are cautious about sending source code to external systems. The Local Agent can be deployed entirely within the client's own cloud environment, ensuring sensitive data never leaves the organization's infrastructure.
Continuous Improvement
The Local Agent is designed to operate independently, but the system also has a mechanism to improve its quality over time. When the Local Agent cannot resolve a problem with confidence, the system escalates to the Advanced Agent. The solution produced is then used as a training signal — feedback that gradually makes the Local Agent more capable.
The Broader Goal
The vision our team holds is that developers should build products, not spend their time diagnosing broken pipelines. By combining pipeline monitoring, AI-driven failure analysis, and code-level suggestions, we are moving toward a future where build systems can identify and resolve their own problems with minimal intervention.
This article was originally published on the GeekyAnts blog.
