DEV Community: Jayesh Jain

TL;DR Sloth: The Privacy-First Group Chat Summarizer

Jayesh Jain — Tue, 20 Oct 2026 18:07:07 +0000

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

What I Built

Waking up to 150 missed messages in a group chat is exhausting. Finding out if you actually need to do anything—or if people are just arguing over dinner plans—takes too much scrolling.

I built TL;DR Sloth to reward laziness. It is a web application that acts as your personal, highly efficient sloth assistant. Instead of reading the chaos yourself, you paste the exported chat log into the dashboard. The application instantly processes the conversation and hands you a clean, 3-part morning briefing:

The TL;DR: A one-sentence summary of the entire conversation.
Plans & Mentions: A bulleted list of actual plans made, or if anyone specifically asked you to do something.
The Drama: A quick summary of any arguments, tension, or funny moments so you're not out of the loop.

Because of TL;DR Sloth, anyone who hates scrolling gets to stay lazy without missing the important details.

Demo

Live Application: https://tldr-sloth.vercel.app

(Feel free to try it out by pasting a messy group chat log!)

Code

The full project is open-source and available here:

Jayesh-JainX / TLDR-Sloth

Your lazy, privacy-first group chat summarizer. Let the sloth do the reading.

🦥 TL;DR Sloth

Your lazy, privacy-first group chat summarizer. Let the sloth do the reading.

📸 Demo & Live Application

Take it for a spin: https://tldr-sloth.vercel.app (Replace with your actual Vercel link if different)

(Note: Ensure your screenshot is saved as demo.png inside your frontend/public/ folder so this image loads perfectly on GitHub!)

💤 The Problem: Group Chats are Exhausting

You step away from your phone for two hours, and suddenly your group chat has 150 missed messages. People are arguing, plans are being made, and someone is asking you a direct question—but finding it means scrolling through endless memes and chaotic texting.

You could paste the chat into a generic AI like ChatGPT, but group chats contain your friends' personal lives, inside jokes, and private drama. Commercial AI tools store that data and use it to train their corporate models.

Nobody wants their private group chat drama harvested by…

View on GitHub

How I Built It

The application is built to be fast, reliable, and completely stateless:

Frontend: Built with Next.js and Tailwind CSS, featuring a relaxing, earthy green UI to match the sloth theme.
Backend: A decoupled Node.js & Express server running entirely in-memory with absolutely no database.
Open-Source AI Core: The backend routes through OpenRouter to tap into the open-weight model meta-llama/llama-3.1-8b-instruct.
The "Lazy" Engineering: Open-weight models can occasionally truncate JSON responses. Instead of building a complex retry mechanism, I engineered an aggressive Regex boundary-extraction algorithm that lazily grabs the required data even if the JSON brackets are cut off.

Why Does Open Innovation Matter?

Group chats contain highly sensitive, personal drama, inside jokes, and private plans.

If I built this tool using a closed commercial API like ChatGPT, I would be taking my friends' private lives and handing them over to a massive tech company to be logged and potentially used for model training. Nobody wants their personal group chat drama harvested by big tech.

Open innovation is the only way this tool can ethically exist. By utilizing open-weight models via a stateless proxy, I guarantee a strict "in-and-out" memory design. The chat log exists in the server's temporary RAM for exactly 4 seconds during inference. The second the summary appears on the screen, the data is instantly and permanently destroyed.

The Lazy Payoff

This weekend, my friends were planning a cabin trip. I stepped away from my phone for three hours and came back to 84 messages spanning three different chaotic topics.

Instead of reading the backlog, I pasted the log into the app. In exactly 4 seconds, TL;DR Sloth told me:

TL;DR: The group finalized cabin plans, but Dave accidentally scheduled a work shift.
Plans: Mike is driving and bringing the cooler. Alex is getting the keys.
Drama: Sarah got annoyed at Dave for forgetting his schedule.

It saved me 10 minutes of scrolling, let me know I didn't need to bring a cooler, and allowed me to safely ignore the rest of the chat. Mission accomplished.

