DEV Community: Daksh Lalwani

Muted the Group Chat, Missed the Deadline. So I Built a Sloth.

Daksh Lalwani — Mon, 26 Oct 2026 06:32:32 +0000

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

What I Built

Sloths nap through 300 group chat messages without a worry. I can't, so I built ChatSense to do the reading for me.

Paste or upload a messy chat and it hands back the only parts you need:

Tasks with a "time left" bar that turns red when you're nearly out of time
What changed, like "deadline moved from 30 Oct to 2 Nov", so the missed update isn't your fault
Bills and info cards, so the rent stops living in your head
A fraud check for sketchy messages ("your bank account will be blocked, click here!")

Every card points to the exact message it came from. If ChatSense says something, you can see the receipt.

Who gets to be lazier? Students who muted the group and missed the deadline change. Parents who keep forwarding "you have won 25 lakh!" texts. The flatmate who owes 590 and swears nobody told him. A sloth would approve.

Demo

Try it here: https://chat-sense.vercel.app/

There's a demo chat built in, so you can be lazy right from the first click.

Code

Daks9h / chat-sense

This is a Next.js project bootstrapped with create-next-app.

Getting Started

First, run the development server:

npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev

Open http://localhost:3000 with your browser to see the result.

You can start editing the page by modifying app/page.tsx. The page auto-updates as you edit the file.

This project uses next/font to automatically optimize and load Geist, a new font family for Vercel.

Learn More

To learn more about Next.js, take a look at the following resources:

Next.js Documentation - learn about Next.js features and API.
Learn Next.js - an interactive Next.js tutorial.

You can check out the Next.js GitHub repository - your feedback and contributions are welcome!

Deploy on Vercel

The easiest way to deploy your Next.js app is to use the Vercel Platform from the creators of Next.js.

Check out our Next.js deployment documentation for more…

View on GitHub

How I Built It

The brain is Gemma 4 E2B, an open-weight model. My rule was simple: Gemma reads, and plain code decides. A sloth doesn't waste energy, and neither should a model.

Gemma does the reading:

Sorts each message (task, bill, info, promo, suspicious)
Pulls out the details and notices when someone corrects an earlier message
Explains a scam's tricks in one simple line

Normal code does the thinking:

Works out real dates from each message's own timestamp, so a "tomorrow" sent last week is already overdue
Handles time left, totals, duplicates and undo
Gives the fraud verdict by checking the real link domain, URL shorteners, lookalike domains and UPI ID mismatches. Gemma names the tricks, and code makes the call. It never says "safe", only "No red flags found"

Every Gemma answer gets validated, and anything without a matching quote in the original message is thrown out. No source, no card.

The app is built with Next.js and shadcn/ui. On my own test chats it got 83% accuracy. That's not perfect, which is why every card shows its source and lets you edit it.

Why Does Open Innovation Matter?

Group chats are personal. They hold family drama, bank alerts and who owes whom money. A closed API would mean sending all of that to a server I don't control, every time I paste a chat. That's a lot to hand over just to avoid scrolling.

An open-weight model changes that. It can run on my own machine with no per-call bill, no rate limit and no waiting on someone else's servers. I can swap the model, tune the prompts and see exactly what it does. And since the repo is open, anyone can fork it, teach it their own language or local scams, and make it work for their own chats. Fraud looks different in every country, so that matters.

Set it up once, and it's yours to keep.

Prize Categories

Best use of Gemma 4

Learn Faster - The $0-API-Cost Exam Prep Engine Built on Local Open Weights

Daksh Lalwani — Mon, 19 Oct 2026 00:01:24 +0000

What I Built

Every semester, millions of university students drown in 2-hour lecture recordings before midterms. They scrub timelines at 1.5x speed, transcribe notes passively, and still fail tricky midterm questions because they never tested themselves under exam conditions.

Students already pay $15–$25/month for tools like Quizlet, Chegg, or Anki extensions. But existing tools require hours of manual card creation, and generic AI chat tools hallucinate or output vague bullet points instead of actual exam questions.

