DEV Community: Vidisha Gupta

Freeing AI from the Terminal: How We Built SwitchWarRoom to Turn Coding Agents into SRE Teammates in Slack

Vidisha Gupta — Sat, 07 Nov 2026 17:44:13 +0000

Submitted for the **Flip the Switch Hackathon* hosted by WeMakeDevs & DevTools Academy (Powered by Switch AI & SandboxAQ).*

🎥 Watch the 2-Minute Demo Video

Live Deployed App (Vercel): https://switch-war-room.vercel.app
GitHub Repository: https://github.com/vidishagupta/switch-war-room

1. The Terminal Dilemma: Why Solo AI Agents Fail Under Pressure

Imagine this scenario: It's 2:15 AM on a Saturday. Your PagerDuty alarm blares. A P1 outage has struck the checkout service. Kubernetes pods are crashing in an OOMKilled loop, and 38% of user transactions are timing out with HTTP 504.

In most engineering teams today, one on-call engineer wakes up groggy, opens their laptop, and launches an AI coding assistant (like Claude Code, Antigravity, or Cursor) in an isolated terminal window.

For the next 45 minutes, that engineer is the sole bottleneck:

Zero Visibility: The engineering manager, SRE lead, and VP of Engineering sitting in the #incident-war-room Slack channel have no idea what the agent is doing.
Rogue Risks: What if the agent suggests rm -rf / or runs an unparameterized database migration? With terminal-only agents, there are no organization-wide guardrails.
Context Loss: Once the engineer's terminal session closes, the reasoning chain, stack trace analysis, and reproducing tests vanish into thin air.

AI agents shouldn't be lonely terminal sidekicks. They should be transparent, cooperative team members in the channels where human teams already live.

That was our epiphany when we discovered Switch at the Flip the Switch hackathon. We built SwitchWarRoom to transform isolated coding agents into a synchronized SRE swarm right inside Slack, Discord, and the Switch Console.

2. Introducing SwitchWarRoom

SwitchWarRoom is an autonomous multi-agent incident response swarm powered by Switch and SandboxAQ's Switch Trust.

When an outage strikes, SwitchWarRoom instantiates a dedicated incident room across team channels and deploys a coordinated squad of four specialized AI agents:

                  ┌─────────────────────────────────────────┐
                  │          Monitoring Alerts              │
                  │     (Datadog / Sentry / PagerDuty)      │
                  └────────────────────┬────────────────────┘
                                       │
                                       ▼
                  ┌─────────────────────────────────────────┐
                  │             SWITCH BRIDGE               │
                  │     (Slack / Discord / WebSockets)      │
                  └────────────────────┬────────────────────┘
                                       │
       ┌───────────────────────────────┼───────────────────────────────┐
       ▼                               ▼                               ▼
┌──────────────┐               ┌──────────────┐               ┌──────────────┐
│  🕵️ Triage   │               │   🛠️ Patch    │               │  🛡️ Switch   │
│  Diagnostics │──────────────▶│  Engineering │──────────────▶│  Trust Gate  │
└──────────────┘               └──────────────┘               └──────┬───────┘
                                                                     │
                                                       [Human Sign-Off in Slack]
                                                                     │
                                                                     ▼
                                                              ┌──────────────┐
                                                              │  📋 Comms &  │
                                                              │ Post-Mortem  │
                                                              └──────────────┘

🕵️ Detective Triage: Ingests Sentry error traces and logs, correlates recent commits, and isolates root cause in 1.4 seconds.
🛠️ Patch Engineer: Synthesizes an automated Vitest/Jest reproduction test and creates a surgical bugfix diff.
🛡️ Switch Trust Sentinel: Enforces SandboxAQ security guardrails, scans for leaked API credentials, blocks destructive commands, and pauses for Human-In-The-Loop authorization via interactive chat buttons.
📋 Comms Commander: Keeps leadership updated with live progress reports and automatically publishes a comprehensive Blameless Post-Mortem.

3. How We Integrated Switch

Switch acts as the nervous system for SwitchWarRoom. Instead of reinventing custom chat bots for every single messaging platform, Switch gives us:

A. Universal Channel Bridging

Switch abstracts the underlying chat protocols. When our multi-agent orchestrator emits an event, Switch renders:

Rich Block Kit components with interactive action buttons in Slack.
Formatted Embeds with syntax-highlighted code in Discord.
Real-time updates to the local Switch Console desktop app.

