DEV Community: Raga Vinjanampati

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

Raga Vinjanampati — Sun, 01 Nov 2026 06:07:35 +0000

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:

The hackathon: a link to the challenge.
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:

Press Ctrl+Shift+J and a transparent window appears over everything, with the pixel vampire walking along the bottom of your screen.
He takes a screenshot, and shows it to you first. Nothing is sent until you press "Judge this".
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.

I built an AI couch potato that tells me which chores to skip. My mom agrees with it.

Raga Vinjanampati — Mon, 26 Oct 2026 02:26:57 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

Every day I have the same argument with myself.

Me: Do I really need to go to the 8 AM lecture?
Also me: You're going to regret this.
Me: I'll regret it later. Later is a problem for future me.

So I hired a professional. He's a potato. He lives on a couch. He wears sunglasses indoors. His name is Lazy.

To test him, I asked Lazy and my mom the same questions about my own chores. Lazy told me to skip a date and clean the fridge. My mom said exactly the same thing. I have never felt so outnumbered.

In 30 seconds:

What it is: tell Lazy what you're avoiding, answer up to 3 taps, and get one verdict: skip it, do the lazy minimum, do it later, or yes, do it.
The trick: an open AI model (Gemma 3) runs on your laptop and only collects the facts. About 200 lines of plain JavaScript make the actual decision, so the AI can't talk you out of paying a bill.
The proof: my mom and Lazy answered the same questions. I agreed with Lazy 7 times out of 10.
The stack: Gemma 3 + Ollama, Render, ElevenLabs, Sentry, TabPFN, GitHub Actions + Copilot. Each one has exactly one job.

What I Built

Do I Need to Do This? is a web app for people who are tired of deciding. You type the task you're avoiding. Lazy asks you up to three quick questions, and you answer with a tap. Then he gives you one honest verdict:

The twist: Lazy is not allowed to let you off the hook for the important stuff. Health, money, official paperwork and anything graded can never get "Skip it". Lazy is lazy, not irresponsible.

And the part I'm proudest of: the AI doesn't pick the verdict. Gemma, an open model running on your own laptop, reads, asks and takes notes. A small file of plain JavaScript rules makes the final call. More on why below.

Meet Lazy (a short, cute video)

Demo

Try it: raga-v.github.io/do-i-need-to-do-this

The AI runs on your laptop, so you'll need Ollama, a free app for running AI models locally, with the gemma3:4b model downloaded. The app's AI setup screen gives you the exact one-line command to copy.

What you can do:

Ask about one task. "Go to the 8 AM lecture tomorrow", "Pay the electricity bill", "Reply to the group chat", "Iron my shirt".
Add a photo. A timetable, a notice, a screenshot. Lazy reads it before he asks anything.
Plan my lazy day. Save your timetable once, and Lazy sorts your whole day into Must do · Lazy minimum · Skip · Later.
Hear the verdict. Lazy delivers it like a tired judge: "[sighs] Skip it. … Court is adjourned."

The Lazy Payoff: Mom vs. Lazy

Anyone can say their app works. So I sat my mom on our (non-purple) sofa, asked her the questions I'd normally overthink, filmed her answers, and then asked Lazy the same questions on my laptop. Two judges, my chores.

Straight from the app's History screen:

13 tasks judged.
I agreed with Lazy 7 out of 10 times (I answered "Would you have decided the same?" on 10 of them).
5.1 hours back this week. That's the sum of Gemma's own effort estimates for everything Lazy said to skip or shrink, not a stopwatch.

Highlights from the tape:

"Do you think I should reply in the family group chat?" Mom: "Why didn't you reply yet?" Lazy, slightly more relaxed: Do the lazy minimum. Just send a quick "okay" message. About 2 minutes.
"Do you think I should go on a date with a guy I never met before?" Mom: "No. Never. And ever." Lazy asked one question, "Would letting him down be bad?", and then: Skip it. "Since you've never met him, a simple decline won't cause any issues." Mom and the potato, united.
"Do you think I should clean the fridge before Diwali?" Mom: "Do you think the sky is blue? Obviously you have to." Lazy jumped off the couch: Yes, do it. "Your mum will probably get annoyed if you don't clean the fridge." He knows her. Judged by Gemma in 83.7 seconds, on my laptop.
Where I disagreed: "Do you think I should do my little sister's assignment?" I would have skipped it. Lazy said Do the lazy minimum. That's not Gemma being wrong. It's my own safety rule: "assignment" is on the graded-work list, and graded work can never be skipped. Lazy refused to help me be a bad sibling. Fair.

Code

Raga-V / do-i-need-to-do-this

Do I Need to Do This?