I built Learn Faster: a private, autonomous lecture-to-exam engine designed as a $0-marginal-cost study tool.

A student drops in a YouTube lecture recording or pastes raw lecture notes. In under 15 seconds, it builds a complete exam-readiness package:

Quick Take: 3 high-yield conceptual anchors without fluff.
Key Concepts: Core syllabus breakdown preserving hardware formulas, state tables, and definitions.

Exam Radar: Predictive questions tagged with priority tiers (very_likely, important) and Professor Trap Alerts targeting edge cases where instructors typically trick students.

Active Recall Deck: Interactive flashcards with definitive answers.
Adaptive Combat Quiz Arena: Gamified multiple-choice assessment with instant XP feedback, real-time score tracking, and 1-sentence technical explanations.

Knowledge Map: Real-time retention scores highlighting weak topics before test day.

The Hustle & Business Model
Target Audience: Engineering, CS, pre-med, and professional certification candidates (AWS, CompTIA, USMLE).

The Monetization Problem with Closed AI: If you build this on proprietary APIs (OpenAI/Anthropic), synthesizing a single 90-minute lecture (~25,000 words with multi-chunk summarization) costs $0.20–$0.40 per run. A student preparing for 4 courses would burn through $10/month in API costs alone, killing a student-budget SaaS margin.

The Open-Weight Solution: By shipping this as a local-first desktop app powered by local open weights, the marginal cost per user is literally $0.00. I can charge a flat $29 one-time license or a low-cost $7/month student pass and keep 100% gross margins.

Demo

Daks9h / learn-faster

Learn Faster ⚡

Transform chaotic lecture slides, notes, and transcripts into high-yield concept maps and combat quiz arenas.

💡 Overview

Students and self-directed learners frequently spend 80% of their study time passively re-reading 50-slide decks or skimming endless lecture recordings, leading to cramming and rapid forgetting. Standard AI summarizers only produce more dry walls of text.

Learn Faster turns passive study materials into an active, game-inspired learning experience:

Synthesizes unstructured lecture notes and transcripts into structured, high-yield takeaways.
Maps core dependencies into an interactive visual Knowledge Graph.
Challenges comprehension with an interactive Combat Quiz Arena that rewards XP and isolates weak topics.

✨ Key Features

🎯 Tactical Lecture Synthesis: Instant executive briefs, core formulas, essential definitions, and practical intuition without fluff.
🧠 Interactive Knowledge Graph: Dynamic node-link visualization displaying conceptual hierarchies, prerequisite pathways, and topic relationships.
⚔️ Combat Quiz Arena: Fast-paced active recall testing with instant…

View on GitHub