B. Switch Trust MCP Integration

We implemented a dedicated Switch Trust Model Context Protocol (MCP) server over stdio. Before any agent executes bash commands or writes code, the operation is checked against Switch Trust guardrails:

Destructive commands like DROP TABLE or rm -rf are immediately blocked.
Sensitive credentials (AWS keys, Stripe secrets) are deterministically redacted before posting to chat.
Token budgets and dollar costs are monitored in real time (e.g., $0.0142 total AI cost for a full P1 resolution).

4. The Live Flow in Action

Here is what happens during an actual live incident:

Alert Ingestion: Datadog flags an OOM failure in checkout-api. Switch creates #war-room-checkout-api in Slack.
Root Cause Analysis: @Detective Triage immediately responds: > "I traced the stack trace to src/services/checkout.ts:88. Unbounded event listener allocation inside processCheckout(). On each transaction, an inline closure was bound to redisBus.on('payment_ack') without an .off() cleanup."
Automated Reproduction & Patch: @Patch Engineer runs a Vitest reproduction suite simulating 50 concurrent transactions to confirm the leak, then posts the exact surgical diff and PR link.
Human-In-The-Loop Gate: @Switch Trust Sentinel posts: > "Policy Alert: Modifies live production service. Switch Trust Compliance: 96/100. Human approval required." Two interactive buttons appear right in Slack: [✅ Approve Fix & Deploy Hotfix] and [🧪 Canary 10%].
Human Sign-Off: The on-call Tech Lead taps Approve.
Post-Mortem Auto-Generation: Within seconds of deployment, @Comms Commander confirms p99 latency returned to 120ms and generates an automated Blameless Post-Mortem ready for Notion and Jira.

5. Results & Real-World ROI

In our benchmark tests comparing traditional incident response vs. SwitchWarRoom:

Metric	Traditional Human Triage	SwitchWarRoom + Switch
Mean Time to Detect (MTTD)	~8.5 minutes	1.4 seconds
Reproduction Test Synthesis	~22 minutes	3.2 seconds
Human Coding Required	~35 lines under panic	0 lines (1-click sign-off)
Downtime Cost Avoided	N/A (Prolonged outage)	$18,400+ saved
Total AI Cost	N/A	$0.0142

6. What We Learned Building with Switch

Shared Context Trumps Solo Prompting: Bringing AI out of private terminals into Slack completely changes team dynamics. Junior engineers learn from the agent's diagnostic steps, and senior engineers maintain full veto authority.
Guardrails Build Trust: Nobody will let an autonomous agent touch production without guardrails. Having Switch Trust transparently score risk and enforce Human-in-the-Loop approvals gives enterprise teams the confidence to adopt agentic workflows.
The Future of Work is Centaur Teams: The most effective engineering team isn't 100% human or 100% autonomous—it's human leads directing specialized agent swarms through everyday chat interfaces.

7. Try SwitchWarRoom

Explore the project, run the interactive simulator, and inspect the code:

Live Deployed App (Vercel): switch-war-room.vercel.app
GitHub Repository: vidishagupta/switch-war-room
YouTube Demo Video: Watch on YouTube

vidishagupta / switch-war-room

⚡ SwitchWarRoom

Autonomous Multi-Agent Incident Response & SRE Swarm for Slack and Discord
Powered by Switch & SandboxAQ Switch Trust
Built for the Flip the Switch Hackathon hosted by WeMakeDevs & DevTools Academy.

🌐 Live Links

Live Deployed App (Vercel): https://switch-war-room.vercel.app
YouTube Demo Video: https://youtu.be/_1hyjWhKm3g
Technical Blog Post (Dev.to): https://dev.to/vidisha_gupta_/freeing-ai-from-the-terminal-how-we-built-switchwarroom-to-turn-coding-agents-into-sre-teammates-2aom
GitHub Repository: https://github.com/vidishagupta/switch-war-room

🏆 Hackathon Submission Details

Target Track: Track 1: Best Business Workflow ($2,000)
Bonus Tracks:
- 📝 Best Technical Blog Post (AirPods 5): Read our official article on Dev.to: Freeing AI from the Terminal: How We Built SwitchWarRoom
- 🎥 Demo Video (YouTube): Watch the 2-minute walkthrough on YouTube
- 🛡️ Switch Trust MCP: Standalone Model Context Protocol server in mcp-switch-trust/

