AI Devops Agent

Universal AI DevOps Agent automatically detects bugs from user feedback, finds the root cause, and creates a Merge Request with the fix. Any app. Zero manual debugging.

Comment

Inspiration

As developers, we constantly faced the same frustrating cycle — users report bugs, developers manually read through feedback, spend hours debugging, write issue reports, find the root cause, implement a fix, and finally deploy. This entire process could take days. We asked ourselves: what if an AI agent could handle everything from the moment a user complains to the moment the fix is deployed? That question inspired the Universal AI DevOps Agent.

We were also inspired by the power of GitLab Duo Agent Platform and Anthropic's Claude API — two technologies that together make it possible to build agents that don't just chat, but actually take action inside a real codebase.

What it does

The Universal AI DevOps Agent is a plug-and-play pipeline that connects user feedback directly to automated code fixes. Here is the complete flow:

  1. A user submits feedback on the live application describing a bug or issue
  2. The feedback is stored in Supabase (PostgreSQL)
  3. A 6-stage GitLab CI/CD pipeline triggers automatically
  4. Stage 1 — Feedback Analysis: fetches all unresolved complaints from Supabase and groups them by component
  5. Stage 2 — Issue Detection: confirms severity as LOW, MEDIUM, or HIGH based on complaint frequency
  6. Stage 3 — Root Cause Analysis: Claude (Anthropic) reads real user descriptions and reasons about the specific technical cause
  7. Stage 4 — Fix Generation: generates a prioritized list of actionable fixes
  8. Stage 5 — Issue Creation: automatically creates a detailed GitLab issue with the full report
  9. Stage 6 — Code Fix Agent: GitLab Duo reads the issue, explores the codebase, finds the exact bug, and raises a Merge Request
  10. Developer reviews and clicks Merge — Vercel auto-deploys in 7 seconds

The entire flow from user complaint to deployed fix takes under 5 minutes. The developer only clicks Merge.

To demonstrate the agent we built an AI-powered Quiz Application with React.js, Flask, and Supabase where real users reported bugs like timer resets and score display issues. The agent detected, diagnosed, and fixed all of them automatically.

How we built it

Frontend: React.js with Vite and Tailwind CSS, deployed on Vercel. Features quiz gameplay with a 10-second timer, score tracking, leaderboard, and a feedback modal where users report issues with subject, category, and component fields.

Backend: Flask REST API with PyJWT authentication, deployed on Render. Handles quiz questions, score submission, user stats, and feedback collection. Connected to Supabase using the Python client.

Database: Supabase (PostgreSQL) with tables for users, categories, questions, quiz results, and feedback. The feedback table is the core data source for the agent pipeline.

AI Agent Pipeline: Six Python scripts running in GitLab CI/CD stages. The feedback analyzer fetches data from Supabase via REST API. The root cause agent calls Anthropic Claude API with real user descriptions to reason about the technical cause. The create issue script calls the GitLab API to generate a rich formatted issue.

GitLab Duo Code Fix Agent: A custom public agent created in GitLab Duo Agent Platform with a system prompt that knows the entire codebase structure through AGENTS.md. Uses built-in GitLab tools including find_files, get_repository_file, edit_file, and create_merge_request to autonomously fix bugs.

Universal Configuration: A single agent_config.yml file maps the app name, feedback table, issue column, and GitLab project ID. Any team can integrate the agent by changing 5 values in this file.

Challenges we ran into

1. Database migration from SQLite to Supabase We initially built all 6 agent scripts for SQLite. When we moved to Supabase for public deployment, every database connection had to be rewritten to use the Supabase REST API. The data persists correctly now but the migration took significant debugging time.

2. GitLab CI variable injection Setting CI variables as Protected prevented them from reaching the pipeline runner since our branch was not protected. The variable SUPABASE_URL was being treated as a literal string instead of the actual URL value, causing the agents to fail with MissingSchema errors. This took hours to diagnose.

3. Feedback classification accuracy We initially used Claude to classify feedback as positive or negative. However user descriptions were too short for reliable LLM classification — phrases like "best score issue" were being classified as positive. We simplified the logic to treat all submitted feedback as complaints, which is more accurate for a dedicated feedback form.

4. Agent giving generic fixes The GitLab Duo Code Fix Agent was generating generic React fixes like adding ErrorBoundary components instead of fixing the specific timer bug. We solved this by creating AGENTS.md — a codebase knowledge base that tells the agent exactly which files handle which features and what the known bug patterns look like.

5. Compute minutes exhausted GitLab free tier compute minutes were exhausted during development. We adapted by running the agent pipeline locally using Python directly, which produced identical results and actually made for a more compelling live demo.

Accomplishments that we're proud of

  • Built a truly universal agent — changing just 5 values in one config file makes it work for any web application
  • Successfully detected and auto-fixed 3 real bugs reported by actual users on the live application — timer reset bug, best score display bug, and question skip bug
  • The GitLab Duo Code Fix Agent created precise, surgical Merge Requests that fixed the exact lines causing the bugs
  • Vercel auto-deployed every fix within 7 seconds of merge — fully automated from complaint to live fix
  • The entire pipeline from user complaint to deployed fix runs in under 5 minutes with only one human step — clicking Merge
  • Built a production-ready application with real users, real feedback, and real automated fixes — not just a demo

What we learned

  • LLM reasoning on real data is powerful — Claude reading actual user descriptions produces far more specific and accurate root cause analysis than any rule-based system
  • GitLab Duo Agent Platform is a production-grade tool for building autonomous coding agents, not just a chat interface
  • AGENTS.md is the agent's brain — the quality of the agent's code fixes is directly proportional to how well you document your codebase for it
  • Hybrid AI architecture works best — rule-based agents for fast pattern detection combined with LLM reasoning for intelligent analysis gives the best balance of speed and accuracy
  • Separation of concerns in deployment — keeping the agent pipeline completely independent of the application backend means it works even when the backend is down

What's next for AI DevOps Agent

  • LLM-powered fix generation — replace rule-based fix suggestions with Claude generating context-aware code fixes directly, making the MR even more precise
  • Auto-merge for low-risk fixes — automatically merge fixes for simple bugs like typos, config changes, or missing null checks without requiring human review
  • Multi-bug parallel processing — run the pipeline in parallel for each component so multiple bugs are detected and fixed simultaneously in separate MRs
  • Feedback analytics dashboard — a real-time dashboard showing bug trends, resolution time, agent accuracy, and component health scores
  • Slack and email notifications — alert the right developer the moment an issue is detected, with the root cause and fix already attached
  • Support for mobile apps — extend the agent to work with React Native and Flutter applications using crash logs and app store reviews as feedback sources
  • Self-improving AGENTS.md — after each successful fix, the agent automatically updates AGENTS.md with the new bug pattern so it gets smarter with every issue it resolves ```

Built With

  • anthropic-claude-api
  • axios
  • cause
  • flask
  • flask-cors
  • gitlab
  • gitlab-ci/cd
  • gitlab-duo-agent-platform
  • gitlab-rest-api
  • javascript
  • jwt-authentication
  • llm-powered
  • postgresql
  • pyjwt
  • python
  • react.js
  • render
  • root
  • sql
  • supabase
  • supabase-rest-api
  • tailwind-css
  • vercel
  • vite
Share this project:

Updates