DepL AI — Your CI/CD Incident Commander

Inspiration

Every developer knows how frustrating it can be when a CI/CD pipeline fails. A failed job can interrupt development, delay a release, and force developers to spend valuable time moving between pipeline pages, job logs, configuration files, and merge requests just to understand what went wrong.

I wanted to build something that could make this process simpler.

That idea led to DepL AI, an AI-assisted CI/CD Incident Commander designed to bring pipeline monitoring, failure investigation, and AI-generated fix proposals together in one dashboard.

Rather than making developers search through different parts of GitLab to understand an incident, DepL aims to give them a clearer view of what failed, why it failed, and how they might resolve it.

What It Does

DepL AI connects to GitLab and provides a centralized interface for investigating CI/CD incidents.

Its key features include:

GitLab project integration: Access projects available to the connected GitLab account.
Pipeline monitoring: View pipeline activity and identify failed pipelines.
Job log inspection: Open job logs to investigate failures and understand what happened.
AI-assisted recovery: View GitLab Duo-generated fix proposals and associated merge requests.
Human-controlled changes: Review proposed corrections before applying them, rather than automatically merging unverified changes.

The goal is to shorten the journey from pipeline failure to understanding the problem and evaluating a possible fix.

How I Built It

I built DepL AI using a modern web development stack:

Next.js and React for the application interface.
TypeScript for application logic and type safety.
Tailwind CSS for styling the dashboard.
GitLab APIs for retrieving project information, pipeline activity, job logs, and merge request details.
GitLab Duo Agent Platform for AI-assisted CI/CD failure investigation and fix proposals.
Render for deploying the web application.

I developed the application around a practical workflow: connect to GitLab, select a project, inspect pipeline activity, investigate failed jobs, and review available AI-generated repair proposals.

A major part of the implementation was connecting the dashboard to GitLab's APIs while keeping the interface understandable and useful. I also worked on making the project build successfully and deploying a live version that people can explore.

A Real CI/CD Challenge

One of the most important challenges involved validating the pipeline itself.

During development, my pipeline encountered a YAML configuration error involving the script definition of a test job. I initially focused on the script's formatting, but the experience taught me to distinguish between a configuration error and a job that is failing because of its actual command.

After correcting the YAML formatting, the pipeline configuration became valid. The test job then exposed a separate issue: it deliberately executed exit 1, which caused it to fail.

This became a useful demonstration of the difference between identifying a failure and actually fixing it.

GitLab Duo investigated the failed pipeline and proposed removing the intentional failure command. After applying the correction, I was able to get the pipeline passing.

That experience reinforced an important principle behind DepL AI: an AI-generated explanation or fix is not the same as a verified resolution. Developers need to inspect the evidence, review the proposed change, and confirm that the pipeline succeeds.

What I Learned

Building DepL AI taught me lessons beyond writing code.

I learned how to integrate a web application with GitLab, work with pipeline and job information, handle API responses, and deploy a Next.js application. I also gained practical experience with CI/CD configuration, troubleshooting YAML errors, investigating job failures, and working with GitLab Duo's AI-assisted workflows.

Most importantly, I learned that useful AI tools should do more than generate suggestions. They should help people understand the problem, connect recommendations to relevant evidence, and verify the outcome.

Working through the project also strengthened my ability to debug unfamiliar problems, test assumptions, and keep moving when deployment or integration issues appeared.

Challenges I Faced

The biggest challenges were integrating the different GitLab components, troubleshooting pipeline configuration, and getting the application deployed and connected to real project data.

Developing in a mobile coding environment added another layer of difficulty. I had to work carefully through terminal commands, dependencies, build errors, Git operations, and deployment configuration.

Instead of abandoning the project when these issues appeared, I approached them incrementally: identify the error, make a targeted correction, rebuild, and test again.

These challenges helped shape DepL into a working project rather than just an idea or mockup.

What's Next?

DepL AI is a foundation for a more comprehensive CI/CD incident management experience.

Future improvements could include:

Better classification and grouping of recurring pipeline failures.
More detailed incident summaries with links to relevant job logs.
Clearer explanations connecting proposed fixes to the underlying errors.
Pipeline history and incident tracking.
Improved verification of fixes after changes are applied.
Additional safeguards and controls around AI-assisted remediation.

The long-term vision is to help development teams spend less time investigating repetitive CI/CD problems and more time building and shipping software.

Final Thoughts

DepL AI represents my effort to turn a real development frustration into a practical tool. Building it challenged me to work across frontend development, API integration, CI/CD troubleshooting, AI-assisted workflows, and deployment.

I'm especially interested in the intersection of AI and developer tooling: not AI that simply produces more output, but AI that helps developers understand incidents and make better-informed decisions.

DepL AI brings the investigation, the evidence, and the proposed next step closer together—while keeping the developer in control.

Live Demo: https://depl-all4.onrender.com/

GitLab Repository: https://gitlab.com/gitlab-ai-hackathon/transcend-october-2026/43235643/depl