💥 The Problem: Why Terminal AI Agents Fail in Production

AI coding agents (like Claude Code, Antigravity, OpenCode, and Cursor) are powerful, but they operate in isolated local developer terminals.

When a mission-critical P1 outage strikes:

Zero Visibility:…

View on GitHub

Built with passion for the **Flip the Switch Hackathon* by WeMakeDevs & DevTools Academy, powered by Switch AI.*

Ofrenda: Yaadon ka Diya — Virtual Remembrance Altar with Open-Weight AI

Vidisha Gupta — Fri, 30 Oct 2026 16:01:43 +0000

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

🪔 Ofrenda: Yaadon ka Diya — Virtual Remembrance Altar with Open-Weight AI

"Sab kuch aapke device par. Koi account nahi."

(Everything stays on your personal device. Zero accounts required.)

🕊️ A Quiet Sunday Morning: Why I Built This

Every Sunday morning, my grandmother (Dadi Savitri Devi) would wake up before the sun to boil masala chai in her small, dented silver saucepan. She would send us down the street to fetch hot, syrupy jalebis from the neighborhood halwai, and as the kitchen filled with the aroma of roasted cardamom and fried sugar, she would quietly hum Lata Mangeshkar’s “Lag Ja Gale” under her breath.

When she passed away in 2021, the hardest part of grief wasn't a sudden crisis. It was the crushing quiet of Sunday mornings. It was realizing that all the tiny, sensory details that made up her soul—the sound of her glass bangles, the extra pinch of ginger in the tea, her laughter until tears rolled down her cheeks—were now held only in my fragile memory.

When I saw the prompt for Week 4 of the Hacktoberfest Open-Source AI Challenge: "Ghost in the Machine", my heart initially sank.

In recent months, we’ve all seen Silicon Valley hype cycle around "grief-tech"—companies promising that if you upload your deceased parent's text messages and voice notes, an AI chatbot will let you "talk to their ghost."

To me, that felt heartbreakingly wrong. Grief is not an interactive customer support bot. Our ancestors are not LLM conversational agents to be hallucinated by statistical next-token prediction. It turns sacred remembrance into an uncanny valley puppet show.

I asked myself: What if the machine doesn't try to be a ghost at all? What if technology could simply be a humble, sacred altar?

🏵️ The Bridge: Where Día de los Muertos Meets the Indian Diya

