GitHub Repo: https://github.com/SimranShaikh20/BugWhisperer
Live Demo: https://bugwhisperer.msusimran20.workers.dev
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
GITHUB_TOKEN = "put_your_token_here"
def get_issues(repo):
url = f"https://api.github.com/repos/{repo}/issues"
r = requests.get(url)
print(r) # just printing for now
def analyze_issue(issue):
pass
def main():
repo = "facebook/react" # hardcoded lol
get_issues(repo)
print("done?")
main()
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.
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.
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:
Every open issue gets analyzed by Groq's Llama 3.1 AI and returns:
Instead of a boring list, issues are sorted into a 4-column visual board:
One click generates a complete 2-week sprint plan with time estimates, recommended team size, and a week-by-week breakdown.
Download the entire analysis as a .md
file — paste it into your GitHub Wiki, Notion, or Linear instantly.
Post the AI analysis directly as a formatted comment on any GitHub issue — no copy-pasting, no leaving the app.
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.
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:
print(r)
just prints the response object, not the dataanalyze_issue
was completely emptyIt 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.
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"
}
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.
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.
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.
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
| 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) |
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.
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.
| 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) |
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.
👉 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
GitHub Repo: https://github.com/SimranShaikh20/BugWhisperer
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