Inspiration: The Pit Lane Bottleneck
In Formula 1, a race is won or lost in the pits. A team of experts performs high-precision service in seconds to get the car back on the track. As a software engineer, I’ve often seen the opposite in my daily work: code sits in the "pit lane" for days waiting for a review, or a deployment fails because no one checked the "engine temperature" of the production environment.
I saw a clear need for a tool that doesn't just track tasks, but actually understands the technical heartbeat of a project. I built Pit-Stop AI to bring F1-level precision to Jira, creating an automated "Pit Crew" that removes friction, predicts bottlenecks, and ensures every release is "Race Ready."
How I Built It: The Engineering Stack
I used the Atlassian Forge platform to build a seamless integration within Jira. The project consists of three core specialized modules:
The AI Reviewer (Rovo Agent): An agent I built to analyze Jira issues and GitHub code diffs to provide an immediate "Readiness Score."
The Safety Car (Telemetry): Backend resolvers I implemented to fetch real-time health metrics from external monitoring APIs (like Datadog or Prometheus) to block risky deployments.
The Tyre Coach (Reviewer Assignment): A custom tool I developed to identify the best reviewer by analyzing GitHub commit history and current Jira workloads.
I opted for a Custom UI approach, using a dedicated build script to generate a lightweight, high-performance interface that loads instantly.
Smart Logic: Context-Aware Reviewing
Instead of random assignments, I developed a Context Scoring system. The app looks at three specific data points to suggest the right "Tyre Compound" (Reviewer):
Expertise: How many times has this person touched these specific files?
Recency: How long has it been since they last worked in this area of the code?
Workload: How many "In Progress" tasks do they currently have in Jira?
This logic ensures that critical fixes go to the fastest available experts, while complex new features go to those with the deepest knowledge.
Challenges: Navigating the Hairpin Turns
Building a bridge between Jira, GitHub, and AI presented several hurdles:
Platform Synchronization: I initially faced persistent installation errors. This taught me the importance of Forge lifecycle management and how to properly purge deprecated components to maintain a clean environment.
The Data Connection Trio: Balancing Jira Data, Direct GitHub API calls, and Webhooks was a challenge. I learned that while APIs provide the "intelligence" (code diffs), Webhooks are the only way to achieve the "automation" needed for a real-time experience.
What I Learned
This project was a masterclass in modern Developer Experience (DX). I learned that AI is most effective when it has access to raw, cross-tool telemetry. By connecting the Rovo Agent to GitHub's raw code, I moved beyond simple text summaries to actual technical analysis. I discovered that the best tools are proactive—they don't just tell the developer there is a problem; they prevent the problem from reaching the track.
Next Steps
My immediate next steps for Pit-Stop AI involve transitioning from a diagnostic tool into a proactive, automated co-pilot. I plan to refine the Rovo Agent to ingest deeper technical context from documentation and operationalize the "Safety Car" module with live monitoring integrations. I also intend to launch the "Tyre Coach" predictive analytics to forecast project "lap times" and expand support to Bitbucket and GitLab. My goal is to introduce "Race Radio" notifications via Slack to ensure every stakeholder remains perfectly synced with the high-velocity development race
Log in or sign up for Devpost to join the conversation.