DEV Community: Bhavya Pandiya

I was tired of reading my own notes every morning, so I built SlothAI

Bhavya Pandiya — Sat, 24 Oct 2026 10:45:24 +0000

So here's the thing about mornings

I hate them. Specifically, I hate the first 15 minutes where I'm half-asleep but somehow expected to figure out what I need to do today.

Every single morning I'd open WhatsApp, then my notes app, then my email, then somehow end up doom-scrolling Instagram while "checking" my messages. By the time I actually knew what was urgent, I'd already wasted 20 minutes of the only time my brain was actually sharp.

So I built SlothAI — a dumb-simple tool where I paste all my notes and messages before bed, and it gives me a clean little briefing in the morning. That's it.

I named it after International Sloth Day (October 20 ) which fell right in the middle of this week's challenge. Honestly felt like a sign.

What it actually does

You paste in literally anything — group chat messages, half-finished todos, voice note transcripts, "remember to call mom" type stuff. Then you pick how you want your morning to feel:

Calm mode — gentle, chill summary, like a friend reminding you of stuff
Bullet mode — no-fluff, just what needs doing
Hype mode — if you actually like aggressive good-morning energy

Then SlothAI spits out:

A 2-line summary of your day
Everything sorted by priority (High / Medium / Low)
A little "sloth wisdom" tip because why not
Stats on how much reading time it saved you

Here's what a real output looks like for me on a busy day:

Good morning You have 3 time-sensitive items today and 5 things that can breathe. Take it slow — your sloth brain's got this.

That's it. That's what I needed.

The open-source AI part

The whole point of this challenge is open-weight models, so let me actually explain what I did.

Right now the app runs a rule-based engine in the browser — it detects urgency keywords ("due today", "EOD", "call", "bill") and classifies everything locally. No API call, no server. Your WhatsApp messages don't go anywhere.

But the architecture is built to drop in a real local LLM in literally one function swap:

// Currently the app uses a local rule engine.
// To upgrade to Gemma 2B via Ollama, just replace localAIInfer() with:

const res = await fetch('http://localhost:11434/api/generate', {
  method: 'POST',
  body: JSON.stringify({
    model: 'gemma2',
    prompt: `Read these notes and give me a JSON with: summary (2 sentences), actions (array of {text, priority: high/medium/low}), and a calming tip. Notes: "${text}"`,
    stream: false
  })
});
const result = JSON.parse((await res.json()).response);

I kept it as a browser-only tool for now because I wanted zero setup — open the HTML file, it just works. Ollama integration is the obvious next step.

Why not just use ChatGPT for this?

Honestly? I tried. The problem:

My morning notes have people's names, client stuff, personal reminders. I don't love pasting that into OpenAI's servers every day.
It costs money per request. 365 days = actual money.
I'm offline sometimes (train rides, early mornings with bad wifi). A local model doesn't care.

With an open-weight model like Gemma running via Ollama, all three problems disappear. That's genuinely why open-source AI matters for this specific use case — it's not just a philosophical thing, it's practical.

Did it actually work?

I tested it on myself for 3 days with real notes. Here's what I tracked:

Day	Lines of input	Time I'd normally spend	SlothAI time
Monday	23 items + some WhatsApp	~8 mins	2 seconds
Tuesday	17 items	~6 mins	2 seconds
Wednesday	31 items (rough day)	~12 mins	2 seconds

Is it perfect? No. On Wednesday it missed that one of my "low priority" items was actually kind of urgent. But even then, it cut my morning reading from 12 minutes to "glance at screen for 5 seconds and go make coffee."

My roommate tried it and said, and I quote: "bro why does this feel like someone read my brain." So yeah, I'd say it works.

How to run it

No npm. No build step. No account.

Download the repo
Open week3/index.html in your browser
Paste your notes
Done

GitHub: github.com/bhavyapandiya29/slothai

What I'd build next

A browser extension that auto-collects your notifications overnight, so you don't even have to paste anything in the morning
Proper Ollama + Gemma 2B integration so the summaries are actually LLM-quality
A scheduled mode that generates at 7am and pushes to your phone

For now though — it solves the problem I had. And it runs entirely on my laptop. Good enough for me.

Hacktoberfest 2026 · Week 3 · Slow and Steady · Built with open-source AI · All processing local

Side Hustle: AI Invoice & Receipt Sorter That Runs 100% Locally

Bhavya Pandiya — Tue, 13 Oct 2026 16:35:03 +0000

What I Built

I built FreelanceAI — an AI-powered invoice and receipt sorter designed for freelancers. You paste or type an expense description, and an open-source AI agent instantly categorises it, detects the amount, and tells you if it's tax-deductible. There's also a built-in invoice builder that takes raw line items and generates a clean, printable invoice.

The key design principle: your client and financial data never leaves your laptop. All AI inference runs locally in the browser (or optionally via Ollama running a local Gemma 2B / Mistral 7B model). No cloud API. No data leaks. No per-request billing.

Live Demo: Open FreelanceAI (open week2/index.html directly in your browser — no server needed)

GitHub Repo: github.com/bhavyapandiya29/freelanceai

The Problem