F.E.R.P.A. Grader: A Privacy-First, Stateless AI Essay Evaluator Built for Tutors

Jayesh Jain — Fri, 16 Oct 2026 16:54:24 +0000

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

What I Built

F.E.R.P.A. Grader is a subscription-ready, stateless micro-SaaS designed for private high school tutors, essay coaches, and freelance educators.

Grading essays is exhausting, but teachers face a massive legal roadblock: strict educational privacy laws (like FERPA) prohibit them from pasting student text into commercial AI tools like ChatGPT, where user data is logged and harvested for model training.

F.E.R.P.A. Grader solves this by offering instant, rubric-based essay critiques using a zero-database, in-memory architecture. The text exists for 3 seconds during inference and is instantly purged.

What my first user said:

"I tested it with a sample student paragraph. Having instant rubric breakdowns without worrying about data retention policies or school compliance makes this something I would actually pay a monthly fee for as an independent tutor."

Demo & Architecture

Live Application: https://ferpa-grader.vercel.app/
Frontend: Built with Next.js and Tailwind CSS for a clean, distraction-free educator dashboard, hosted on Vercel.
Backend: A decoupled Node.js & Express server running entirely in-memory with no database and no user authentication required.
AI Core: Routes through OpenRouter to tap into open-weight models (nvidia/nemotron-3.5-super-vl:free), enforcing strict JSON schemas for structured grades and commentary.

Code

The complete source code is public and open-source under the MIT License:

Jayesh-JainX / FERPA-Grader

Privacy-first, instant essay feedback for educators—built entirely without data storage.

🛡️ F.E.R.P.A. Grader (StatelessGrader)

Privacy-first, instant essay feedback for educators—built entirely without data storage.

📸 Demo & Application Preview

Here is a look at the F.E.R.P.A. Grader interface in action. The split-screen dashboard allows educators to input custom rubrics and student essays on the left, receiving instant, structured critiques on the right with a verified "Memory Cleared" privacy indicator.

