I Built an AI Tool That Triages GitHub Issues Like a Senior Maintainer — Here's How
A Pirates of the Coral-bean Hackathon story
There's a quiet crisis in open source.
Not a security vulnerability. Not a licensing dispute. Something more mundane — and somehow more exhausting. Every day, maintainers of popular projects open GitHub and find themselves staring at a wall of issues. Some are bugs. Some are feature requests. Some are the same question asked for the 40th time. A few are duplicates of each other. And buried somewhere in all that noise is a critical fix that needs attention right now.
Manual triage takes hours. Every week. For free.
I wanted to fix that. So I built OSS First Mate — an AI-powered assistant that does the triage, finds the duplicates, drafts the release notes, and shows you exactly what data it queried to do it. No black boxes.
The Idea
The hackathon challenge was simple: build something useful using Coral — an open-source tool that lets you query any API, database, or file as SQL. No ETL pipelines. No custom API wrappers. Just write a SQL query, and Coral handles auth, pagination, and rate limits underneath.
The moment I read that, one idea clicked immediately.
What if GitHub issues were just rows in a database table? What if you could write SELECT * FROM github.issues WHERE state = 'open' and get back a clean JSON result — and then feed that directly into an LLM for analysis?
That's OSS First Mate.
What It Does
The dashboard has five core features:
Issue Triage — Enter any public GitHub repo. Click one button. Coral runs a SQL query against GitHub, fetches the latest open issues, and sends them to Groq's LLM (llama-3.3-70b). Within seconds you get a table showing each issue classified as a bug, feature request, docs task, or question — with a priority level (high/medium/low) and a suggested label. What used to take 30 minutes of reading through issues now takes about 15 seconds.
Duplicate Detection — OSS First Mate fetches 20 recent open issues and asks the LLM to find pairs describing the same problem. It returns each pair with a confidence score (high/medium/low) and a reason explaining the similarity. Maintainers can close duplicates immediately instead of discovering them months later.
Release Notes Generator — Pulls merged pull requests and drafts a structured changelog with sections for New Features, Bug Fixes, and Other Changes. Ready to copy-paste into your GitHub release.
SQL Log — Every Coral query that ran is logged in a dedicated tab. Full transparency. You can see exactly what data was fetched, when, and why. No hidden API calls.
Run History — Every analysis run is stored in MongoDB Atlas. You can go back and compare how a repo's issue patterns changed over time.
The Secret Weapon: Coral
Here's what makes this different from just "call the GitHub API and feed it to GPT."
Every data fetch in OSS First Mate goes through Coral's SQL interface. No custom API wrappers. No ETL. Just SQL:
SELECT number, title, body, labels, created_at, state
FROM github.issues
WHERE owner = 'fastify' AND repo = 'fastify'
AND state = 'open'
ORDER BY created_at DESC
LIMIT 10;
Coral runs this locally on your machine. Your GitHub token never leaves your computer. The data resolves inside Coral before it ever touches the backend. Auth, pagination, rate limits — all handled below the surface.
This matters more than it sounds. The SQL log tab in OSS First Mate is a direct reflection of this — every query is auditable. You're not trusting a black box. You're reading SQL.
Technical Architecture
The stack is straightforward:
Frontend: React + Vite + Tailwind CSS. A 3D Spline scene on the landing page, then a clean dark dashboard with tab-based navigation.
Backend: Node.js + Express. Five route handlers, three service modules.
coralService.js — spawns the Coral binary as a child process, passes SQL queries in, parses JSON output.
groqService.js — sends the fetched data to Groq's API for LLM classification, duplicate detection, and release note generation.
Database: MongoDB Atlas for persisting run history across sessions.
One bug I caught and fixed before recording: the original coralService.js had a hardcoded Windows path (D:\\coral.exe). That would have broken for anyone else cloning the repo. Fixed it to read from process.env.CORAL_PATH with a sensible default — a small change that makes the project actually portable.
I Used My Own Tool to Find an Open Source Contribution
Here's where it gets meta.
After building OSS First Mate, I ran it on fastify/fastify to look for something I could actually contribute to. The triage ran in under 20 seconds and surfaced issue #3618 — a documentation task to categorize 700+ community plugins in the ECOSYSTEM.md file. Classified as docs, priority low, which is perfect for a first-time contributor.
That's the real value of this tool. Not just for maintainers managing their repos — but for contributors trying to find where to start.
I also ran it on the Coral repo itself — withcoral/coral. Every single open issue came back classified as feature, priority low, label community-source. All of them were contributors adding new data sources to Coral's ecosystem. No bugs, no fires, nothing broken. The repo is healthy. So I moved on to find my contribution elsewhere — which is exactly what a good triage tool should tell you.
What's Not Perfect Yet (Honest Section)
Release notes bypass Coral: After spending a significant amount of time trying to get Coral's SQL interface working for merged pull requests, I hit a wall with the query structure for closed PRs. For the hackathon deadline, release notes fetch from the GitHub REST API directly. The feature works well — but it doesn't use Coral, which breaks the "everything via SQL" story for that one tab. This is the first thing I'll fix after the hackathon.
SQL injection: The owner and repo inputs are interpolated directly into SQL strings. For a personal dashboard with trusted input, this is fine. For a production tool, inputs need sanitization. Noted as a known limitation.
Future Vision — A Philosophical Shift
Here's the bigger idea.
Right now, most AI developer tools are wrappers. They call an API, stuff the response into a prompt, and return generated text. The data flow is opaque. You don't really know what was fetched, how it was filtered, or why the LLM responded the way it did.
OSS First Mate is built on a different premise: the query is the source of truth. By routing all data through Coral's SQL interface, every data access is explicit, readable, and auditable. The SQL log isn't a debug feature — it's a core part of the product.
This is the shift I think is coming for AI agents more broadly. Right now we're in the "it works" phase. The next phase is the "you can trust it" phase — and that requires transparency about what data the agent accessed, not just what output it produced.
Planned next steps:
Get release notes working through Coral SQL for merged PRs
Deploy on AWS EC2 (or any free tier alternative) inside Docker containers so anyone can run it without local setup
Add GitHub Actions integration — run triage automatically when new issues are opened and post a comment with the classification
Explore cross-source joins: Coral can JOIN GitHub issues with Slack messages in a single query, which would let maintainers see which issues are being discussed in their community in real time
The containerization and cloud hosting piece is the most immediately useful — right now the tool requires a local Coral binary and environment setup. Wrapping everything in Docker and hosting it makes it a real product anyone can use.
Conclusion
Building OSS First Mate taught me two things.
First, that Coral's SQL-over-API approach is genuinely different. The moment you can write a JOIN across GitHub and Slack in one query, a whole category of developer tooling becomes possible that wasn't before.
Second, that the right AI tool isn't one that does everything for you. It's one that shows you exactly what it's doing, so you can trust it with the things that matter.
OSS First Mate is open source. Go triage something.
GitHub: github.com/Atharva-026/oss-first-mate-coral
Hackathon: Pirates of the Coral-bean
Built for the Pirates of the Coral-bean Hackathon · May 2026