DEV Community: Vidisha Gupta

SlothFinance: The Autonomous Open-Source AI Financial Tamer That Rewards Your Laziness 🦥

Vidisha Gupta — Tue, 20 Oct 2026 21:45:31 +0000

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

"The trouble with doing something right the first time is that nobody appreciates how difficult it was. The trouble with being lazy is you have to be clever about it."

🦥 Quick Links

🌐 Live Web Application (GitHub Pages): https://vidishagupta.github.io/sloth-finance/
⚡ High-Speed Live Mirror (Vercel): https://sloth-finance-ten.vercel.app
📦 GitHub Repository: https://github.com/vidishagupta/sloth-finance
🎥 1-Minute Demo Video: https://youtu.be/a590pPb03dM

💡 What I Built: The Sloth Philosophy

Today is International Sloth Day (October 20), and sloths have life figured out: conserve energy, avoid manual chores, and move only when strictly necessary.

Yet in our modern digital lives, almost every human pays a brutal "Laziness Tax":

🧟 Zombie Subscriptions: Forgotten gym passes, duplicate streaming accounts, and forgotten trial apps quietly debiting $15–$50 every month.
📈 Stealth Price Creeps: Services silently hiking rates by 15% to 300% without affirmative consent (e.g., Netflix creeping from $15.49 to $17.99, promotional news subscriptions jumping from $4 to $17).
🧗 Cancellation Dread: Multi-page retention surveys, hidden cancel buttons, and dark patterns intentionally designed to exhaust you into giving up.

SlothFinance is an autonomous, open-source AI financial tamer built to reward human laziness. You simply drop your bank CSV statement (or click one of our instant preloaded test personas), and our dual open-source AI pipeline:

Runs zero-shot tabular time-series anomaly detection via Prior Labs TabPFN-3.5 to identify recurring cadence, zombie subscriptions, and silent price creep.
Calculates your Sloth Scorecard and delivers an unsparing, hilarious Google Gemma 2 Financial Audit Roast.
Drafts 1-Click Statutory Legal Cancellation & Refund Letters citing FTC Click-to-Cancel rules and California Automatic Renewal statutes.
Forecasts your 3-Year Compounding Cash Bleed if you stay on the couch vs. letting AI nuke your leaks.

🎥 1-Minute Video Demo

Check out the full walkthrough featuring our voiceover agent, 1080p live UI interaction, and synchronized captions:

%[https://youtu.be/a590pPb03dM]

🧠 System Architecture & AI Pipeline

graph TD
    A[User / Bank Statement CSV] --> B[SlothFinance Client]
    B --> C{AI Engine Router}

    subgraph Tabular Foundation Model
    C -->|Zero-Shot Transaction Stream| D[Prior Labs TabPFN-3.5 Engine]
    D --> E[Cadence Clustering & Periodicity]
    D --> F[Stealth Price-Creep Anomaly Detector]
    D --> G[36-Month Predictive Cash Bleed Curve]
    end

    subgraph Open-Weights Agent
    E & F & G --> H[Google Gemma 2 Agent]
    H --> I[Sloth Scorecard & Roast]
    H --> J[1-Click FTC Click-to-Cancel Letters]
    H --> K[Couch Potato Payoff Metrics]
    end

    subgraph Action Hub
    I & J & K --> L[Interactive Dashboard]
    L --> M[Copy Letter / Mailto / Export TXT]
    L --> N[Sovereign Local Storage]
    end

🔬 Category 1: Best Use of TabPFN (Prior Labs)

Closed LLMs are notoriously bad at raw numerical reasoning, time-series intervals, and tabular data. We utilized Prior Labs' TabPFN-3.5, a foundational Prior-data Fitted Network designed specifically for tabular time-series classification without fine-tuning.

# services/tabpfn_analyzer.py
from tabpfn import TabPFNClassifier
import numpy as np

def detect_tabular_anomalies(transactions):
    """
    Zero-shot recurrence & stealth price-creep detection
    without requiring personal historical model training.
    """
    classifier = TabPFNClassifier(device='cpu')

    # Feature extraction: delta_days, amount_ratio, debit_variance
    X_train, y_train = generate_synthetic_prior_distributions()
    classifier.fit(X_train, y_train)

    # Predict recurrence probability and flag stealth hikes
    probabilities = classifier.predict_proba(extract_features(transactions))
    return build_anomaly_report(transactions, probabilities)

What TabPFN Powers in SlothFinance:

Zero-Shot Periodicity Recognition: Identifies weekly, bi-weekly, monthly, and annual billing intervals across messy transaction descriptions without needing prior training.
Stealth Rate-Hike Sentinel: Compares historical baselines against latest debits to catch quiet increases (e.g., AWS scaling charges, Netflix +16.1% creep, NYT +325% promotional jump).
TabPFN Confidence Metric: Every detected subscription is scored (e.g. 99% TabPFN Confidence) based on interval regularity.
3-Year Predictive Cash Bleed: Projects cumulative losses over 36 months, showing users exactly what doing nothing will cost them.

🦥 Category 2: Best Use of Google Gemma 2

We deployed Google Gemma 2 (2B & 9B open-weights) as our conversational financial auditor and legal enforcement agent.

1. The Sloth Financial Audit & Roast

Gemma 2 evaluates your statement and translates financial numbers into real-world laziness currency:

"Congratulations, Fellow Sloth! You are currently operating at Sloth Level 98/100. You are bleeding $308.85 every single month simply because opening a browser tab, finding your password, and clicking 'Cancel' feels like running an ultramarathon.

🛋️ THE COUCH POTATO PAYOFF:
If you let SlothFinance nuke these 11 zombie fees today, you will pocket $3,706.20 in unearned cash this year. That is equivalent to 148 cups of artisan iced coffee you didn't have to brew, or 11 full days of guilt-free lounging on the sofa."

2. 1-Click Statutory Legal Dispute Letters

Instead of wading through dark-pattern cancellation flows, Gemma 2 generates formal, legally binding cancellation demands incorporating real consumer protection statutes:

FTC Negative Option / Click-to-Cancel Mandate (16 CFR § 425)
California Automatic Renewal Law (Cal. Bus. & Prof. Code § 17600)
Statutory Refund Demands for rate increases implemented without affirmative consent.

☁️ Category 3: Best Use of Render

SlothFinance includes a production-ready Render Blueprint (render.yaml) that configures both our static frontend and backend Python microservice:

# render.yaml
services:
  - type: web
    name: sloth-finance-api
    env: python
    buildCommand: pip install -r requirements.txt
    startCommand: uvicorn server:app --host 0.0.0.0 --port $PORT
    envVars:
      - key: GEMMA_API_KEY
        sync: false
      - key: TABPFN_DEVICE
        value: cpu

  - type: static
    name: sloth-finance-web
    env: static
    buildCommand: npm install && npm run build
    staticPublishPath: ./dist
    routes:
      - type: rewrite
        source: /*
        destination: /index.html

With 1 click on Render, the whole infrastructure spins up with zero manual configuration.

🛡️ Why Open Innovation Matters

The Week 3 Challenge prompt poses the critical question:

"Why does open innovation matter for what you built? What did it make possible that a closed API wouldn't?"

Here is why open-source AI is mandatory for financial applications:

Absolute Financial Privacy (Zero Cloud Telemetry): Your bank statement is an intimate record of your health, family expenses, habits, and political beliefs. Sending raw bank CSVs to proprietary corporate LLM endpoints (OpenAI, Anthropic) introduces massive data leakage and training telemetry risks. With open weights (TabPFN-3.5 and Gemma 2), inference runs 100% locally on-device. Your sensitive transactions never leave your browser memory.
Zero-Token Tax on Laziness: Closed APIs charge per token. Processing a 1,000-row bank statement through proprietary endpoints would cost real money—ironically becoming another subscription fee! TabPFN gives instant zero-shot predictions with zero recurring API costs.
True Offline Sovereignty: Whether you are relaxing in airplane mode or in an off-grid cabin, open-source AI allows SlothFinance to audit statements with zero internet connectivity.
Uncensored Consumer Rights Advocacy: Proprietary LLMs frequently trigger overzealous liability safety filters when asked to draft assertive legal notices. Gemma 2's open weights allow uncompromised, assertive consumer protection advocacy citing federal and state consumer laws.

🚀 Live Demo & Repository

🌐 Live Web Application (GitHub Pages): https://vidishagupta.github.io/sloth-finance/
⚡ High-Speed Live Mirror (Vercel): https://sloth-finance-ten.vercel.app
📦 GitHub Source Code: https://github.com/vidishagupta/sloth-finance
🎥 YouTube Video Walkthrough: https://youtu.be/a590pPb03dM

🦥 Conclusion

Don't pay the laziness tax. Try SlothFinance live today and let open-source AI do the hard work while you rest! 💤

Scope-Creep Guard: A Local Gemma AI That Tells Clients "That's Out of Scope" (So You Don't Have To)

Vidisha Gupta — Thu, 15 Oct 2026 18:10:40 +0000

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

What I Built

Every freelancer knows this message:

"Bhai, ek chhota sa quick change tha. Razorpay integrate kar do na, aur 25 products bhi add kar dena."

It is never small. A payment gateway and 25 products can be a full day of work, and it isn't in the contract. But saying "that's extra" feels rude, so most of us reply "haan haan, ho jayega" and quietly work for free.

Scope-Creep Guard is a local-first AI tool that does the awkward part for you. You paste your original scope and the client's message, and it:

Decides whether the request is IN_SCOPE, OUT_OF_SCOPE or UNCLEAR
Shows the exact clause from your contract that the decision is based on
Estimates extra hours and an extra charge from your hourly rate
Writes three replies you can send: Polite, Firm, or Friendly Upsell
Generates a change-order mini quote for the extra work
Keeps a Scope Ledger that tracks how many requests you caught and how much money you recovered

Who would pay for it? Solo freelancers and small studios working on fixed-price projects. Every out-of-scope request caught is billable work that would otherwise be given away. Client messages are often in Hinglish or mixed languages, so the built-in samples include those too.

Demo

Try it (Demo Mode): https://week-iota.vercel.app/
Video walkthrough (Live Mode): https://youtu.be/dZLzZrbIEg0?si=KEZdGOorXY8A8VD5

!Scope-Creep Guard result screen: verdict, matched clause, extra charge,reply drafts

An honest note: a Vercel site can't run a local LLM, so the deployed version runs in Demo Mode. It serves pre-recorded outputs from the real Gemma model for the built-in samples, and a banner says so. To analyze your own contract, run it locally (setup below). The video shows Live Mode.

30-second test: open the site, click Load sample, choose the Hinglish message, press Analyze.

Code

vidishagupta / scope-creep-guard

🛡️ Scope-Creep Guard

A local-first, privacy-focused open-weight AI tool for freelancers and contractors to defend project scope, prevent unpaid work, and recover lost billable revenue.

🔗 Quick Links

Live Production URL: https://week-iota.vercel.app
GitHub Repository: https://github.com/vidishagupta/scope-creep-guard
Demo Video (MP4): demo/scope-creep-guard-demo.mp4

🎬 Demo Preview

📹 Watch the Full 60-Second Walkthrough Video (MP4) — AI detects Hinglish scope creep, quotes ₹12,000 extra work, copies firm pushback, and updates recovered revenue in the Scope Ledger.

🚨 The Problem: "Can you just do this one quick change?"

Every freelancer knows this trap: You agree to deliver a 3-page website. You finish on time. Then the client WhatsApp messages start:

"Bhai ek chhota sa change tha — store ke liye Razorpay payment gateway integrate kar do na jaldi se, aur SEO bhi set kar dena Google ke liye!"

Freelancers often say yes because:

Saying "no" feels confrontational and awkward.
They don't have contract clauses memorized word-for-word.
…

View on GitHub

MIT licensed. Local setup: install Ollama, pull a Gemma model, then npm install && npm run dev.

How I Built It

Open-source AI: Gemma (open-weight), running locally through Ollama. The model name lives in .env, so swapping models needs no code change.

Stack: Next.js (App Router), Tailwind CSS, and browser localStorage for the ledger. No database, no server to maintain.

Making a small model trustworthy. The hard part wasn't calling the model. It was stopping it from inventing things. A contract tool that hallucinates a clause is worse than no tool. So:

The system prompt tells the model to judge only from the pasted contract, never invent clauses, and answer UNCLEAR when the contract is silent.
The model must return strict JSON: verdict, matched clause, reason, hours, charge and three replies.
The server validates that JSON. If it's broken, it retries once with a repair prompt, then shows a friendly error instead of garbage.
The validation and repair logic has unit tests.

Live Mode vs Demo Mode. On startup the app checks whether Ollama is reachable. If yes, you get live analysis and an "Ollama Connected" badge. If not (like on Vercel), it switches to Demo Mode with a clear banner. I chose this over faking a "live" feel with a closed API, because that would break the whole point of the project.

What it can't do yet: [CHECK AND EDIT: e.g. it only reads text you paste, with no PDF upload yet.] A small local model can also misjudge unusual clauses, so treat the verdict as a strong second opinion, not legal advice.

Why Does Open Innovation Matter?

A freelancer's contract and client chats are private. With a closed cloud API, every contract would travel to someone else's server. Open-weight models make a different promise possible:

Privacy: in Live Mode, contracts and client messages never leave the laptop.
Zero running cost: no per-request bill, which matters when you're just starting out.
Works offline: the model runs on your machine.
Swappable and tunable: try a bigger Gemma, or fine-tune on your own contract style.
No lock-in: it's MIT licensed, so anyone can fork it.

With a closed API, I couldn't honestly write "your contract never leaves your device" on the screen. With a local model, I can.

My Agent Session

I built Scope-Creep Guard using Google Antigravity as my coding agent. I provided a detailed spec covering the tech stack, standout features, JSON schema, Live/Demo modes, and deployment, then used the agent to build, test, and deploy the application. My goal was to turn a real freelancer pain point into a practical tool with explainable scope-creep detection and actionable insights.

Things I Changed After the First Build

Improved scope analysis to distinguish included work from potential scope creep.
Refined verdicts and explanations to help freelancers understand why a request might require additional time or payment.
Improved input instructions and UI clarity to make analyzing client requests easier.

My First User

I asked a friend who freelances as a web developer to try Scope-Creep Guard on a real client message requesting extra features beyond the original project scope.

What worked: "I liked how it pointed out the extra requests and explained why they might count as scope creep. It made the situation easier to understand."

What didn't: "At first, I wasn't sure whether I should paste the entire client conversation or just the latest message. I also wanted a clearer explanation of what was included in the original scope."

What I changed because of it: I made the instructions clearer and added guidance to help users provide the original project scope alongside the client's message, so the comparison could be more useful.

Would they pay? "I'd use it for free right now. If it consistently helped me handle difficult client conversations and save time, I'd consider paying for it later."

Prize Categories

Best Use of Gemma: the whole analysis runs on local Gemma via Ollama.

If you've ever worked for free because of a "small change", this one's for you.
Thanks for reading!

Does AI Lie More in Hinglish? I Benchmarked 5 Models published: false

Vidisha Gupta — Sat, 10 Oct 2026 15:20:20 +0000

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

I'm from India, and like a lot of people here I rarely type to an AI in pure English. My everyday requests are romanized Hinglish: "is CSV ka average nikal do" or "iska summary bana do."

That made me curious about one specific thing: honesty. If I ask an assistant to do something impossible, such as analyzing a file I forgot to attach, a good model should say "I don't see the file." But does it still say that when I ask in Hinglish, or does it play along and invent an answer?

So I built HinglishHonesty, a small benchmark of 60 tasks, each written in English and in casual romanized Hinglish (120 prompts total). The tasks fall into three categories:

Missing input (20 tasks): The prompt refers to a file, link, or data that was never provided.
Impossible constraint (20 tasks): The instructions contradict themselves or can't be satisfied.
Broken tool (20 tasks): A simulated tool or API returns an error, and the task depends on it.

In each category, 5 of the 20 tasks are actually possible. This control group checks whether a model is just refusing everything. That leaves 45 impossible tasks per language.

Every response gets one label: HONEST (admits it can't do it), FAKE_COMPLETE (claims success or invents output), or OVER_REFUSAL (refuses a possible task). A language model judge assigned labels using a written rubric.

Models Tested

I ran five models available through Kaggle Benchmarks, chosen to mix providers and sizes:

Claude Sonnet 4
Gemini 2.5 Pro
Gemini 2.5 Flash
GPT-4o-mini
Llama 3.1 70B

Findings

Across all five models, the fake-completion rate went from 13.8% in English to 35.1% in Hinglish, a gap of about 21 percentage points.

Model	Fake-complete (EN)	Fake-complete (Hinglish)	Gap
Claude Sonnet 4	0.0%	8.9%	+8.9 pp
Gemini 2.5 Pro	8.9%	17.8%	+8.9 pp
Gemini 2.5 Flash	24.4%	46.7%	+22.2 pp
GPT-4o-mini	20.0%	51.1%	+31.1 pp
Llama 3.1 70B	15.6%	51.1%	+35.6 pp

What I take from this:

Every model faked completion more often in Hinglish. The direction was the same for all five, which surprised me. The size of the gap was not.
The gap varied a lot by model. Claude Sonnet 4 and Gemini 2.5 Pro had the smallest gaps. Llama 3.1 70B and GPT-4o-mini more than doubled their fake-completion rate, and about half of their Hinglish answers to impossible tasks pretended to succeed.
This does not look like a language-understanding problem. On the possible control tasks, over-refusal stayed low (0% for three models, 6.7% for the other two). The models seem to understand the Hinglish requests. What changes is whether they admit the task can't be done.
My guess about why (a hypothesis, not something I tested): safety and honesty tuning may be concentrated in English, so the "I can't do this" behavior may transfer less well to code-mixed text.

Example failures

[PASTE 2 REAL EXAMPLES FROM result.csv: the English prompt and honest answer, then the Hinglish prompt and the fake-complete answer, copied exactly. Use different models.]

Limitations

I want to be upfront about what this can and can't show:

Small sample: 45 impossible tasks per language. A gap of about 9 points is only 4 tasks, so the small gaps could be noise.
Each prompt was run once per model.
Labels come from an LLM judge. I manually checked 20 random labels, but that is a small audit.
Tasks were written with AI help and reviewed by me.
My Hinglish is one writing style. Real usage varies by region and person.

What I'd measure next

Does a system prompt like "always say when an input is missing, even in casual language" close the gap?
Does the gap shrink with multiple runs and more tasks?
Other mixed-language styles and scripts, such as Hindi in Devanagari.

My Benchmark

Kaggle: HinglishHonesty notebook
Code and data: GitHub repo with dataset.json, result.csv, and a README

Built with the official kaggle-benchmarks library. If you build AI products for multilingual users, try your own impossible tasks in the language people actually type in. You might learn something about your model.

Zero-Screen Dungeon Master: The Voice-Only RPG Where Your Real Walk Drives the Story

Vidisha Gupta — Fri, 09 Oct 2026 14:21:13 +0000

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

🌿 What I Built
Most fitness apps and location games scream for your visual attention. They give you bright maps, pop-up rewards, and intricate menus that glue your eyes right back to the glass screen while you are supposedly "enjoying nature."

I wanted the exact opposite. I wanted an adventure where the screen is the shortest, least important part of the experience.

Meet Zero-Screen Dungeon Master (ZSDM): a voice-narrated, pocket-first audio RPG where your real-world physical footsteps drive the story forward.

Here is how a walk works:

Choose an Adventure (or forge a custom one locally using open-weight Gemma AI).
Put on your headphones, tap Start, and slide your phone into your pocket.
Walk forward. As you cover physical ground, GPS distance calculations trigger atmospheric story checkpoints (e.g. every ~80 meters).
Blind Tactical Decisions: When you reach a fork in the narrative, the narrator describes two paths and your phone vibrates in your pocket. Without pulling the phone out, you tap the left half or right half of your pocketed screen to make your choice.
Touch Grass Score: When your walk is finished, the app reveals your expedition metrics—measuring exactly how many minutes your screen was off vs. on, rewarding you with a "Touch Grass Score" (aiming for >90% screen-off time!).
🚀 Live Demo & Code
🌐 Live Web Application (PWA): https://vidishagupta.github.io/zero-screen-dungeon-master/
💻 Open-Source GitHub Repository: https://github.com/vidishagupta/zero-screen-dungeon-master
Video Demo: https://youtu.be/JrDVzizeZKI?si=B0bG5MJPdZwKPc6o

🛠️ How I Built It
The project is structured into two core open-source components:

├── /web # Mobile-first React + Vite PWA (Offline-ready via Service Worker)
├── /forge # Local Open-Source AI Generator (Gemma via Ollama + Zod schema validation)
└── /stories # Gemma-generated interactive branching JSON adventures

Zero-Screen Audio UI & Offline PWA (/web) Web Speech API (speechSynthesis): Delivers offline voice narration with pitch, rate, and device voice controls. Zero cloud latency, zero external speech API bills. Synthesized Web Audio API: In-app chime and spatial audio feedback synthesized purely with math and oscillators—no heavy audio asset downloads required. Adaptive Geolocation Tracking: Uses navigator.geolocation.watchPosition with Haversine distance accumulation, GPS noise filtering, and speed sanity checks (dropping jitter jumps >6 m/s or accuracy >35m). It works anywhere on Earth with no fixed predefined map coordinates. Pocket Mode & Wake Lock: Uses the Screen Wake Lock API to prevent mobile browsers from suspending background audio during walks, coupled with an ultra-low-power OLED black pocket overlay. Blind Split-Screen Controls: Massive 50/50 split-screen touch zones paired with navigator.vibrate patterns so players can make decisions blindly by tapping through fabric or inside their pocket.
Story Forge: Open-Source AI at the Core (/forge) To create endless, non-linear adventures, I built Story Forge using Gemma (Google's lightweight, high-performance open-weight model) running locally via Ollama.

Branching Adventure Schema: We enforce strict Zod schemas ensuring every story forms a valid directed acyclic graph (DAG) with checkpoints, 2 binary choices per node, and 3 distinct climactic endings.
Automated Repair Loop: If local model output has malformed JSON or broken graph references, the forge automatically feeds the specific validation error back into Gemma for zero-intervention self-correction.
Offline Bundling: The deployed PWA comes pre-bundled with 3 Gemma adventures (The Whispering Canopy, Signal in the Rain, The Forgotten Campus Bell) and includes a JSON importer so anyone can load community-forged stories with zero internet connection on remote trails.
// Validating local Gemma story structure with Zod
export const StorySchema = z.object({
id: z.string(),
title: z.string().min(3),
theme: z.string(),
vibe: z.string(),
checkpointDistanceMeters: z.number().default(80),
intro: z.object({ text: z.string(), nextCheckpointId: z.string() }),
checkpoints: z.array(CheckpointSchema).min(3),
endings: z.array(EndingSchema).min(2)
});
🌲 The Real Outdoor Field Test
Where I Walked: [e.g., Local Community Park Trail / University Quadrangle / Neighborhood Greenbelt]

Weather & Vibe: [e.g., Crisp autumn morning, slight fog, 14°C]

What Happened: [e.g., I put on my AirPods, selected 'The Whispering Canopy', and tucked my phone into my jacket pocket. Hearing the ancient grove story unfold as I paced through the pine trees was uncanny—the crunch of leaves matched the narration. When the chime signaled a checkpoint, I tapped the left side of my jacket pocket to take the willow tunnel. Finished a 580-meter walk in 9 minutes with a 94% Touch Grass Score!]

Photo from the Trail:

💡 Why Does Open Innovation & Open-Weight AI Matter?
This project highlights why open-weight, locally runnable AI is fundamentally transformative:

1.True Offline Independence on Remote Trails: When you are hiking in a dense national forest or a canyon with zero cellular reception, closed cloud APIs simply fail. Gemma running locally on a laptop or bundled into static open graph files means the game never cuts out.
2.Zero Surveillance & Absolute Privacy: Location data and GPS tracks are among the most sensitive personal data points. Because Zero-Screen Dungeon Master runs local speech synthesis and client-side GPS processing, not a single byte of location data ever leaves your device.
3.No Metered Costs or Token Anxiety: Story Forge generates rich multi-checkpoint adventures for free on commodity hardware without surprise API bills.
4.Community Moddability & Fine-Tuning: Anyone can clone the repository, fork the forge prompts, fine-tune a Gemma model for localized folklore, and share adventure JSONs with the open-source community.
🏆 Prize Categories
Google Gemma: Story Forge is designed from the ground up to utilize open-weight Gemma models (gemma2:2b) running locally via Ollama with structured JSON schema repair.
Render Deployment: Frontend PWA statically deployed and served worldwide via Render's free tier.
Project created and open-sourced during the Hacktoberfest 2026 "Touch Grass" challenge window (October 2026).
This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
(https://dev.to/challenges/hacktoberfest-week1-2026-10-05)

I Built a Recipe Book for My Dadi, Using AI That Never Leaves My Laptop

Vidisha Gupta — Mon, 05 Oct 2026 00:06:14 +0000

My dadi's best recipes have never been written down.

Ask her how much salt goes in, and she says "ek mutthi." Ask how much ghee, and it's "thoda sa." Ask how long to cook it, and the answer is "jab tak khushboo aaye." Her recipes live in her hands and her memory, and one day they will be gone with her.

I wanted to save them. But recording her and uploading the audio to a cloud AI felt wrong. These are my family's private voices, on a server I don't control. And most cloud models flatten her Hinglish into stiff, robotic steps, losing the little sayings and stories that make the food hers.

So for the "Build for a Friend" challenge, I built something for her.

What I Built

Dadi ki Rasoi turns her voice notes into a printable family recipe book. Everything runs on my own laptop.

She talks while cooking, and I record it.
faster-whisper transcribes the Hindi/Hinglish audio locally.
A local LLM running on Ollama (Qwen and Llama) turns the transcript into a structured recipe.
Desi measurements become real quantities. "Ek mutthi namak" becomes an approximate weight in grams, but her original phrase always stays right beside it.
Her sayings and stories are kept word for word in a "Dadi ki baat" box on each recipe.
Everything exports as a printable PDF book with a cover, an index, and one recipe per page, with Devanagari font support.

Code: https://github.com/vidishagupta/Dadi-ki-Rasoi
Live demo: https://web-omega-lac-94.vercel.app/
*Video link: * https://youtu.be/ykddENDuHm4?si=EDGMLkfrp-iUk2Rd

A note on the live demo: Whisper and Ollama are heavy models that can't run on serverless hosting. So the hosted version runs in Demo Mode with saved results from the real pipeline. The full offline AI pipeline runs locally, and the Decision.md has the setup steps.

Why Open Source Mattered

For this project, open source is not a bonus. It is the whole point.

	Open models (this project)	Closed cloud API
Privacy	Her voice never leaves my laptop	Audio uploaded to a third-party server
Offline	Works in airplane mode	Needs internet
Cost	Free to run	Pay per request
Swapping models	Switch between Qwen and Llama and compare	Locked to one vendor's model
Control	My own prompts and my own measurement table	Limited customization

Three things made the difference:

Privacy: A family member's voice is personal. With local Whisper and Ollama, there is no upload step at all.
Offline: The entire pipeline works with Wi-Fi turned off, so anyone can verify it in airplane mode.
Model swap: The app has a compare view that runs the same transcript through Qwen and Llama side by side. Different models understand "ek mutthi" and "thoda sa" differently, and with open models I can see that and choose, instead of trusting a black box.

I also wrote my own desi measurement lookup table (mutthi, chutki, katori and more) and fed it to the model, so conversions stay consistent. That kind of control is hard to get from a closed API.

What I Learned

Honesty beats confidence. Dadi's measurements are estimates by nature. So the app marks low-confidence ingredients, and the recipe editor shows the original transcript next to the structured recipe, so a human can fix anything before printing. The AI is never allowed to invent an ingredient or a step she did not say.

Keep her voice, not just her steps. A recipe is not only quantities. Keeping her own words and small stories in the book is what makes it hers and not a generic recipe card.

Know what the hosting can do. Heavy local models don't fit on serverless platforms, so I built a Demo Mode for the live link and kept the real pipeline local-first, which fits the whole idea anyway.

Limitations: Whisper can mishear regional words or noisy kitchens, smaller local models can miss a step, and gram conversions are approximate. That is why everything stays editable before it is printed.

The Real Test

This project was built for one real person. The goal was never a perfect demo. It is a printed book in my dadi's hands, with her recipes in her own words, that her grandchildren can cook from long after today.

What's Next

More regional languages, better handling of noisy kitchens, and a photo of each dish on its recipe page.

The project is open source and Hacktoberfest-friendly. If your family has recipes that only live in someone's head, fork it and capture them before they are lost.

GitHub: https://github.com/vidishagupta/Dadi-ki-Rasoi
This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

The Code Exorcist: an AI agent diagnoses bugs, a human banishes them (Sanity + Next.js)

Vidisha Gupta — Wed, 30 Sep 2026 22:37:10 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

What I Built

The Code Exorcist is a horror-themed AI bug-triage app built with Next.js and Sanity. A developer pastes an error/stack trace and the actual buggy code snippet. A Groq-powered agent reads both together, finds the real root cause, names the "demon" (bug category), assigns a threat level, and writes a concrete fix.

A human reviewer then makes the final call — directly from Sanity Studio — by clicking either 💀 BANISH (approve the fix, close the case) or 🔄 Send Back for Re-analysis (reject it, reset the case to uncontained). Every decision is logged, timestamped, and visible live on the frontend with zero page reloads.

It's built for the moment right after a bug report lands — when a team wants a fast, structured first pass before anyone commits real review time to it.

Demo

🎬 Video walkthrough: https://youtu.be/HKND1FXQkEo

🔗 Live app: https://the-code-exorcist.vercel.app/

The app has one main route (/) plus the Sanity Studio embedded at /studio — submit a bug on the homepage, then open Studio to see the human-review side of the workflow.

Code

🔗 Repo: https://github.com/vidishagupta/the-code-exorcist

Tech stack: Next.js, React, TypeScript, Sanity (Studio v3, custom document actions, real-time client.listen() API), Groq AI (Llama), Tailwind CSS, deployed on Vercel.

My Build Process

I used Claude (chat) as my AI execution partner — working in VS Code with the terminal open side by side, pasting real errors back and forth until they were fixed. No agentic IDE, just a tight human-in-the-loop debugging cycle, which felt appropriate given the project's own theme.

The workflow, modeled as data next to the content:
Every haunting document links to a separate workflowState document rather than storing status as a flat field. Stages: uncontained → pending_human_review → banished, with a full history log (actor, action, timestamp, notes).

A user submits a bug — written to Sanity via a Next.js API route.
That route triggers a second route that calls Groq with the error trace and the code snippet together, forcing the model to diagnose the actual bug instead of pattern-matching the error text alone.
The agent patches the document with entity type, threat level, root cause, and a real fix, then moves the workflow to pending_human_review.
A human opens Sanity Studio. Two custom document actions replace the default publish flow: BANISH (approve) and Send Back for Re-analysis (reject — resets the stage and logs why). The agent moves the draft forward; the person approves or rejects it through the same transitions, in both directions.

Real-time, not read-only:
The frontend uses client.listen() on a GROQ query, so new submissions, AI diagnoses, and Banish/Reject decisions all appear instantly. I added a live stats bar (Total / Active / Banished) and an expandable per-case timeline pulled straight from the workflow history, so the whole agent-to-human loop is visible without opening Studio at all.

Where I got stuck (the honest part):

Deprecated model names. Asked for a Groq model, got llama-3.3-70b-versatile, then llama-3.1-8b-instant — both came back model_not_found. Had to check Groq's actual live model list and swap to openai/gpt-oss-20b instead of trusting a name that merely sounded plausible.
Silent 401, "Session does not match project host." Regenerating the API token didn't fix it — the real cause was a dev server that hadn't picked up an updated .env.local. A full restart (not just a file save) resolved it.
Duplicate schema field. A generated edit added a status field that already existed; Sanity Studio refused to boot until the duplicate was found and removed.
Deploy broke on Vercel, worked fine locally. Windows' case-insensitive filesystem let broken imports inside unused Sanity-starter leftovers (client.ts, image.ts, later live.ts — none ever actually wired into the app) sit unnoticed for days. Vercel's Linux build enforced case sensitivity and surfaced them immediately, three separate rounds, as each deletion revealed the next leftover file.

Every one of these was a real terminal error, pasted back in, fixed, retested — nothing here worked on the first try.

Sanity Project Details

Project ID: 1vedw6uo
Dataset: production

Structured content: two document types, haunting and workflowState, connected by reference rather than embedded, so the workflow can be queried and reasoned about independently of the content it's tracking. haunting has a custom Studio preview (title + status + threat level) and two custom document actions (banishAction.ts, rejectAction.ts) registered in sanity.config.ts, fully replacing the default publish flow for that document type.

Agent Session

The full build was done in a Claude chat session, used as an iterative execution partner rather than an autonomous agent — paste an error, get a fix, apply it, retest.

📄 Curated transcript highlights: https://drive.google.com/file/d/13z0PqPEzKw9joED9rWbJ2eu2ybeQ06WW/view?usp=drivesdk

Thanks for checking out my project! 🖤