Preset Test Course: Includes a pre-configured UC Berkeley CS 152 (Computer Architecture: Booth's Multiplier & IEEE 754) demo so you can test the Combat Quiz Arena and Exam Radar instantly.

Code

Daks9h / learn-faster

Learn Faster ⚡

Transform chaotic lecture slides, notes, and transcripts into high-yield concept maps and combat quiz arenas.

💡 Overview

Learn Faster turns passive study materials into an active, game-inspired learning experience:

Synthesizes unstructured lecture notes and transcripts into structured, high-yield takeaways.
Maps core dependencies into an interactive visual Knowledge Graph.
Challenges comprehension with an interactive Combat Quiz Arena that rewards XP and isolates weak topics.

✨ Key Features

🎯 Tactical Lecture Synthesis: Instant executive briefs, core formulas, essential definitions, and practical intuition without fluff.
🧠 Interactive Knowledge Graph: Dynamic node-link visualization displaying conceptual hierarchies, prerequisite pathways, and topic relationships.
⚔️ Combat Quiz Arena: Fast-paced active recall testing with instant…

View on GitHub

Stack Highlights

Frontend: React + TypeScript + Vite, Tailwind CSS with brutalist zero-radius borders, Three.js / React Three Fiber interactive hero canvas.

Backend: Node.js Express server with Server-Sent Events (SSE) streaming real-time stage progress (/api/analyze?stream=true).

Data Integrity: Strict Zod schema validation with automatic error feedback retry loops to eliminate LLM schema degradation.

How I Built It

The entire product was engineered around open-weight models and local inference:

Local Open-Weight Core: Powered by Qwen2.5 7B running locally via Ollama. It runs smoothly on standard consumer hardware (tested on an everyday laptop NVIDIA RTX 3050 with 4GB VRAM).

Long-Lecture Hierarchical Chunking: Dense 90-minute technical lectures exceed standard context budgets. The backend breaks 60,000+ character transcripts into sequential semantic chunks, distills technical definitions and equations, and then passes the consolidated technical brief to the synthesis engine.

Strict JSON State Machine: Closed models charge extra for structured output guarantees. We built a zero-preamble prompt harness combined with Zod schema sanitization that enforces 4 options per question, valid index integers (0–3), and fuzzy-concept matching to keep quizzes 100% playable.

Pluggable Architecture: A clean AIProvider interface allows swapping between local Ollama inference and lightweight cloud fallbacks (e.g. Gemini Flash) with zero client-side code changes.

Why Does Open Innovation Matter?

Open-source AI isn't just an implementation detail here—it is the reason this business model works:

Zero Marginal Server Cost: Closed-source API costs scale linearly with your user base. With open weights running on the user's laptop, my infrastructure cost is $0. Whether a user synthesizes 1 lecture or 100 lectures during finals week, it costs me nothing.

True Student Data Privacy: University professors frequently warn students against uploading proprietary lecture slides, internal problem sets, and unreleased exam hints to cloud AI tools. With local inference, client lecture data never leaves their laptop.

No Network Dependency: Students study in library basements with dead zones, on trains, and on campus Wi-Fi that blocks AI services. Open innovation lets students study completely offline without an active internet connection.

No API Price Hikes or Sudden Deprecations: You can't run a student side hustle if a cloud provider 3x's their token pricing or deprecates a model mid-semester. With frozen open weights, the software works forever.

My First User

To test whether this was something people would actually use and pay for, I handed the build to an engineering friend preparing for a Computer Architecture midterm.

What they said: "Normally, I spend 3 hours scrubbing through 50-minute Panopto recordings just to find the two slide examples the professor emphasized for the exam. The Exam Radar flagged the exact Booth's recoding hardware edge cases in 15 seconds."

What did they ask for next? One-click export to Anki .apkg files so they can sync cards to their phone, and support for uploading raw course slide PDFs directly.

Prize Categories

Hacktoberfest Week 2: Side Hustle Track
Open-Source AI / Local Inference Track

StreetQuest AI: A Photo Treasure Hunt That Gets You Outside

Daksh Lalwani — Mon, 12 Oct 2026 06:58:21 +0000

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

What I Built

I spend most of my day looking at a screen. So I built something that makes me put it down.

StreetQuest AI is a small treasure-hunt game. You pick a level and get a simple mission, like "find a heart-shaped object" or "find an unusual leaf". Then you go outside, take a photo, and upload it. An AI looks at the photo and tells you if it matches. If it does, you earn points.

That's it. Nine missions, three levels. Easy missions take about two minutes. Medium unlocks after you finish two Easy ones, and Hard unlocks after two Medium ones. I kept it small on purpose, so it feels like a quick walk and not homework.

Demo

Code

Daks9h / streetquest

StreetQuest AI — Outdoor Treasure Hunt

A calm, minimal outdoor treasure hunt game powered by Gemma 4 (gemma-4-26b-a4b-it) via the Gemini API Built for the Hacktoberfest 2026 DEV Open-Source AI Challenge, Week 1 "Touch Grass" Hashtags: #devchallenge #weekendchallenge #hf26challenge

🍃 Overview

StreetQuest encourages players to step outside and observe natural details around them:

Choose a level: Easy (always open), Medium (unlocks after 2 Easy missions), or Hard (unlocks after 2 Medium missions).
Accept a mission: 9 missions total, from finding living leaves to discovering natural patterns.
Capture a photo: Uploaded directly from mobile or desktop with automated canvas resizing ($\le 1024\text{px}$).
AI Photo Check: The backend verifies the photo using Gemma 4 26B in memory without ever writing user photos to disk.
Score & Ranks: Earn points for valid matches (Seedling $\rightarrow$ Trail Finder $\rightarrow$ Ranger $\rightarrow$ Pathfinder).

…

View on GitHub

How I Built It

The flow

You pick a mission in the React app.
The app shrinks your photo so it uploads fast.
A small FastAPI backend sends the photo and the mission to Gemma 4.
Gemma replies with a verdict (match, no match, or unclear), a confidence score and a short reason.
The backend checks the reply is valid, then sends it back.
If it's a match, you earn points. Each mission can only be rewarded once.

The stack

Frontend: React, Vite and Tailwind CSS
Backend: Python and FastAPI
AI: Gemma 4 through the Gemini API in Google AI Studio
Storage: your browser's localStorage. No accounts, no database.

A few choices I made

The API key stays on the backend. The browser never sees it.
Photos are never saved. They are processed in memory and then dropped.
The server decides the mission rules. The browser only sends a mission ID, so nobody can edit the request to make any photo match.
"Unclear" is a real answer. If a photo is dark, blurry or far away, the app asks for a better one instead of guessing. A match with low confidence also counts as unclear.
The prompt ignores text inside the photo. Someone could hold up a sign saying "this is a match", and the model is told not to follow it.

What went wrong

A photo of caterpillar goes wrong through AI during testing.

Honest limits

A photo check can't prove you went outside. Someone could upload a picture from the internet. StreetQuest is a nudge, not a lie detector.
Scores live in your browser, so they can be edited. That's fine for a game, not for a competition.
The free tier has rate limits, so the app shows a calm message when they are hit.
On the free tier, Google may use what you send to improve its products. That is why the app asks you not to upload photos of people.

Why Does Open Innovation Matter?

Gemma 4 is open-weight and released under the Apache 2.0 license. For a small project like mine, that matters in three ways:

No lock-in. I used the hosted API to move fast, but my code only talks to one model name stored in a config setting. Switching models, or hosting Gemma myself, would be a small change, not a rewrite.
Privacy is possible. A photo game can be sensitive. With open weights, a school, club or community group could run it on their own machine, so photos never leave their hands. I haven't built that yet, but a closed API wouldn't offer it at all.
Clear rules. Apache 2.0 means I can use, change and share the project without worrying about custom terms.

I also tested more than one Gemma 4 size on the same photos. [Edit this to match what you really tested, or delete it.] Trying different sizes is easy when the models are open.

ThankYou!

Building Conversation Repairer for Aishwarya: Grounded Relationship Memory with Gemma

Daksh Lalwani — Sun, 04 Oct 2026 23:34:12 +0000

My friend Aishwarya often runs into a tough communication pattern. When tensions or awkward moments happen in a chat, she swings between two extremes: either she feels too kind and shy to state what she needs, or she swings the other way and sounds completely nonchalant and detached.

Both reactions cause confusion. People misread her silence as indifference, or her detachment as rudeness, even when her actual intention was simply to avoid conflict. When we talked about it, she mentioned that she often forgets past commitments or mutual preferences agreed upon weeks earlier in long chat threads. When an argument flares up, she has no quick way to recall what was actually said.

I built Conversation Repairer for her. It takes an exported WhatsApp conversation (.txt), extracts relationship context backed by exact quotes, stores everything strictly in the browser, and helps draft grounded responses when a chat gets tense.

## What I Built

Conversation Repairer is a full-stack tool that turns chat logs into a searchable relationship memory dashboard.
When you paste a tense message exchange into the app, it does not invent an arbitrary apology. Instead, it retrieves relevant past promises, recurring patterns, and communication preferences from your history. Then it suggests three distinct response options:

Soft: Gentle, acknowledging emotions without being overly apologetic.
Casual: Low-friction and conversational, de-escalating tension without drama.
Direct: Clear and honest, setting boundaries without sounding cold. It also highlights things to avoid saying and flags honest uncertainties about the situation.

## Demo

Live Demo: [https://conversation-repairer.onrender.com/]
Video Walkthrough: [https://drive.google.com/file/d/14azZci_Y4yMJE3f4lf1mUWXGQflvWv7p/view?usp=drive_link]

## Code

GitHub Repository: [https://github.com/Daks9h/conversation-repairer]

Tip for testing: If you do not have a WhatsApp export handy, clone the repo and upload samples/ios_sample.txt. It contains a realistic synthetic conversation between Kabir and Ananya covering canceled plans, late shows, and texting preferences.

## How I Built It

The core idea is simple: keep the server stateless, store personal memories only in the user's browser, and force the model to prove its claims with exact quotes.

WhatsApp Export (.txt)
│
▼
┌──────────────────┐
│ Browser Parser │ (Runs 100% in browser; strips bidi unicode)
└─────────┬────────┘
│
▼
┌──────────────────┐
│ Message Chunker │ (Recent ~1,500 messages, 120-msg chunks)
└─────────┬────────┘
│
▼
┌──────────────────┐
│ Gemma Extraction │ (Extracts memories with exact quotes)
└─────────┬────────┘
│
▼
┌──────────────────┐
│ Quote Check Code │ (Drops memory if quote is not in chunk)
└─────────┬────────┘
│
▼
┌──────────────────┐
│ LocalStorage │ (cr:memories stored strictly in browser)
└─────────┬────────┘
│
Tense chat snippet
│
▼
┌──────────────────┐
│ Keyword Retrieve │ (Scores overlap, category weight & recency)
└─────────┬────────┘
│
▼
┌──────────────────┐
│ Gemma Repair │ (Analyzes conflict + retrieved evidence)
└─────────┬────────┘
│
▼
3 Response Options: Soft, Casual, Direct

I built and iterated on this application using AI coding assistants (Google Antigravity) for scaffold generation, refactoring, and test runners, while Google Gemma 4 powers the extraction and repair intelligence of the live product. I designed the architecture, quote verification engine, and retrieval scoring, and validated the pipeline across synthetic test cases.

## Why Does Open Innovation Matter?

Personal conversations are deeply private. If you build communication tools using closed proprietary APIs, users are locked into third-party cloud platforms with no say over where their personal relationship history travels.

Because Gemma is an open-weight model family, Conversation Repairer is not trapped inside a single vendor's walled garden. Anyone who wants complete privacy can run the entire application offline by setting LLM_PROVIDER=ollama in their .env file and running gemma3:4b on their own computer. No chat text ever needs to leave their machine.

To be honest about the live deployment: the public demo on Render connects to Google's hosted Gemma API (gemma-4-26b-a4b-it) for inference, meaning text chunks travel over HTTPS to Google during analysis requests. However, the server remains completely stateless, stores nothing on disk, and saves all memories in local browser storage. Open weights make it possible for anyone to take the exact same code, run it locally, and have total data isolation.

What Aishwarya Said

I sent the working deployment to Aishwarya to test on her own chats.

Her immediate reaction was honest and funny. She laughed and told me she wants to send the link directly to people who struggle with communication skills. She noted that she runs into this problem with people around her all the time, and having a tool that grounds replies in what was actually agreed upon is a relief. For her, seeing past preferences lined up side by side with the three response styles gave her an easy way to reply without spiraling into over-apologizing or shutting down.

Privacy Note

Because personal chats contain sensitive information:

The server stores zero logs, zero conversation text, and zero user data.
All memories and sender names stay inside your browser localStorage.
If you prefer total isolation from cloud APIs, you can run Conversation Repairer offline by setting LLM_PROVIDER=ollama in your .env file and running gemma3:4b locally.