I lost 3 hackathons in a row. So I built a vampire judge to tell me why.

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

Three weeks. Three projects. Three evenings refreshing the winners page.

Week 1: nothing. Week 2: nothing. Week 3, I built a couch potato that told my mom to make me skip a date, filmed her agreeing with it, made three videos and rewrote the post four times. Nothing.

Every time, I did the same thing afterwards: scrolled the winners list and wondered, what did they have that I didn't? Nobody tells you. You just lose quietly.

So for the final week, I summoned someone who would tell me. Someone strict. Someone who has sat on every jury since the fall of Rome. Someone with fangs.

What I Built

Judge Fangs is a 3,000-year-old vampire judge who reviews your hackathon submissions, emails and ideas, and tells you, bluntly and with evidence, exactly why they won't win.

You give him two things:

1. The hackathon: a link to the challenge.
2. Your work: a DEV post, a GitHub repo, an email, or just an idea.

Then he does what I never had time to do. He digs up the background: the judging criteria, the prize categories, and the posts that actually won. He works out what those winners had in common. Then he checks your code to see whether you really used what you claim. Finally he judges you against each criterion, quoting your own words back at you as evidence.

You get a score, the 3 biggest reasons you'd lose, 3 fixes, and a better title and opening. Then he reads his sentence aloud in a cold, ancient voice.

He's pixel art, drawn entirely in code, and he roams. On the website he wanders along the bottom of the page, taps his foot while he digs, and pulls out a gavel when the verdict lands. On my laptop, I press Ctrl+Shift+J and he drops onto my actual screen, looks at whatever I'm working on, and judges that.

His catchphrase, for anything under 50: "Objection. To all of it."

Demo

Try it (no install, no sign-up):

fangs-web.onrender.com

Paste any DEV post and challenge link and test out Judge Fangs.

I fed him my own losing entries

This was the moment of truth. I gave Judge Fangs my Week 3 post, the one I was proudest of.

I won't lie, this one stung a little.

I put a lot of effort into Couch Potato, and seeing what separated it from the winning projects was humbling.

But I'd rather have an AI point out my blind spots than keep making the same mistakes in every hackathon. Time to take notes, not just the L.

My project had personality, but Judge Fangs wanted stronger technical proof, measurable impact, and a reason to beat the competition.

Brutal? Yes.

Useful? Unfortunately, also yes.

The real test: can he judge like the real judges?

A judge who just insults everyone is easy to build. I wanted to know whether his taste matches the real jury's. So I ran a blind backtest:

• I picked 45 real Week 3 entries: 10 that won a prize and 35 that didn't (mine included).
• Judge Fangs scored all 45 without being told which ones won. The "what winners have in common" step was built from other winning posts, so he couldn't peek at the answers.
• Then I revealed the real results.

Results:

• 9 of the 10 real winners landed in his top 10.
• Average score of winners: 96. Non-winners: 64.

Code

Raga-V / judge-fangs

Judge Fangs

Your hackathon companion, from idea to verdict. A strict, funny, 3,000-year-old vampire judge who has sat on every hackathon jury since the fall of Rome, and who now sits beside you through the whole hackathon.

"I have watched empires fall with more structure than your README. Three fixes. Then we shall speak again."

Open a case file for each hackathon you enter: paste its URL or just type its name. The Count digs up the theme, the judging criteria in order of weight, the prize categories, the deadline and what past winners had in common. Then each case follows the hackathon timeline:

Tab	When	What Fangs does
Brief	before	The case file: the theme in one line, weighted criteria, prize categories, a deadline countdown, "what winners usually have", and the sources he read
Ideate	before	Judges up to 5 ideas on originality, theme fit, buildability before the deadline

…

View on GitHub

How I Built It

Three steps: dig, check, judge

1. Dig. The server fetches the challenge page and the winners announcement through the public DEV API, and your repo through the GitHub API. If you don't have the winners post, SerpApi (a search API) finds it. Gemma then extracts the judging criteria in order of weight, plus the patterns the winners shared. For Week 3, those included things like a number in the title and one measured test.

2. Check. This step is plain Python, with no AI. It collects hard facts the model can't argue with:

• Did the post claim "Best Use of Sentry"? Then is there a Sentry package in the repo's dependencies, or a Sentry import in the code? Each claim is marked backed by code, mentioned only or not found.
• Is there a number in the title? A demo link? A video? How long is it?

3. Judge. One call to Gemma, with the criteria, the winners' patterns, the evidence and your submission. It must answer in a strict JSON format (fixed fields that code can read): a score from 0 to 10 per criterion, a one-line verdict, and an exact quote from your post as evidence. Then come the reasons you'd lose, 3 fixes, a better title and a better opening.

Guard rails: the judge is not allowed to lie

AI models make things up. So, like a real court, Judge Fangs needs evidence:

• Every quote is checked. If the "evidence" isn't actually in your post, that score is marked unsupported.
• Code overrules the model. If Gemma says you used a partner technology but the repo check found nothing, the verdict says so: "The code check overruled the model."
• Scores are capped and validated before they reach the screen. Broken JSON gets one retry with the error explained.

