DEV Community

Cover image for BugWhisperer: How I Finally Finished My Abandoned GitHub Issue Analyzer (8 Months Later) with GitHub Copilot
Simran Shaikh
Simran Shaikh Subscriber

Posted on

BugWhisperer: How I Finally Finished My Abandoned GitHub Issue Analyzer (8 Months Later) with GitHub Copilot

#devchallenge #githubchallenge #webdev #githubcopilot

GitHub “Finish-Up-A-Thon” Challenge Submission

My Submission

GitHub Repo: https://github.com/SimranShaikh20/BugWhisperer
Live Demo: https://bugwhisperer.msusimran20.workers.dev

The Project I Abandoned — September 2025

Eight months ago I had a problem.

Our dev team had 60+ open GitHub issues across 3 repos. Nobody knew what to fix first. Every sprint planning meeting turned into a 45-minute debate about priority. I thought: what if a script could just read all the issues and tell us what is most critical?

So I started building. Here is the entire codebase from that day:

import requests
import os

# TODO: fix this later
GITHUB_TOKEN = "put_your_token_here"

def get_issues(repo):
    # this doesnt work properly
    url = f"https://api.github.com/repos/{repo}/issues"
    r = requests.get(url)
    print(r)  # just printing for now
    # TODO: parse response properly

def analyze_issue(issue):
    # wanted to use openai here but ran out of time
    pass

def main():
    repo = "facebook/react"  # hardcoded lol
    get_issues(repo)
    # analyze_issue() # commented out, broken
    print("done?")

main()
Enter fullscreen mode Exit fullscreen mode

Yes. That is it. A print(r) that prints the raw response object. A function called analyze_issue that literally does nothing. A hardcoded repo URL.

My commit message on September 15, 2025:

"initial attempt - giving up for now, too complicated"

And that was it. The repo sat there for 8 months untouched.

Add link

Sprint

Why I Finally Came Back

When I saw the GitHub Finish-Up-A-Thon challenge, this project was the first thing that came to mind. The idea was always solid. The problem was real. I just never had the right tools or the time to push through the hard parts.

This time I had GitHub Copilot.

What I Built — The After

BugWhisperer is now a full AI-powered GitHub Issue Command Center.

Paste any GitHub repo URL → Get instant AI triage of every open issue in seconds.

Here is everything it does now:

AI Analysis for Every Issue

Every open issue gets analyzed by Groq's Llama 3.1 AI and returns:

  • Root Cause — what is likely causing this issue
  • Suggested Fix — concrete actionable solution in plain English
  • Complexity — Low / Medium / High
  • Priority — Low / Medium / High / Critical

Kanban Priority Board

Instead of a boring list, issues are sorted into a 4-column visual board:

  • 🔴 Critical — fix immediately
  • 🟠 High — this sprint
  • 🟡 Medium — next sprint
  • 🟢 Low — backlog

AI Sprint Planner

One click generates a complete 2-week sprint plan with time estimates, recommended team size, and a week-by-week breakdown.

Export to Markdown

Download the entire analysis as a .md file — paste it into your GitHub Wiki, Notion, or Linear instantly.

Post Analysis to GitHub

Post the AI analysis directly as a formatted comment on any GitHub issue — no copy-pasting, no leaving the app.

How GitHub Copilot Made This Possible

This is the honest story of where Copilot actually helped me — not a vague "it was amazing" but the specific moments where it unblocked me.

Moment 1: Understanding My Own Broken Code

I opened the old main.py in VS Code with Copilot and typed:

"What is this code trying to do and what is broken?"

Copilot told me immediately:

  • No authentication headers on the GitHub API call (hence the silent failures I was getting 8 months ago)
  • Response was never parsed — print(r) just prints the response object, not the data
  • analyze_issue was completely empty

It then suggested the complete fixed GitHub API call with proper authentication, pagination, and error handling. What I could not figure out in a week 8 months ago, Copilot explained and fixed in 2 minutes.

Moment 2: Reliable JSON from an LLM

The hardest technical problem was getting structured JSON output from an AI model reliably. Every time I tried, the model would add markdown fences around the JSON, add explanation text, or sometimes just break the format entirely.

I described the problem to Copilot and it wrote this system prompt pattern that solved it completely:

You are a senior software engineer analyzing GitHub issues.
Respond ONLY in valid JSON format.
No other text. No markdown. No explanation. Just JSON.

{
  "root_cause": "...",
  "suggested_fix": "...",
  "complexity": "Low or Medium or High",
  "priority": "Low or Medium or High or Critical"
}
Enter fullscreen mode Exit fullscreen mode