That question led me to look at two ancient traditions separated by oceans, yet identical in heart:

        MEXICAN OFRENDA                           INDIAN DIYA
  (Día de los Muertos Tradition)             (Deepam / Pitru Smriti)
  +----------------------------+             +----------------------------+
  | Orange Cempasúchil Petals  |  <=======>  | Sacred Marigold Garlands   |
  | 3-Tier Wooden Altar Steps  |    SHARED   | 3 Spheres (Soul, Body, Earth|
  | Favorite Comfort Foods     |    TRUTH    | Bhog & Prasad Offerings    |
  | Copal Incense to Guide     |   OF LOVE   | Chandan & Copal Dhoop      |
  | Lighting Candles for Spirit|             | Lighting Sacred Diya Flame |
  +----------------------------+             +----------------------------+

In Mexican tradition, during Día de los Muertos, families build multi-tiered ofrendas. You don't pretend the dead are still mortal; you lay out their favorite dishes, scatter bright orange marigolds (cempasúchil), and burn copal resin so their spirit feels loved and remembered.

In Indian tradition, we light a Diya (Deepam / Yaadon ki Jyoti). The flame represents the eternal Aatma—the indestructible soul that has crossed the river of time. We offer bhog (their favorite sweets) and sit together recounting the exact memories that made them who they were.

Ofrenda: Yaadon ka Diya is my tribute to this shared human impulse: a virtual, interactive 3-tier remembrance altar powered by open-weight AI (Gemma 2 & Qwen 2.5) and built with uncompromising on-device privacy.

🎬 1080p Interactive Walkthrough & Live App

Watch how the application feels in action—complete with natural Indian voiceover, ambient score, live cursor interactions, photo upload, flame lighting, and streaming Hinglish remembrance:

🔗 Verified Project Links

🌐 Live Web Application (Render): https://ofrenda-yaadon-ka-diya.onrender.com
📂 GitHub Source Code: https://github.com/vidishagupta/ofrenda-yaadon-ka-diya
🩺 Production Health Check: https://ofrenda-yaadon-ka-diya.onrender.com/health

vidishagupta / ofrenda-yaadon-ka-diya

Ofrenda: Yaadon ka Diya - Virtual Remembrance Altar powered by open-weight AI (Gemma) for Dev.to Hacktoberfest Open-Source AI Challenge

🪔 Ofrenda: Yaadon ka Diya

Dev.to Hacktoberfest Open-Source AI Challenge — Week 4
Theme: Ghost in the Machine / Día de los Muertos

🌐 Live Production Website & Demo

Live ofrenda website: https://ofrenda-yaadon-ka-diya.onrender.com
Cinematic 1080p Demo Video: https://youtu.be/07Xy2v-2z6I
Health Check Endpoint: https://ofrenda-yaadon-ka-diya.onrender.com/health

🌟 What is "Ofrenda: Yaadon ka Diya"?

Ofrenda: Yaadon ka Diya is a virtual remembrance altar builder fusing the Mexican tradition of Día de los Muertos (ofrendas, cempasúchil/marigold petals, copal incense) with the Indian tradition of lighting a Diya (Deepam / Yaadon ki Jyoti) for departed ancestors.

Users honor their loved ones by entering their name, relation, lifespan, favorite foods, favorite songs, and 2–3 cherished personal memories. An open-weight model (Gemma via Ollama or any OpenAI-compatible open endpoint) weaves these memories into an intimate, warm remembrance letter streamed in Hinglish or English.

The remembrance is presented on an illuminated 3-tier glowing altar:

View on GitHub

💡 The "Ghost in the Machine": Compassionate Mirror vs. Eerie Impersonator

Here is the foundational philosophy behind Ofrenda:

The machine should never pretend to "be" our loved ones.

Instead, the machine is a compassionate chronicler and mirror—a reverent listener that gathers the specific living details we choose to honor (the jalebi, the chai, the melody, the laughter) and weaves them into a tender remembrance letter (Yaadon ki Chitthi).

🛡️ Strict Prompt Guardrails (Zero Hallucination)

To protect the sanctity of family memory, our AI system prompt enforces four unbreakable cardinal rules:

Strict Zero Hallucination: The model must ONLY use the explicit facts typed by the user. If the user only enters "loves tea and Sunday mornings", the AI is forbidden from making up that she was a doctor, or had a golden retriever, or lived in Paris. If input is sparse, it writes around those exact memories with universal emotional tenderness.
Hard 180-Word Ceiling: Grief diluted by verbosity becomes hollow. The letter is kept strictly under 180 words—lyrical, focused, and intimate.
Ban on Funeral Clichés: Generic tropes—like "gone too soon", "taken before their time", or "rest in peace"—are strictly banned. The focus is 100% on living gratitude: the sweetness of the food, the melody of the song, and the warmth of the presence.
Natural Conversational Hinglish: The model crafts the letter in the comforting, authentic cadence of everyday Indian homes—natural Hindi in Latin script with English warmth ("Aaj ofrenda par aapka diya roshan kiya hai, pyaari Dadi... chai aur jalebi ki mehak...").

// System Prompt Guardrail: Emotional Dignity & Zero Hallucination
const SYSTEM_PROMPT = `You are a reverent chronicler for 'Ofrenda: Yaadon ka Diya'.
Write a short, tender remembrance letter honoring a departed loved one.

CARDINAL RULES:
1. Use ONLY the user-provided facts (name, relation, foods, songs, memories).
2. DO NOT invent or assume new facts, places, professions, or anecdotes.
3. NEVER use funeral clichés like 'gone too soon' or 'rest in peace'. Focus on celebrating living memory.
4. Keep the letter strictly UNDER 180 WORDS.
5. If language is Hinglish, write natural, warm conversational Hindi in Latin script.`;

🏛️ The Three-Tier Sacred Altar

In ofrenda lore, an altar’s tiers mirror the sacred journey between worlds. In Ofrenda, every tier is dynamically generated in real-time as you type, rendered in cinematic midnight indigo (#070913) and marigold orange (#ff8500):

+---------------------------------------------------------------+
|         NIVEL 1: ETERNAL SPIRIT (AATMA & LIGHT)               |
|   - Ornate vintage golden oval portrait frame                 |
|   - Central sacred Diya with dual-layer flickering flame      |
|   - Name & Lifespan banner (e.g., "Dadi Savitri Devi")        |
+---------------------------------------------------------------+
|         NIVEL 2: BHOG & OFRENDAS (NOURISHMENT & SCENT)        |
|   - Illustrated offering plates of favorite comfort foods     |
|     (Garam garam jalebi, Masala chai, Pan de muerto)          |
|   - Smoking brass burner with Copal & Chandan Dhoop           |
+---------------------------------------------------------------+
|         NIVEL 3: SUR & YAADEIN (MELODIES & EARTH)             |
|   - Retro cassette cards of cherished songs & melodies        |
|   - Memory blossoms pinned to marigold garlands               |
|   - Floating, fluttering cempasúchil (marigold) petals        |
+---------------------------------------------------------------+

🕯️ Pure CSS Dual-Layer Flame & Animation

The central diya does not use heavy GIF assets or CPU-intensive canvas loops. It is crafted entirely with hardware-accelerated CSS:

An inner white-hot core (#fff) pulsing at 0.18s organic jitter.
An outer golden-amber teardrop (#ff9e00 to #ffd166) with radial glow filter.
Dynamic glowing aura that gently breathes when idle and pulses rapidly while the AI streams tokens.
Accessibility: Fully honors prefers-reduced-motion for motion-sensitive users.

🔒 Why Open Innovation Matters for Sacred Memories

The official Hacktoberfest Week 4 prompt asks:

Why does open innovation matter for what you built?

Here is my core conviction:

1. Sovereignty of Grief: No Corporate Data Harvesting

Grief, family anecdotes, childhood nicknames, and private tears are the most vulnerable personal data human beings hold. Sacred memories should never become training data for closed commercial AI conglomerates.

Ofrenda operates with zero database.
100% of altar data, photos, and letters are stored exclusively in the user's browser localStorage.
When run locally with Ollama, family stories never touch the internet.
Notice our app's pledge banner: "Sab kuch aapke device par. Koi account nahi."

2. Immunity from Deprecation & Corporate Gatekeeping

Commercial AI APIs routinely deprecate models, hike token prices, or enforce crude blanket safety filters that frequently misclassify death rituals and ancestor honoring as "harmful content."

An open-weight model (Gemma 2, Qwen) stored on your hard drive is yours forever. No board meeting or corporate acquisition can revoke your right to remember your grandmother.

3. Cultural Preservation Beyond Silicon Valley Monoculture

Closed APIs are predominantly trained and aligned on Western corporate standards. Preserving non-Western traditions—such as blending Mexican Day of the Dead with Indian Diya rituals in conversational Hinglish—requires open models that can be prompted, adapted, and hosted freely without corporate sanitization.

🛠️ System Architecture & Tech Stack

                     +------------------------------------+
                     |         Browser Client             |
                     |  - Semantic HTML5 & Modern CSS3    |
                     |  - Pure Vanilla JS (ES Modules)    |
                     |  - LocalStorage Memory State       |
                     |  - html2canvas PNG + TXT Export    |
                     +-----------------+------------------+
                                       |
                              HTTP POST (SSE Stream)
                                       |
                                       v
                     +------------------------------------+
                     |     Node.js + Express Backend      |
                     |        (Live on Render)            |
                     |  - Native fetch & SSE streaming    |
                     |  - Health check at /health         |
                     |  - Strict prompt sanitization      |
                     +-----------------+------------------+
                                       |
                        +--------------+--------------+
                        |                             |
                        v                             v
           [Local Offline Inference]      [Production Hosted Cloud]
             Ollama (Gemma 2 / Qwen)       Render + Open Weights (Groq)
             http://localhost:11434/v1      OpenAI-Compatible Endpoint

Technical Specifications

Layer	Technologies Used	Key Purpose
Backend	Node.js, Express, Native `fetch`	Server-Sent Events (SSE) token streaming & health monitoring
Frontend	Vanilla HTML5, CSS3 Variables, ES6 JS	Zero framework overhead (<30KB footprint), instant 60fps load
AI Layer	Open-Weight Gemma 2 & Qwen 2.5	OpenAI-compatible streaming interface; local or hosted
Styling	Midnight indigo (`#070913`), Marigold (`#ff8500`)	Cinematic Día de los Muertos & Diwali nocturnal visual aesthetic
Deployment	Render Web Service (`render.yaml`)	High availability, continuous deployment, `/health` monitoring
Exports	`html2canvas` & Blob API	Instant high-resolution PNG altar download & `.txt` tribute file

🪔 Interactive Features Walkthrough

Multi-Altar Tabs: Honor multiple ancestors (e.g., Dadi Savitri Devi, Dada ji, Abuelita) with independent tabs and memory state.
On-Device Photo Cropping: Drop any JPG/PNG photo. It gets encoded client-side into a Data URI and mounted into the golden oval altar frame.
Real-Time Token Streaming: Click "Light the Diya (Diya Jalayein)"—watch the sacred flame awaken as words appear token-by-token on vintage parchment.
Extra Diya Tributes: Click "+ Light Extra Diya" to place additional named candles on the altar shelf for other loved ones.
High-Resolution PNG Export: Capture the full 3-tier illuminated altar as a 2x supersampled PNG to share with family or print.
Chitthi Text Export: Download the remembrance letter with tribute metadata as a .txt keepsake.

🚀 How to Run Locally in 2 Minutes

# 1. Clone the repository
git clone https://github.com/vidishagupta/ofrenda-yaadon-ka-diya.git
cd ofrenda-yaadon-ka-diya

# 2. Install dependencies
npm install

# 3. Pull an open-weight model with Ollama
ollama run gemma2:9b

# 4. Start the server
npm start

Visit http://localhost:3000 and light your first diya!

🌺 Closing Reflection

A computer program can never replace the touch of a mother's hand, the sound of a grandfather's laugh, or the wisdom in an elder's eyes.

But code can be a sanctuary. When built with open-weight models, respectful boundaries, and uncompromising privacy, technology can give our collective memories a warm place to rest.

May the light of your diya never flicker out. 🪔🏵️

Built with love, code, and marigolds by Vidisha Gupta for Dev.to Hacktoberfest Open-Source AI Challenge 2026.

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

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.

Demo

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

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

Code

📦 GitHub Repository: https://github.com/vidishagupta/sloth-finance

vidishagupta / sloth-finance

🦥 SlothFinance

Autonomous Open-Source AI Financial Tamer That Rewards Laziness

Built for the DEV Hacktoberfest 2026 Week 3 Challenge: Slow and Steady (International Sloth Day)

🌐 Live Demo (GitHub Pages) • ⚡ Live Mirror (Vercel) • 📝 DEV Submission Article • 🎥 Watch 1-Min Video Demo • 🚀 Render Blueprint Deploy

🎥 1-Minute Video Walkthrough

(Click above to watch the 1-minute full walkthrough with AI voiceover and synchronized subtitles)

🌟 The Philosophy: Why "Slow and Steady"?

Tomorrow is International Sloth Day, and sloths have life figured out: they move at their own pace, conserve energy, and avoid unnecessary effort.

Yet in our modern digital lives, humans lose hundreds or thousands of dollars every year to financial inertia:

🧟 Zombie Subscriptions: Forgotten free trials that quietly converted to full recurring bills.
📈 Stealth Price Creeps: Streaming platforms and SaaS tools quietly hiking rates by $2 to $5/month without explicit…

View on GitHub

How I Built It

SlothFinance combines modern web tech, zero-shot tabular time-series models, and open-weights LLMs:

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

1. TabPFN (Prior Labs) - Tabular Foundation Model

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.

2. Google Gemma 2 (Open-Weights Agent)

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

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."
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.

3. Production Deployment on 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

Why Does Open Innovation Matter?

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.

My Agent Session

I built SlothFinance with pair programming support from Google Antigravity. Antigravity helped architect the dual-AI pipeline: connecting Prior Labs' tabular classification with Gemma 2's legal draft generation, structuring the client-side parsing routines, and configuring the Render blueprint for effortless zero-setup deployment.

The Lazy Payoff

Time Saved: Auditing 12 months of statements manually takes 3–5 hours of tedious spreadsheet checking. SlothFinance does it in under 3 seconds.
Direct Financial Recovery: The average test persona recovered $3,706.20/year in forgotten zombie subs and stealth price creeps with 1 click.
Effortless Legal Enforcement: 1-click legally backed cancellation letters eliminate the friction of arguing with retention reps or navigating dark cancellation mazes.

Prize Categories

Best Use of TabPFN (Prior Labs)
Best Use of Google Gemma 2
Best Use of Render

🦥 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! 🖤