Tell it what you're avoiding. Gemma 3 asks a few questions on your laptop. Plain rules give an honest verdict.
Try it live · Run it · How it decides · Privacy · Partners

Type the task you're avoiding: "Go to the 8 AM lecture tomorrow", "Pay the electricity bill". Optionally add a line of context or a photo of a timetable, notice or screenshot. Gemma 3 runs on your own laptop, asks up to three tap-to-answer questions, and then the app hands down one of five verdicts.

Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 3: Slow and Steady (build something with open-source AI that rewards laziness).

Meet Lazy

Home
chilling

Thinking
while Gemma works

Skip it
asleep

Lazy minimum
coffee

Later
calendar

Yes, do it
jumping

Not sure
puzzled

Lazy is a couch potato in sunglasses, drawn entirely…

View on GitHub

How I Built It

A 20-second jargon decoder

You don't need to be an engineer to follow the rest of this post. These are the only terms that matter:

Term	What it means here
Gemma 3 4B	An open AI model from Google. "4B" means 4 billion parameters: small enough to run on a normal laptop.
Ollama	A free app that runs AI models on your own computer, like a media player for models.
JSON	A simple, strict text format for data, made of `"name": value` pairs that code can read reliably.
Schema	The fixed list of fields the JSON must have. Anything else gets rejected.
`decide()`	The JavaScript function, in the file `public/decide.js`, that picks every verdict. No AI inside.
Token	A chunk of text, roughly ¾ of a word. Models read and write in tokens, so token counts measure how much work the AI did.
API key	A password that lets an app use a paid online service (like ElevenLabs' voices).

The one rule: the AI asks, the code decides

My first instinct was to ask Gemma "should I skip this?" and show whatever it said. That's a bad idea. A small model is great at reading and asking, and terrible at being consistent. Ask it the same thing twice and you get two different moods. You don't want a moody judge deciding whether you pay your electricity bill.

So I split the job in two. Here's where everything runs:

How to read this diagram: everything in the purple box happens on your laptop, and that includes the AI. The white box is a small server on Render whose only job is holding the API keys. The orange box is the online services. The arrows show the only things that ever reach them: one line of text to speak, and a few labels.

And here's one run, from your question to Lazy's gavel:

Read it top to bottom. Each numbered arrow is one message passing between you, Gemma, the rules and the online services. In words:

Gemma reads. If you add a photo (say, your timetable), Gemma copies down only what it can actually see. Anything unreadable is marked [?] instead of guessed, and you can correct what it read.
Gemma asks. Up to 3 questions, each with 2–4 answers you tap, and only about what it doesn't already know.
Gemma writes down facts, not opinions. Instead of chatting, it has to fill in a form, as JSON. Ollama's format option forces the answer to match the schema, so Gemma can't add or skip fields. For "clean the fridge", the form looks something like this:

{
  "category": "chores",          // what kind of task (chores, money, health, exam...)
  "consequence": "annoying",     // what happens if you skip it: nothing, minor, annoying, serious or severe
  "affects_others": true,        // does skipping it let someone else down?
  "can_be_undone_later": false,  // can you fix it later if you skip it now?
  "effort_minutes": 60,          // how long the whole task takes
  "lazy_minimum": "Throw out anything expired",  // the smallest version that keeps you out of trouble
  "lazy_minimum_minutes": 10,    // how long that smallest version takes
  "confidence": 0.8              // how sure Gemma is about all of the above (0 to 1)
}

(An example of the shape, not a real log. The comments are mine, for this post.)

4. Plain JavaScript decides. The decide() function reads those fields and picks the verdict. It's about 200 lines with no AI in it, and the same file runs in the app and in the automated tests. That means every rule is checked before any code goes live.

The rulebook in three steps: (1) if Gemma is less than 50% sure, Lazy says "Not sure yet". (2) Otherwise, how bad skipping would be picks the verdict. For example, "minor" and only affects you gives Skip it. (3) Finally, a safety check: if the result is Skip it but the task involves health, money, legal paperwork or graded work, the verdict is upgraded.

Gemma tried to cheat. The code caught it.

A small model running on a laptop makes mistakes. Instead of hoping a better prompt would fix them, I added guard rails in code: small checks that run on Gemma's answer before the rules ever see it. Every rail exists because of a real mistake I saw in testing:

It filed "Pay the electricity bill" under "other". Now, if the task's own words mention a bill, payment, doctor, exam or passport, it's treated as protected, whatever category Gemma picked.
It "quoted" things I never said. Gemma is allowed to skip a question if I've already answered it, but it has to quote my exact words as proof, and the code checks the quote really is in what I typed. It once invented "They'll cut off the power." Nobody said that.
It told someone to skip the laundry because their attendance was high. Lazy now only shows Gemma the "About me" notes on the same topic as the task. Your attendance has nothing to do with your socks.
Its maths was creative. In one test it reasoned that 88% attendance minus one class is below 75%. The rules only read the form fields, not Gemma's reasoning, and the verdict card shows Gemma's working so you can catch moments like this.
If Gemma is less than 50% sure, Lazy says "Not sure yet". He'd rather ask than guess.

Every time the code overrules Gemma, the verdict card says so: "The app overruled Gemma." No secret edits.

Lazy remembers you (without spying on you)

Memory. After each verdict, Gemma suggests up to 3 lasting facts about you ("College requires 75% attendance"). The code throws away anything you didn't actually say, one-off details and duplicates. You can edit or delete any of them in Settings.
Timetable. Upload a photo once. If it's a clean grid, plain code turns it into a timetable instantly. Messier photos go to Gemma, and any row it wasn't sure about gets a "check this" badge instead of a guess.
Plan my lazy day. Gemma fills in one form for every class or task on today's timetable, in a single request, and then the same decide() rules judge each one.

All of this is saved in your own browser's storage (localStorage) and only ever sent to Gemma, on your own laptop.

Small things that make it feel alive

Lazy is drawn entirely in code. He's an SVG, a drawing written as code, so there are no image files. He breathes, his Zzz float up, and he bounces when he panics. The animations switch off if you've asked your device to reduce motion.
Funny sounds, generated live in the browser with the Web Audio API (the browser's built-in synthesizer), so there are no audio files either: a snore for skip, a coffee slurp for the lazy minimum, a tick-tock for later, a panicked boing for "do it", and a flump as Lazy lands on the couch.
What I didn't ship: a microphone. I wanted local speech-to-text with Whisper, an open speech-recognition model, but couldn't build and test it in time. The browser's built-in speech recognition sends your audio to Google, so I left it out rather than break the privacy promise.

How each partner technology is used

Every partner has exactly one job in Lazy's household. Each section starts with the plain-English version, then the details for the curious.

In plain words: Gemma is the part that reads and listens. It runs on your own laptop through Ollama, so it costs nothing per question and your tasks never leave home.

Vision: reads timetable photos, notices and screenshots, copying down only what's visible.
Conversation: decides which follow-up questions to ask, and writes the tap-to-answer options.
Filling in the form: returns the JSON facts shown above. If the JSON comes back broken, the app retries once and tells Gemma exactly what was wrong.
Memory, timetables and planning: each is its own small, separate request with its own form, and a cap on how much Gemma may write.

Gemma never picks the verdict, and that's what makes it safe to give a small model this job. Each verdict card is open about the work: how long Gemma took on your laptop, how many tokens it read and wrote, its speed, and the full table of facts it filled in.

In plain words: Lazy's brain lives on your laptop, but his voice and his gut feeling need secret API keys. Secrets can't live in a web page, where anyone could read them. So they live on a small server at Render, which uses them on Lazy's behalf.

That server is one file, server.js, with zero extra code libraries. Render runs it as a web service: a program that's always on and answers requests. Render calls a config file that sets everything up a Blueprint, and mine is render.yaml:

services:
  - type: web
    name: do-i-need-to-do-this
    runtime: node
    region: singapore          # the closest Render region to users in India
    buildCommand: npm ci       # install, exactly as locked in package-lock.json
    startCommand: node server.js
    healthCheckPath: /healthz  # Render pings this page to check the server is alive
    autoDeploy: true           # every push to GitHub redeploys automatically
    buildFilter:               # ...unless only the README or tests changed
      paths: [public/**, server.js, tabpfn.js, package.json, package-lock.json]
    envVars:                   # the secret keys
      - key: ELEVENLABS_API_KEY
        sync: false            # typed into Render's dashboard, never written in the code
      - key: SENTRY_DSN
        sync: false
      - key: TABPFN_TOKEN
        sync: false

(Trimmed for the post. The full file is in the repo.)

One-click deploy: anyone can copy the repo and get the same server with one click.
Secrets stay out of the code: every key lives only in Render's dashboard.
Safe on the open internet:
- Files are compressed before they're sent (gzip), so the app loads faster.
- Each visitor gets a limited number of requests (rate limiting), so nobody can drain my API credits.
- Anything sent to the server is capped at 16 KB, so a photo physically can't be uploaded. That's a privacy promise you can check in the code.
You always know what's live: the app's footer shows exactly which version is running. It reads Render's RENDER_GIT_COMMIT setting, the ID of the code commit. Render also checks /healthz before it switches visitors to a new version.

In plain words: Lazy talks. He reads you his questions, bangs a gavel, and announces the verdict like a very tired judge.

A voice with a personality. When you tap "Hear the verdict", the app asks the server (at /api/speak) to voice one line. It uses ElevenLabs' newest model, eleven_v3, which understands audio tags: stage directions in square brackets that change how the line is performed. The server adds them per verdict: [sighs] Skip it. … [laughs] Court is adjourned. or [clears throat] Yes, do it. If v3 is unavailable, it falls back to the older eleven_multilingual_v2 voice.
Sound effects, generated by ElevenLabs: a gavel bang before every verdict, and a snore when you poke Lazy. ElevenLabs creates them from a text description. Each is made once when the server starts and then reused, instead of being paid for on every verdict.
Lazy reads each question aloud, so it feels like a conversation, not a form.
It can't be abused as a free voice service. The server only voices verdict lines and short questions: one sentence, at most 140 characters, ending in "?", no links. It also gets a stricter request limit.

In plain words: Sentry is a security camera on Gemma's thinking. For every run, I can see which steps Gemma took, how long each one took and how hard it had to work, without Sentry ever seeing what you typed.

Two Sentry words first. A trace is the full recording of one run. A span is one step inside it, drawn as a bar on a timeline. Each run is one trace that reads like a story: agent, then Gemma, then Gemma again, then the rules.

I use Sentry's AI agent span types, so Sentry knows what each step is:
- gen_ai.invoke_agent is the whole run.
- gen_ai.chat is one call to Gemma. There's one per step: reading the photo, asking questions, filling in the facts.
- gen_ai.execute_tool is the rules deciding. I named it decide_verdict.
Each Gemma step records which model ran, which step it was, whether it was a retry, how many tokens went in and came out (taken straight from Ollama's own counters), and how long it took.
The rules step records the facts that went in and the verdict and rule that came out. A surprising verdict can be traced to the exact rule.
Broken JSON from Gemma is logged as an error, labelled with the step and attempt.
When you disagree with the court, Sentry records both verdicts and the rule that fired. That's the best signal for tuning the rules.
Privacy: no prompts, replies, photos or task text are ever sent to Sentry. Only lengths and labels.

In plain words: the rules give the official verdict. TabPFN guesses what you would actually pick, based on your past answers. I disagreed with Lazy 3 times out of 10, and TabPFN is how Lazy learns that about me.

TabPFN is an AI model built for small tables of data. Most machine learning needs thousands of examples, but TabPFN can learn from a few dozen. One person's verdict history is a few dozen rows at most, so it's the right tool.

What it learns from: each time you answer "Would you have decided the same?", that verdict becomes one row. Once you have at least 10 rows (with at least two different answers), the app sends TabPFN six labels per row, plus what you actually chose:
1. category
2. consequence
3. days until the deadline
4. whether it affects others
5. whether it can be fixed later
6. effort in minutes

No words, ever.

The server checks every value against fixed lists and number ranges, and rejects anything else (including free text) before it reaches TabPFN.
The full TabPFN flow: upload your history, train on it, then ask for the odds of each verdict. The card shows "Based on your past choices, you'd probably pick: X (NN%)", with a bar for each verdict.
A "Teach Lazy" progress bar in History shows how close you are to 10.
Honest limit: with this little data, it's a hint about your habits, not a crystal ball. The rules' verdict always wins.

In plain words: every time I push code, a robot clerk re-checks that the court still rules the way it should.

GitHub Actions runs these checks automatically on GitHub's computers, on every push. That's called CI, short for continuous integration.

Every push runs:
- a syntax check of every file (node --check)
- the full test suite on two versions of Node.js (20 and 22), covering the decide() rules, the Gemma code (tested against a fake Ollama, so no real AI is needed), memory, timetables, TabPFN and the server
- a smoke test of the real server: is it up, does it serve the app, does it fail politely when a key is missing, and does it block attempts to read files it shouldn't
The run's summary page prints the whole rulebook as a table: what decide() rules for every combination of consequence and situation. You can read the court's logic on every single commit.
The main branch (the live version of the code) is also published to GitHub Pages, GitHub's free website hosting.
For Copilot, the file .github/copilot-instructions.md tells GitHub's AI coding assistant the project's hard rules: rules pick verdicts, protect privacy and safety, never invent numbers. Anyone using Copilot on this repo gets those rules automatically. Dependabot is a GitHub bot that keeps the tools these checks use up to date.

Why Does Open Innovation Matter?

Because the things you're avoiding are personal. "Skip my doctor's appointment?" "Pay rent late?" "Go on a date with a stranger?" (Mom already said no.) That's not something I want sitting on someone else's server.

	Lazy (Gemma, on your laptop)	A cloud chatbot
Your tasks, photos, timetable	Never leave your laptop	Sent to a company's server
What it remembers about you	In your browser, editable, deletable	Their memory, their rules
Cost per question	₹0	Pay per use
Can I make the rules stricter?	Yes, it's one JS file	No

An open model is what makes the "lazy" part possible. You can ask Lazy about every tiny thing, all day, for free, and nobody collects a diary of everything you're avoiding.

Honest Limits (Lazy would want me to be upfront)

Gemma 3 4B is small. It can misread messy photos and mix up timetable rows. That's why you can see and edit what it read.
It's slow on modest laptops. On mine, a full run takes about 1–2 minutes (the fridge verdict took 83.7 seconds), and the first model load takes about 40 seconds. Reading a full week's timetable photo took about 2 minutes. The card always shows the real time. This is Slow and Steady, after all.
The "hours saved" are Gemma's estimates, not measurements.
The safety keywords are English-only and simple.
No microphone yet (see above).

Prize Categories

Best Use of Gemma. Gemma 3 4B runs on your laptop through Ollama. It reads photos, asks the questions and fills in a strict JSON form, with code checks on every answer. It never picks the verdict.
Best Use of Render. The app's server is deployed on Render as a Blueprint-defined web service (render.yaml): Singapore region, health checks, smart redeploys, secret keys kept in the dashboard, per-visitor rate limits, a 16 KB upload cap, and a footer showing the live version. Render is the only place the API keys live.
Best Use of ElevenLabs. Judge Lazy's voice uses eleven_v3 audio tags chosen per verdict, generated gavel and snore sound effects, and spoken questions.
Best Use of Sentry Agent Tracing. One AI agent trace per run (gen_ai.invoke_agent → gen_ai.chat → gen_ai.execute_tool) with token counts and timings, broken-JSON errors and disagreement feedback, and no private text sent.
Best Use of TabPFN. Predicts which verdict you'd pick from six checked labels per past verdict, through the full upload, train and predict flow.
Best Use of GitHub Copilot. GitHub Actions tests every push on Node 20 and 22, smoke-tests the server, prints the rulebook in the run summary and deploys to Pages. Copilot instructions and Dependabot keep contributors and tools in line.

Raga Vinjanampati: a broke student who now asks a potato for permission before doing anything. My mom thinks the potato is very sensible.

My dad's scooter naps 9 hours a day. So I built a side hustle app to rent it out, and a local AI that settles "that scratch was already there."

Raga Vinjanampati — Mon, 19 Oct 2026 06:01:47 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

TL;DR: Your scooter sits idle 9 hours a day. IdleWheels lets a neighbour rent those hours, and an open-source AI running on your own laptop settles the one argument that kills every rental: "that scratch was already there." Try it live · Watch the 60-second demo

My dad looked at the parking lot outside his office and said something that wouldn't leave my head:

"Every one of these vehicles is just sitting here until 6 PM. Somebody should be making money off that."

He's right. Every morning, millions of students and office workers in India park a scooter, bike or car at 9 and don't touch it until evening.

That's 9 hours a day of a vehicle doing absolutely nothing. Meanwhile, someone three streets away needs wheels for exactly those hours: to get to college, to a job interview, to the hospital.

So I tried to build the obvious side hustle: rent out the hours your vehicle is asleep.

And within five minutes I hit the real problem. It isn't booking. It's this:

Owner: "There's a new scratch on the side."

Renter: "That was already there."

Every rental ends with that argument. Nobody can prove anything, so nobody trusts anybody, so nobody rents.

So I did what any reasonable engineering student would do. I handed the argument to an AI.

What I Built

IdleWheels lets neighbours rent each other's idle scooters, bikes and cars, by the hour.

👉 Try it live: idlewheels.onrender.com

It works in three steps:

1. List your idle hours. Add your vehicle, your area and the hours it's free (say 9:30 to 5:30). Not sure what to charge? Tap ✨ Ask Gemma and it suggests a fair hourly price.

2. Book and chat. A renter picks a day and a time window and sends a request. The app shows the cost upfront (7 hours × ₹35 = ₹245). Phone numbers stay hidden until the owner accepts. Then a chat opens inside the booking to sort out pickup.

3. The handover check (the part I'm proudest of).

At pickup, 4 photos: front, left, right, rear.
At return, the same 4 again.
Gemma 3, an open-weight AI model running on the owner's own laptop, compares each pair and lists only the damage that's new, with how serious it is and how confident it is.
The verdict drops into the booking chat, and both people can save the full report as a PDF.

That's the whole dispute process. No arguing. Just two photos and a second pair of eyes that doesn't take sides.

Who would pay for this? Any owner who wants their idle vehicle to earn. And honestly, every small two-wheeler rental shop in India, which has the "that scratch was already there" argument every single day.

The Part Where the AI Embarrassed Me

My first version of the pricing feature was simple: show Gemma the vehicle, ask for a price per hour.

For three similar scooters, it said:

₹95. ₹180. ₹600.

Six hundred rupees an hour. For a scooter. At that price it should come with a driver and a cup of chai.

Small AI models are bad at maths and even worse at being consistent. So I split the job in two:

Gemma does what it's good at: looking at the vehicle and sorting it into budget, standard or premium.
A rate table does the maths. I checked real Hyderabad self-drive rental rates this month (Royal Brothers, Zoomcar, Revv and others) and set IdleWheels a little below them. A neighbour's scooter doesn't come with a company, an insurance package or roadside help, so it shouldn't cost the same.

That was the best lesson of the week:

Let the AI judge. Don't let it do arithmetic.

Demo

Here's what you can try in two minutes on the live app:

Browse idle vehicles on the home page, pick a day and time, and send a request.
List your own vehicle and tap ✨ Ask Gemma for a price.
Open a booking to see the chat. Phone numbers only appear once the owner accepts.
Run a handover check: 4 pickup photos, 4 return photos, and the verdict lands in the chat.

Listings, bookings and chat work for anyone, straight away. The two AI features run on your machine, so they need Ollama with gemma3:4b (the AI setup tab walks you through it).

There's also a static copy on GitHub Pages: raga-v.github.io/idlewheels

Code

Raga-V / idlewheels

Rent out your idle bike or car. A local Gemma checks every handover for new damage.

IdleWheels

Your scooter naps 9 hours a day. Let it earn.

College students and office-goers in India park their scooters, bikes and cars at 9 and don't touch them until 6. IdleWheels lets neighbours rent each other's vehicles for exactly those idle hours. Booking is the easy part. The hard part of peer-to-peer rental is trust, so the core of IdleWheels is an AI handover check that runs on an open model on the owner's own laptop.

Live: https://idlewheels.onrender.com (also https://raga-v.github.io/idlewheels/)

How it works

List the idle hours. The owner says when the vehicle is free. Gemma sorts the vehicle into a price class (a Splendor is budget, a Royal Enfield is premium) and the app suggests a fair hourly price from real Hyderabad rental rates.
Request and chat. A neighbour picks a day and hours and sees the total cost. The owner accepts or declines. Once accepted, both…

View on GitHub

How I Built It

Plain HTML, CSS and JavaScript, with no build step. A tiny Node.js server (one dependency: pg) stores listings, bookings and chat in Render Postgres. The AI never runs on the server.

📱 Browser ──4+4 photos──▶ 💻 Owner's laptop
                            (Ollama + Gemma 3 4B)
📱 Browser ◀──JSON verdict── 💻
📱 Browser ──text only────▶ ☁️ Render
                            (Node + Postgres:
                             listings, bookings, chat)

Getting a small model to compare two photos honestly was the real work:

Describe first, judge later. Each request sends the pickup and return photo together, with a JSON schema that makes Gemma describe photo 1, then photo 2, and only then list what changed. Ollama fills the fields in order, so the verdict rests on what the model just looked at, not a guess.
Tell it what to ignore. Two photos taken hours apart never match. The light changes, shadows move, reflections shift. The prompt tells Gemma to ignore all of that, plus dust.
Let it say "I don't know." Gemma can answer unsure, and it flags when the two photos don't show the same view. A dispute tool that invents damage is worse than no tool at all.

Deploying: Render runs the server and Postgres from a render.yaml blueprint. GitHub Actions checks the code, runs a server test, and publishes the static copy to GitHub Pages on every push.

Why Does Open Innovation Matter?

Because handover photos are private. They show a number plate, often the owner's home, sometimes a face.

In IdleWheels, those photos go from the browser to the owner's own laptop, and nowhere else. The server only ever sees the text verdict: "new scratch, left side panel, minor."

	IdleWheels (Gemma, local)	A paid cloud vision API
Where the photos go	The owner's own laptop	Someone else's server
Cost per handover check	₹0	Paid per image, 8 images every time
A rental shop doing 50 handovers a day	Still ₹0	The bill grows every day
Want sharper eyes?	Swap to `gemma3:12b`, or fine-tune on scratch photos	Wait for the vendor

A side hustle runs on thin margins. A rental that earns ₹245 can't pay for an API call on every handover. An open model running on a laptop the owner already has makes the trust layer free.

Honest Limits (because judges can smell hype)

A 4B model on a laptop can miss hairline scratches and get fooled by glare. It's a second pair of eyes, not a judge.
Identity is just a name, a phone number and a key saved in your browser. A real launch needs OTP verification.
The legal bit: in India, renting out a privately registered (white-plate) vehicle for money needs commercial registration and insurance. IdleWheels is a demo of the trust layer. The fastest real-world path is licensed rental shops, who have the exact same scratch argument every day.

Prize Categories

Best Use of Gemma: Gemma 3 4B (vision) is the core of the app. Running locally through Ollama, it compares pickup and return photos for every angle and returns the new damage, severity and a verdict as structured JSON. It also looks at the vehicle and picks its price class.
Best Use of Render: Render hosts the whole app: the Node.js server and front end as a web service, and Render Postgres for listings, bookings and chat, all defined in render.yaml. Live at idlewheels.onrender.com.
Best Use of GitHub Copilot: GitHub Actions automates the project. Every push checks the code, runs a server test and deploys a static copy to GitHub Pages.

My dad came up with the idea. I built it in one very caffeinated morning. He has already asked about his commission.

If your vehicle is napping right now, go list it. And if you've ever lost a "that scratch was already there" argument, tell me about it in the comments. 👇

— Raga Vinjanampati, a broke student whose scooter earns more than she does (on paper)

I built an app that lets 2.5-billion-year-old rocks guilt-trip you. My college rocks are very disappointed in me.

Raga Vinjanampati — Mon, 12 Oct 2026 06:23:34 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

A rock told me my face was a distraction.

Not a person. A rock. A big granite boulder in Hyderabad, about 2.5 billion years old.

"Do try not to stare so intensely. Your face is a distraction."

To be fair, I did build the app that made it say that. So that one's on me.

What I Built

Adopt-a-Rock is a Tamagotchi, but it's a rock. And it only works if you go outside.

Hyderabad is full of huge, ancient rocks. My college, Gokaraju Rangaraju (GRIET), has them too. I've walked past them for years and never once asked how they were doing.

So now they tell you. Here's how it works:

Find a rock. Take one photo. The app saves where the rock is.
Wait. The rock is asleep. It's 2.5 billion years old. It doesn't reply the same day.
It wakes up. Overnight, a free AI running on my laptop looks at the photo and gives the rock a name, a personality, and a grudge. It even gets its own voice.
Go back. When you visit the rock again, it talks to you through your earbuds. Each visit unlocks a new bit of its story.
Stay away, and it texts you. Rocks get lonely. And dramatic.

You can't look after a rock from your bed. You have to go outside.

Demo

Every rock line in the video comes straight from the app. I didn't write a single one of their insults. They came up with those on their own. (The googly eyes were my idea. The rocks did not consent.)

Meet the Rocks

I tested the app on photos of famous Hyderabad rocks. Here's who woke up.

🪨 Khajanchi (patiently grumpy)

Wants to be dusted with "a single, perfectly formed sand grain each morning."
Has a neighbour rock called Prakasan, who is "always trying to get people to mistake him for me."
On how I photographed it: "It's a poor angle. A very poor angle."

🪨 Katta (grumbling, stoic)

"I consider all shadows an intrusion."
Hates construction work nearby: "It's a crime against geological stability."
Secretly likes the light through the leaves. Even rocks have a soft side.

🪨 Chilakalu (cantankerous)

Thinks the pebbles around it are arranged wrong. It's been annoyed about this for a long time.
When I took its photo: "Focus on the boulders, woman."

🪨 Gael (irritated)

"I've developed a distinct dislike for the colour orange."
The one that told me my face was a distraction.

🪨 My college rocks (asleep 💤)

Then I went to adopt the rocks at my own college, GRIET.

Me and my rock. Only one of us is 2.5 billion years old. Only one of us has a braid.

This one lives at my college. It has seen more batches graduate than any professor.

These two are wedged between the college buildings. The buildings came later. The rocks have opinions about that.

They haven't said a word yet. They're still asleep, waiting for the laptop to wake them up. They've waited 2.5 billion years for someone to notice them, so they're in no hurry. But I can already tell they're disappointed in me. I've walked past them for years and never said hi.

Skip a Visit, Get a Text

If you don't visit, your rock starts messaging you. These are real messages from Khajanchi:

3 days: "A pigeon has built a nest in one of my larger cracks. Really?"

7 days: "The ORR traffic continues its incessant, grating roar."

14 days: "A particularly aggressive auto-rickshaw nearly clipped my base. The audacity!"

My mom doesn't guilt-trip me this well.

No Proxy Attendance

Every college student knows the trick: get a friend to mark you present. This app doesn't fall for it.

A visit only counts if you're actually standing near the rock and the photo matches. Try to check in with a different rock, and the real one gets offended:

"Prakasan is a fool. He's shaped differently, he's covered in algae, and he constantly tries to block my sunlight. He is not me." — Khajanchi

Stricter than my college's attendance system.

Bloopers

The AI is small, so it gets things wrong. My favourites:

I asked Gael for one "3 days without a visit" message. It kept going: "Nine days. A pigeon sat on me. I let it." Its 14-day message went all the way to "Thirty-five days. I am parched, utterly depleted."
Katta finished a story, then kept typing closing quote marks: ” ” ” ” ” ” ” ”. Forever.
Khajanchi wrote a scene where I put a plastic bottle next to it for the photo. There was no bottle. The AI just decided I was that kind of person.

How I Built It

The tricky part: phones can't run a big AI model easily, and there's no signal near most rocks. So I split the work in two.

Rocks are slow. Everything that happens at the rock runs on the phone, with no internet. The heavy AI work happens at home on my laptop, while the rock "sleeps".

PHONE (works offline)                 LAPTOP (at home)
─────────────────────                 ────────────────
Camera + GPS                          Gemma 3 (the rock's brain)
Photo matching (CLIP)        ⇄        Piper (the rock's voice)
Saved stories + voices      Wi-Fi     Writes new stories overnight

Gemma 3 4B (Google's open model) runs on my laptop through Ollama. It looks at the rock's photo and writes the personality, stories, and nagging texts. Waking up one rock takes about 2 minutes.
CLIP runs right inside the phone's browser. It checks whether your photo shows the same rock. It works with Wi-Fi and mobile data turned off.
Piper turns the text into speech. Each rock gets its own voice and talks a little slowly, because rocks are never in a hurry.
When the phone gets back on home Wi-Fi, it syncs with the laptop and picks up any new stories.

Three things I learned about getting a small AI to be funny:

It copies examples. If I put one example line in my instructions, every rock repeated it. So I describe the style instead of giving examples.
Make it look first. I ask the AI to list what it sees in the photo before it writes anything. That way the stories mention real details, like cracks, trees and the building behind the rock.
Check its work. The code throws out broken answers (like the quote-mark spiral) and asks again, up to 3 times.

Code

Raga-V / deccan-rocks

Adopt a 2.5-billion-year-old granite boulder in Hyderabad. It talks, slowly and with grudges. Offline phone PWA + local Gemma, no cloud.

Deccan Rocks

Adopt a 2.5-billion-year-old granite boulder in Hyderabad. Visit it. It talks to you, slowly and with grudges.

Everything runs on your own devices. The phone works fully offline on the hill. The rock's brain (Gemma) runs on a laptop at home. No cloud API is involved, and GPS and photos never leave your phone and laptop.

The design trick: rocks are slow

In the field (phone, offline)	At home (laptop, local)
Snap the rock, read GPS	FastAPI + SQLite
CLIP ViT-B/32 in the browser (transformers.js) checks it's the same rock	Gemma 3 via Ollama looks at the photo and invents a personality
GPS check: within ~40 m of the adoption spot	Gemma writes the next 3 chapters, a rejection line and guilt-trip nags
Plays the next chapter's voice line, cached on the phone	Piper TTS gives every rock its own voice

A rock you adopt is asleep 💤…

View on GitHub

Why Does Open Innovation Matter?

Because a rock on a hill doesn't have Wi-Fi. Neither does most of my college.

	Adopt-a-Rock (open, runs on my devices)	A paid cloud AI
Works with no signal	✅ Yes	❌ No
Where your location goes	Your phone and laptop only	Someone else's server
Cost per visit	₹0	Pay every time
Can I change how the rock thinks?	Yes. Edit it, swap models, retrain it	No

An app like this knows where you go every day. For a student, that's basically your whole routine: which classes you skip and how long you spend at the canteen. I didn't want that on anyone else's server. With open models, it doesn't have to be.

Also, since every visit is free, your rock can talk to you every day for four years of college. For a rock, four years is about one blink.

The Serious Bit

The rocks have good reason to be grumpy. Hyderabad's ancient rock formations have been disappearing to construction for decades, and people here have fought for years to save them.

I gave the AI a list of things a Hyderabad rock might complain about: peacocks, biryani smell, rain puddles, auto-rickshaws, construction. Almost every rock picked construction or traffic. They know.

I started this as a silly project. Now I notice every rock on my way to class.

Go adopt a rock. It's been waiting since before your college was built. It will complain about that too.

— Raga Gowtami, student at GRIET, now legally responsible for several very disappointed rocks 🪨

P.S. If you build your own and your rock insults you, drop its best line in the comments. Mine called my face a distraction. Beat that.