The key Copilot taught me: "No other text. No markdown. No explanation." is far more reliable than just saying "respond in JSON format." That single insight saved me probably 3 hours of prompt debugging.

Moment 3: The Kanban Board Component

I had never built a Kanban board before. I asked Copilot:

"Write a React component that takes an array of issues each with a priority field and displays them in 4 columns: Critical, High, Medium, Low"

It wrote the entire working component in one response. I just connected my data to it.

Moment 4: The Sprint Planner Prompt

I described what I wanted — take all analyzed issues and generate a 2-week sprint plan. Copilot wrote the complete AI prompt, the API call, the JSON parsing, and even suggested adding a team_size_recommended field that I had not thought of. That one suggestion made the feature significantly more useful.

Technical Architecture 

User Input (GitHub URL)
        ↓
Cloudflare Worker
        ↓
GitHub REST API → Fetch open issues (authenticated)
        ↓
Groq API (Llama 3.1 8b instant) → Analyze each issue
        ↓
Returns: root_cause, suggested_fix, complexity, priority
        ↓
React Frontend → Kanban Board
        ↓
Optional: Sprint Planner (second Groq call)
Optional: Export Markdown report
Optional: Post to GitHub as comment
Enter fullscreen mode Exit fullscreen mode

Tech Stack

Layer Technology
Frontend React + TanStack + Tailwind CSS
Backend Cloudflare Workers (serverless)
AI Groq API — llama-3.1-8b-instant
GitHub GitHub REST API v3
Hosting Cloudflare Workers (free tier)

Why Groq and Not OpenAI?

Speed and cost. Groq's inference is genuinely fast — analyzing 10 issues takes about 8 seconds total. The free tier gives 14,400 requests per day which is more than enough. OpenAI costs money. Groq is free. For a developer tool that should be accessible to everyone, free wins.

Why Cloudflare Workers?

Lovable generates TanStack projects configured for Cloudflare Workers by default. The global edge deployment means the app loads fast anywhere in the world. And the free tier covers 100,000 requests per day which is more than enough.

The Before vs After Summary

September 2025 June 2026
Code 47 lines of broken Python Full React + Cloudflare app
UI Terminal only Beautiful dark web interface
AI pass — literally empty Groq Llama 3.1 analysis
GitHub Hardcoded facebook/react Any public repo URL
Analysis None Root cause, fix, complexity, priority
Planning None AI 2-week sprint planner
Export None One-click markdown report
Deployment Never ran successfully Live at workers.dev
Cost $0 (did nothing) $0 (all free APIs)

What I Learned

1. GitHub Copilot is best for bridging knowledge gaps

I did not know how to build a Kanban board. I did not know the best prompt pattern to force structured JSON from an LLM. I did not know how Cloudflare Workers reads environment variables differently from Node.js. Copilot filled every one of these gaps instantly — not by writing the whole app for me, but by answering the exact question I was stuck on.

2. Old ideas are often good ideas

My September 2025 script had the right idea. The problem was real. The solution direction was correct. It just needed time, better tools, and a reason to push through the hard parts. Do not delete your old projects — they often contain your best thinking from a time when you were closest to the problem.

3. Constraints force better design

Using only free APIs forced me to be efficient. Limiting to 300 tokens per analysis and using the fastest available model made the app feel instant. If I had unlimited budget I might have built something slower and more expensive.

4. The finish line matters more than the plan

BugWhisperer v2 looks nothing like what I imagined when I wrote that Python script in September 2025. It is a web app, not a CLI script. It uses Groq, not OpenAI. It runs on Cloudflare, not my laptop. Every single implementation detail changed. But the core idea — help developers understand their GitHub issues faster — stayed exactly the same. Ship the idea, not the plan.

Try It

👉 Live Demo: https://bugwhisperer.msusimran20.workers.dev

Test it with any of these repos:

  • https://github.com/fastapi/fastapi
  • https://github.com/requests/requests
  • https://github.com/psf/black
  • Or any public GitHub repo you are working on

GitHub Repo: https://github.com/SimranShaikh20/BugWhisperer

What Is Next

  • Private repo support (user provides their own token)
  • GitHub Actions integration — auto-analyze on new issue creation
  • Slack notifications for Critical priority issues
  • VS Code extension
  • Multi-repo comparison

If this project helped you think differently about your own abandoned side projects, drop a reaction — it genuinely helps this submission and motivates me to keep building.

And if you have an unfinished project sitting somewhere, this challenge is your sign to finally ship it. The idea you abandoned is probably better than you remember. 🚀

Built for the GitHub Finish-Up-A-Thon Challenge
Powered by Groq AI + GitHub Copilot + Cloudflare Workers

Top comments (0)