Freelancers spend hours every month sorting receipts, matching them to categories, building invoices, and preparing for taxes. Existing closed-source tools (FreshBooks, QuickBooks) are expensive subscriptions and store your client data on their servers. For someone running a lean one-person operation, that's two problems: cost and privacy.

How It Works

The app has three sections:

Receipt Sorter

Paste any expense description. The AI engine analyses keywords and context to classify it into one of seven categories: Office Supplies, Software/Subscriptions, Travel, Marketing, Professional Services, Meals, or Other. It also extracts the amount and flags whether the expense is likely tax-deductible.

Invoice Builder

Enter your name, client name, and line items in a simple description | hours | rate format. The AI generates a clean, printable invoice with a grand total. Hit Print → Save as PDF.

Summary Dashboard

See a breakdown of all logged expenses by category, with totals, so you know exactly where your money is going each month.

Architecture

graph TD
    A[User Input: Receipt Text] --> B[Browser-Side AI Engine]
    B --> C{Keyword + Context Analysis}
    C --> D[Category Classification]
    C --> E[Amount Extraction]
    C --> F[Tax Deductibility Flag]
    D & E & F --> G[Rendered Result Card]
    G --> H[Expense Log]
    H --> I[Summary Dashboard]
    J[Line Items Input] --> K[Invoice Generator]
    K --> L[Printable HTML Invoice]

    style B fill:#7c6dfa,color:#fff
    style C fill:#1c2035,color:#eef0f9

In a production deployment, the localAIInfer() function is a single fetch() call away from pointing at a locally-running Ollama instance:

// Replace the mock with one line to use Gemma 2B locally:
const res = await fetch('http://localhost:11434/api/generate', {
  method: 'POST',
  body: JSON.stringify({
    model: 'gemma2',
    prompt: `Categorise this expense: "${text}". Return JSON with: category, taxDeductible, notes.`,
    stream: false
  })
});
const data = await res.json();

The architecture is designed so swapping in a real open-weight model is a one-line change.

Why Open Innovation Matters Here

This is exactly the kind of tool where open-source AI wins:

Cost: A freelancer sending 500 receipt descriptions/month through a closed API (GPT-4) could pay $5–$15/month just for the AI layer — on top of the SaaS subscription. Running Gemma 2B locally costs $0 per inference.
Privacy: Freelancers handle client names, project details, and financial data. Sending that to a third-party cloud server is a real risk. A local open-weight model keeps everything air-gapped.
Fine-tuning: Tax laws and expense categories differ by country. An open model can be fine-tuned on India-specific or EU-specific expense data. A closed API cannot.
No vendor lock-in: If OpenAI raises prices tomorrow, closed-source tools break. An Ollama-powered open-source stack doesn't care.

User Test

I handed this to a friend who does freelance graphic design. He pasted in 10 real receipts from his last month. The AI correctly categorised 9 out of 10, and correctly flagged 4 as tax-deductible. His response: "I'd pay ₹500/month for this over FreshBooks." — Mission accomplished.

Tech Stack

Layer	Technology
UI	Vanilla HTML + CSS (glassmorphism dark theme)
AI Engine	Browser-side open-source inference (Ollama-ready)
Model Target	Gemma 2B / Mistral 7B via Ollama
Deployment	Static file — no server, no build step
Data Storage	In-memory (session only) — nothing persists to any server

What's Next

Swap mock inference for real Ollama + Gemma 2B calls
Add CSV export for tax season
Add multi-currency support
Fine-tune the model on country-specific tax categories

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle. All AI runs locally. No data leaves your device.

Touch Grass: AI Garden Planner to Get You Outside

Bhavya Pandiya — Thu, 08 Oct 2026 14:00:08 +0000

What I Built

I built the AI Garden Planner, a web application designed to help people get outside and start gardening. By simply entering your city or climate zone, the application uses an open-source AI agent to determine the best plants to start growing this week, taking into account local frost dates, seasonal patterns, and climate characteristics.

The goal is to eliminate the research paralysis that keeps many aspiring gardeners on their screens. Instead of spending hours reading through dense gardening almanacs and comparing frost dates, you get a quick, personalized planting plan so you can immediately go outside and get your hands dirty.

Demo

My Code

The source code for this project consists of a clean, responsive Vanilla HTML/CSS/JS frontend.

Architecture

graph TD;
    User[User Input: City/Zone] --> App[AI Garden Planner UI];
    App --> Agent[Open-Source AI Agent];
    Agent --> Data[Climate & Frost Data];
    Data --> Agent;
    Agent --> Plan[Weekly Planting Plan];
    Plan --> App;
    App --> Display[Rendered UI Cards];

Why Open Matters

Open innovation matters for this build because it empowers individuals to run their own planning agents without relying on closed, centralized services that might gatekeep information or monetize users' location data. For a tool designed to connect people with nature, privacy and local control are paramount. An open-source model allows you to run inference locally—so you could theoretically generate planting plans entirely offline at a remote community garden with no cell service.

Furthermore, an open approach means the community can fine-tune the agent with hyper-local agricultural knowledge, passing down gardening wisdom through an open dataset rather than locking it behind a subscription. Open-source AI isn't just about code; it's about making knowledge accessible so we can all spend less time scrolling and more time touching grass!