(If the image doesn't load directly, you can check out the preview assets inside the frontend/public/ directory).

🍎 For Teachers & Educators (The "Non-Tech" Story)

Grading essays is one of the most time-consuming parts of teaching. While artificial intelligence can help speed up the process by offering immediate feedback and rubric breakdowns, teachers face a major roadblock: student privacy.

Under strict educational privacy laws (like FERPA), educators cannot legally paste sensitive student essays into standard commercial AI tools. Those tools store your text on massive corporate servers and often use…

View on GitHub

Why Does Open Innovation Matter?

You cannot build a legally compliant educational app using closed commercial APIs.

True Data Sovereignty: Closed frontier models retain prompt history and train on user input. By routing through OpenRouter to open-weight models, we retain full transparency over how student data is handled.
Stateless Compliance: Because the code relies on open weights, we can deploy a 100% stateless backend that makes zero database calls—guaranteeing that minors' academic data is never stored or monetized by big tech.
Sustainable Cost Structures: Independent tutors operate on thin margins. Open-weight models keep API expenses fractions of a cent per essay, making a viable business model possible.

Equipment Field Medic: Hands-Free AI Gear Repair for the Wilderness

Jayesh Jain — Tue, 06 Oct 2026 12:27:04 +0000

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

What I Built

Equipment Field Medic ⛰️🏕️ is a hands-free Wilderness Gear Diagnosis and Repair Assistant built for backpackers, hikers, cyclists, and mountaineers.

When your gear breaks miles away from civilization, you want to keep your hands on your gear, not scrolling on your phone screen. Equipment Field Medic uses standard camera snapshots to accurately diagnose physical gear failures and walks you through emergency field repairs using Text-to-Speech narration and Hands-Free Voice Commands.

It perfectly embodies the "Touch Grass" theme because it is designed to make the screen the shortest part of the experience. You snap a photo, let the open-weight vision model diagnose the issue, and then the screen dims into a battery-saving OLED black mode. From there, you just listen to the voice guidance and use spoken commands like "Next Step" while you literally get your hands dirty fixing your bike or gear in the great outdoors.

Demo

Live Application: Equipment Field Medic (Hosted on Vercel)
Taking it Outside (Real-World Test): To earn the "Touch Grass" bonus points, I took my bicycle outside, manually dropped the chain, and tested the application trail-side! The model correctly diagnosed the chain issue from a quick photo and narrated the exact steps to reset the chain which was perfect, because my hands were covered in chain grease and I couldn't touch my phone anyway.

Code

The full project is open-source and available here:

Jayesh-JainX / Equipment-Field-Medic

Equipment Field Medic is a hands-free Wilderness Gear Diagnosis and Repair Assistant built for backpackers, hikers, and mountaineers.

Equipment Field Medic ⛰️🏕️

Equipment Field Medic is a hands-free Wilderness Gear Diagnosis and Repair Assistant built for backpackers, hikers, and mountaineers.

When your gear breaks miles away from civilization, you want to keep your hands on your gear, not scrolling on your phone screen. Equipment Field Medic uses standard camera snapshots to accurately diagnose failures (using open-weight Llama Vision models) and walks you through emergency field repair using Text-to-Speech narration and Hands-Free Voice Commands.

Key Features

Hands-Free Operation: Say "Next Step", "Previous Step", or "Dim Screen" via Web Speech API built right into the browser.
Vision-Assisted Diagnostics: Harnesses Hugging Face models like meta-llama/Llama-4-Scout-17B-[16E]-Instruct (or intelligent fallbacks) to identify broken components and suggest repairs using ONLY the tools currently packed in your Gear Locker.
Stealth Battery Saver: Dims the screen natively with high-contrast OLED black themes to preserve vital battery life when dealing with lengthy field repairs.
…

View on GitHub

How I Built It

The application is engineered to be lightweight, resilient, and completely hands-free once the repair starts:

Open-Source AI Core: The diagnostic engine is powered by the open-weight multimodal model meta-llama/Llama-4-Scout-17B-16E-Instruct (accessed via the Hugging Face Inference API / Novita). It analyzes the uploaded image of the gear failure and outputs structured, step-by-step emergency repair protocols based only on the tools the user has packed in their virtual Gear Locker.
Hands-Free Interface: The app uses the native browser Web Speech API for voice recognition (listening for commands like "Next Step", "Previous Step", or "Dim Screen") and Text-to-Speech (TTS) to dictate the instructions.
Database & Persistence: Backed by MongoDB Atlas, which securely stores the user's "Gear Locker" inventory and repair history. It supports a graceful local-memory fallback when the user loses signal on the trail.
Stealth Battery Saver: An automated high-contrast OLED black theme activates during lengthy repairs to preserve crucial phone battery life in the wilderness.
Hosting: Deployed on Vercel for fast, low-latency edge delivery.

Why Does Open Innovation Matter?

When you're stranded on a trail with a broken bike or a snapped tent pole, relying on a closed, proprietary AI ecosystem is dangerous. Open-weight models are vital for outdoor utility tools for three major reasons:

The Pathway to Offline-First: Closed APIs (like OpenAI or Claude) enforce a permanent dependency on the cloud. By architecting this application around open weights like Llama 4, the core logic can eventually be quantized and ported to run 100% locally on a mobile device via WebAssembly/WebGPU. Survival and emergency repair knowledge shouldn't require a 5G connection.
Data Sovereignty: Real-world geolocation, physical inventory data, and movement habits shouldn't be harvested by closed corporate APIs to train proprietary models. Open-weight inference gives users complete sovereignty over their data.
No Vendor Extortion: Open models allow the developer community to fine-tune the AI specifically on wilderness survival manuals and specialized cycling mechanics without paying expensive, unpredictable API token fees every time a hiker needs help.

Open innovation ensures that tools designed to help people safely explore the physical world remain accessible, auditable, and free from corporate walled gardens.

Prize Categories

Best Use of MongoDB Atlas: I utilized MongoDB Atlas as the primary data layer to persist user Gear Locker inventories, offline-cached repair protocols, and diagnostic histories, ensuring critical data availability across sessions.

Wellness AI Lens: Building an Open-Source Multimodal Nutrition Guide for My Friend

Jayesh Jain — Sat, 03 Oct 2026 17:50:45 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Wellness AI Lens specifically for my close friend, Aarav.

Aarav recently decided to take his fitness and dietary health seriously. However, he struggled constantly with two major friction points:

Hidden Ingredients & Allergen Uncertainty: He suffers from recurring digestive sensitivity and lactose intolerance, making dining out or trying new meal options a game of nutritional roulette.
Tedious Manual Logging: Mainstream fitness apps require typing out every individual item, measuring ounces, and guessing ingredients—a chore he gave up on after just three days.

Wellness AI Lens solves this by acting as a pocket health companion. Aarav simply takes or uploads a photo of his meal, and the application instantly:

Identifies every visible component on the plate.
Delivers an accurate macronutrient (protein, carbs, fats) and calorie breakdown.
Scans for high-risk allergens and inflammatory ingredients tailored to his sensitivities.
Recommends contextual post-meal activity and lifestyle adjustments to avoid glucose spikes.

What Aarav said when I showed him:

"I snapped a photo of a curry bowl at lunch, and within seconds it flagged hidden cream content I wouldn't have noticed. Not having to manually search an ingredient database to track my lunch makes me actually stick to my goals."

Demo

Live Application: https://wellness-ai-lens.vercel.app

* Demo Video:

Wellness AI Lens: Scan Your Food with AI | Jayesh Jain posted on the topic | LinkedIn

Wellness AI Lens – 60-second demo Scan Your Food: https://lnkd.in/dUfighAa 🚀 See how AI turns every plate into insight 🔍 Computer-vision scan → instant macros, micros & allergens 💯 Smart health score for each bite 🤖 Built-in chat dietitian for follow-up questions 📈 Tracks goals, meals, steps, sleep & more 🔔 Auto reminders, daily summaries, weekly reports 🔐 Secure auth + dark/light themes Watch the quick video and imagine smarter eating made effortless.

linkedin.com

Code

The complete source code is public and open-source under the MIT License:

Jayesh-JainX / Food-Analysis-Platform

AI-Powered Food Analysis, Nutrition Tracking & Health Intelligence Platform

Wellness AI Lens - Food Analysis Platform

AI-Powered Food Analysis, Nutrition Tracking & Health Intelligence Platform

Live Demo

🌟 Overview

Wellness AI Lens is an advanced AI-powered food analysis and health management platform designed to help users make informed nutritional and lifestyle decisions. By leveraging modern computer vision and multimodal LLM intelligence via Hugging Face Inference API, the platform enables users to scan food items, retrieve accurate nutritional breakdowns, track fitness goals, explore disease management strategies, and access tailored exercise routines.

✨ Key Features

🍎 AI Food Analysis & Vision Scanning

Image & URL Analysis: Analyze food items using camera uploads or direct image URLs.
Nutritional Breakdown: Real-time identification of macronutrients (protein, carbs, fat) and micronutrients (calories, sodium, fiber, sugar).
Health Score Algorithm: Automated health scoring based on nutritional density and ingredient composition.
Allergen & Ingredient Detection: Highlighting potential allergens and health advisories.
Scan History &…

View on GitHub

How I Built It

Wellness AI Lens is architected to be responsive, scalable, and built around open-weight intelligence:

Frontend: Built with Vite + React for an ultra-fast, responsive mobile-first UI.
Backend: A Node.js server handling image pre-processing, prompt structure, and authenticated endpoints.
Authentication & Database: Supabase handles secure user authentication and persists historical food scans, allergen profiles, and fitness logs.
Hosting: Deployed on Vercel for low-latency serverless edge delivery.
Open-Source AI Core: The visual inspection pipeline is powered by the open-weight multimodal model meta-llama/Llama-4-Scout-17B-16E-Instruct (accessible via the Hugging Face Inference API / Novita provider).
- The image payload and a domain-specific structured prompt are dispatched to the model.
- The model outputs a strict JSON payload containing dietary tags, detected allergens, estimated macro distributions, and personalized advice based on user profile flags stored in Supabase.

Why Does Open Innovation Matter?

Health, diet, and lifestyle data are among the most sensitive personal records an individual generates daily. Building Wellness AI Lens on an open foundation was an intentional choice for three reasons:

User Privacy & Sovereign Health Data: Closed commercial vision APIs (like proprietary frontier models) retain user data according to opaque corporate terms. By building on open weights via Hugging Face endpoints, we retain full ownership of our pipeline. Because the model weights are public, this architecture can be ported to run on local hardware (e.g., self-hosted Ollama on a home server) without rewriting a single business-logic prompt.
Protection Against Vendor Lock-in & Token Extortion: Proprietary vision APIs are costly for daily nutritional tracking where a user scans 3–5 meals a day. Open-weight models democratize access—allowing independent developers to offer high-caliber multimodal analysis without incurring prohibitive per-token taxes.
Reproducibility & Customization: Open weights allow the developer community to audit model bias, fine-tune for regional cuisines (such as Indian and Asian regional dishes, which proprietary Western models often misclassify), and run lightweight quantized checkpoints on commodity hardware.

Open innovation ensures that tools designed to help people live healthier lives remain accessible, auditable, and free from corporate walled gardens.

How a Rogue Anti-AI Bot Network is Hijacking Government Google Results

Jayesh Jain — Sat, 01 Aug 2026 12:08:14 +0000

If you regularly monitor your server logs or browse high-authority websites, you might have noticed a bizarre trend creeping into your browser’s address bar recently.

Whether you are pulling up an Anthropic economic report, checking the U.S. Environmental Protection Agency (EPA) website, or visiting the Indian Government’s Sanchar Saathi portal, you might stumble across URLs that look like this:

At first glance, it looks like a developer accidentally pushed a joke into a production environment. But a deeper technical investigation reveals a highly coordinated, automated SEO exploit. A rogue developer has built a sprawling scraper network to protest the rise of AI-generated code, and they are leveraging technical SEO vulnerabilities to etch their manifesto directly into Google Search results worldwide.

Here is a breakdown of how this bot network operates, why major government and corporate websites are falling victim to it, and the exact steps developers need to take to lock down their domains.

The Motive Behind the Network

To understand the exploit, you have to look at the motive. “Vibe coding” is a slang term that gained heavy traction recently. It describes the practice of building software purely by feeding natural language prompts to AI agents without manually writing or verifying the underlying logic.

Many traditional software engineers strongly oppose this shift, arguing that it creates fragile, insecure, and unmaintainable systems.

One engineer decided to take aggressive action. By tracing the backlink profiles of these strange URLs, investigators uncovered a centralized root domain anchoring the entire operation: https://vibecodingisbullshit.com/.

Beneath the text lies a directory of what the creator calls their “Enterprise Partner Network.” The developer registered a massive portfolio of domains (shielded behind Cloudflare privacy) to act as a coordinated syndication engine. The core network generating the spam includes:

The Mechanics of the Exploit

This is not a server hack. The developer hasn’t breached the databases of Anthropic or the UK Government. Instead, they are exploiting how search engines crawl the web.

The network operates on a classic content aggregator model, weaponized to cause maximum SEO chaos:

The Scrape: Automated bots continuously crawl high-authority targets — governments, AI companies, and news portals.
The Syndication: The bots scrape the headline and the first few paragraphs of an article, publishing the snippet on one of the network’s .ai or .sucks spam domains.
The Trap: To avoid triggering automated copyright takedowns, the bots add a “Read Full Article” button that links back to the original source.
The Payload: Every single outbound link is hardcoded with a protest parameter, such as utm_source=vibecodingsucks.

There is even a tell-tale programming artifact left behind by the scraper script. If you look at the parameter article_id=446943146.0, you'll notice the .0 at the end. In Python data-scraping workflows (particularly when using the Pandas library), integer database IDs frequently convert to decimal floats if the data structure isn't typed strictly.

Auditing the Footprint: How to Search This Yourself

You don’t have to take my word for the scale of this exploit. You can verify the damage on live targets right now by using advanced search operators in Google (often called Google Dorking).

By using the inurl: operator, you can bypass normal text search and force Google to display every URL it has accidentally indexed with this rogue payload.

To see the global footprint of the network, copy and paste this exact string into Google:

inurl:vibecodingisbullshit OR inurl:vibecodingsucks OR inurl:vibecodingsucksdev

When you run these operators, the results are staggering. You bypass the actual article content and expose the raw, parameter-laden footprints left behind by organizations missing their canonical tags.

Why Government Sites Are the Primary Victims

When the scraper network publishes these articles, Googlebot crawls the .ai spam sites, clicks the outbound links, and arrives at the official websites carrying the utm_source=vibecodingsucks payload.

Ideally, Google should recognize that UTM parameters are just tracking noise and only index the clean URL. But this relies entirely on the target website having proper technical SEO in place — specifically, the canonical tag.

A canonical tag tells search engines exactly which version of a URL to index, explicitly commanding them to ignore arbitrary tracking parameters.

Government websites (.gov, .gov.in, .gov.uk), massive academic portals, and legacy corporate CMS builds are notorious for carrying immense technical debt. Many of them completely lack canonical tags. When Googlebot hits these pages, it assumes the parameter-laden URL is a unique, valid document. Because the bot network generates thousands of these links daily, Google assigns them authority and indexes them, pushing the joke URLs into public search results.

The Developer’s Triage Plan

If your analytics dashboard or Google Search Console is suddenly flooded with these parameters, your site’s SEO architecture is compromised. Here is the playbook to fix it.

1. Deploy Canonical Tags (The Real Fix)
This is the only permanent solution. Ensure every page on your application outputs an absolute, self-referencing canonical tag in the <head> document.

<link rel="canonical" href="https://www.yourdomain.com/clean-path" />

Once deployed, Google will consolidate the link equity and drop the spam parameters from its index automatically over the next few crawl cycles.

2. Do Not Use robots.txt
Many developers instinctively add Disallow: /*?utm_ to their robots.txt file. This is a fatal mistake. If you block Google from crawling the UTM link, it cannot read your new canonical tag. As a result, Google will likely leave the spam link in the search index marked as "Indexed, though blocked by robots.txt."

3. Disavow the Scraper Network
Go into the Google Search Console Disavow Tool and upload a text file rejecting the root domains. This tells Google’s algorithm to sever any association with the scraper network:

domain:vibecodingisbullshit.ai
domain:vibecodingsucks.ai
domain:vibecoding.sucks
domain:vibecodingsucks.dev

4. Clean the Client-Side Address Bar
To prevent real users from seeing the vulgar parameters and accidentally sharing them on social media, strip the UTMs using the JavaScript History API right after your analytics scripts fire:

if (window.location.search.includes('utm_source=vibecoding')) {
    const cleanUrl = window.location.protocol + "//" + window.location.host + window.location.pathname;
    window.history.replaceState({}, document.title, cleanUrl);
}

5. Block the Scrapers
Check your server logs to isolate the IP addresses or User-Agent strings hitting your site at superhuman speeds. Block them at the firewall level or engage a Web Application Firewall (WAF) to challenge aggressive automated traffic.

The Takeaway

The irony of this protest is hard to ignore. A developer protesting the dangers of automated, unchecked software has unleashed an automated, unchecked bot network that is actively polluting the internet.

Regardless of where you stand on AI-assisted coding, this incident serves as a massive wake-up call for webmasters. If your canonical infrastructure isn’t airtight, anyone with a domain name and a Python script can rewrite how your organization appears in search results.