The ghost in your machine: the desktop companion

The desktop app is a small Electron app (Electron lets you build desktop apps with web code). Here's what happens:

1. Press Ctrl+Shift+J and a transparent window appears over everything, with the pixel vampire walking along the bottom of your screen.
2. He takes a screenshot, and shows it to you first. Nothing is sent until you press "Judge this".
3. The screenshot goes to the same server. Gemma (which can read images) works out what you're looking at, whether it's a post, an email, an idea or code, and runs the same dig, check and judge steps.

It's never continuous, never saved, and the image is deleted right after judging.

Architecture: nothing runs on your laptop

Last week, judges had to install Ollama to try my app. That was a mistake, so this time:

• The brain is a large Gemma model, gemma-4-31b-it, hosted on a separate server. I call it through a standard, OpenAI-compatible API, so switching to another host, or to my own server, is one setting.
• The courthouse is a FastAPI service on Render that holds every key.
• The face is a React app on a Render static site.

Your browser never sees a key. If the keys or the daily quota run out, he switches to demo mode: "The tribunal is adjourned until moonrise."

How each partner technology is used

In plain words: Gemma is the judge's mind. It reads posts, repos and screenshots, extracts the rules of each hackathon, and writes every verdict.

• Three jobs, one model: reading the challenge (extracting the criteria), reading your screen (vision), and judging (strict JSON with evidence quotes).
• A large open-weight model on a separate server, because judging long posts needs a big model. But it's still open, so anyone can host the same weights themselves.
• It never has the final word. Code checks every quote and every partner claim.

In plain words: Render is where Judge Fangs lives, so nobody has to install anything.

• Two services, one Blueprint (render.yaml): a FastAPI web service holding the keys, and a static site for the React app. One click deploys both.
• Built for strangers on the internet:
  • per-visitor rate limits and a daily cap, so nobody drains my API credits
  • request size caps
  • an allowlist, so the server only ever fetches from DEV, GitHub and SerpApi, never private addresses
  • a health check
• Demo mode if a key is missing or the quota runs out, so judges always see something work.
• The digging log ("Reading 3 winning entries…") streams live from Render to your screen.

In plain words: Judge Fangs speaks. You haven't really been judged until a vampire says "forty-one out of a hundred" to your face.

• eleven_v3 with audio tags (stage directions in square brackets) such as [clears throat] and [coldly].
• Cached by text, so the same sentence is never paid for twice. Only lines the server itself wrote can be voiced.

In plain words: Sentry keeps the court record. For every judgement, I can see each step he took, how long it took and how hard the model worked, without Sentry ever seeing your text.

• One trace per judgement, using Sentry's AI agent span types:
  • gen_ai.invoke_agent for the whole judgement
  • a child span for each fetch (DEV, GitHub, winners, search)
  • a span for the code checks
  • gen_ai.chat for each Gemma call, with tokens, timing and retries
• Lengths, labels and timings only, never your words or screenshots.

In plain words: you don't need to know where the winners post is. Name the hackathon, and SerpApi finds it, so Judge Fangs can study what won.

Why Does Open Innovation Matter?

Hackathon judging is a black box. You submit, you wait, you lose, and you never find out why.

Judge Fangs is the opposite of a black box:

• The rules he judges by are in the open: the scoring is in the code, and the evidence is on the screen.
• The model is open-weight. Anyone can run the same judge on their own server, change his rubric, or make him kinder.
• The code is open. If you think he's wrong, you can see exactly why he decided what he did, and fix him.

A closed AI that grades you with no reasons would just be another black box. An open one can show its working, and that's the whole point of a judge.

Honest Limits

• He's a model, not the real jury. The backtest shows how often his taste matches theirs (9 of 10), not that he can predict prizes.
• He's harsh by design. Under the theatre, the fixes are meant to be kind and specific.
• The desktop companion is Windows-first and needs installing. The web app is the one anyone can try.
• Your submission text goes to the hosted model provider in order to be judged. Nothing is stored.

Prize Categories

• Best Use of Gemma: a large hosted Gemma model reads challenge pages, posts and screenshots, extracts each hackathon's rules, and judges with evidence quotes that code verifies.
• Best Use of Render: a FastAPI web service plus a React static site in one Blueprint, with keys kept server-side, rate limits, an SSRF-safe allowlist (the server can't be tricked into fetching private addresses), streaming and a demo-mode fallback.
• Best Use of ElevenLabs: Judge Fangs reads his sentence aloud with eleven_v3 audio tags.
• Best Use of Sentry Agent Tracing: one AI agent trace per judgement, with spans for digging, code checks and each Gemma call, and no private text sent.
• Best Use of SerpApi: finds the winners announcement for any hackathon you name.

---

Raga Vinjanampati: three weeks, three projects, zero wins, and one vampire who finally told me why. Objection noted.

Comments

[arcwrightai]

Solid take. The hard part is always the last 10% nobody talks about.

[Raga Vinjanampati]

Exactly! Getting something to work is one thing and polishing it until it's actually reliable and ready for real users is a whole different battle. That last 10% somehow takes 50% of the effort. 😭