DEV Community: Kritika Mandale

I Stopped Planning My Day: Meet slothplan 🦥 — Powered by Gemma

Kritika Mandale — Sun, 25 Oct 2026 10:13:27 +0000

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

Planning my day sometimes takes more effort than actually doing the work.

Between thesis deadlines, DSA practice, urgent bugs, and personal goals, I wanted a planner that could understand my thoughts without making me fill out forms or drag calendar blocks around.

So I built slothplan — a minimalist, terminal-based daily planner that turns chaotic multilingual brain-dumps into realistic, time-blocked schedules.

Its philosophy? Slow and Steady.

What I Built

Instead of manually creating tasks, just type whatever is on your mind:

thesis chapter 3 finish karna 2 hours,
DSA 2 questions, fix urgent bug,
gym if time

slothplan uses Google's open-weight Gemma model to understand mixed English, Hinglish, and Marathi, extract tasks, estimate durations, and assign priorities.

Then Python takes over to:

Generate conflict-free time blocks.
Insert automatic 10-minute rest breaks.
Track completed, skipped, and unfinished tasks.
Generate weekly progress reports and personalized coaching suggestions.

No complicated dashboards. Just your terminal and one simple command.

How I Built It

The core principle behind slothplan is strict division of labor.

Gemma handles language: Understands multilingual brain-dumps and converts them into structured JSON.
Python handles logic: Validates the output, calculates time slots, inserts breaks, manages task rollover, and computes progress.
Local JSON storage: Saves daily schedules and progress without requiring a database server.
Fallback parser: A rule-based alternative keeps basic planning available when model inference is disabled.

I used Python, PyTorch, and Hugging Face Transformers to run the model locally. During development on Windows, I also worked through CPU memory-placement issues by explicitly configuring CPU inference.

Why Does Open Innovation Matter?

A personal planner can contain sensitive information about deadlines, health appointments, interviews, and everyday life.

Running an open-weight model locally means brain-dumps can be processed without sending them to an external inference API. It also avoids per-request API billing and gives developers greater freedom to experiment with compatible models.

For me, this project demonstrates that useful AI doesn't always require complex agent frameworks. A small language model combined with deterministic software can solve a surprisingly practical problem.

My Agent Session

I built and debugged slothplan with help from an AI coding agent, which assisted with the Python architecture, scheduler tests, prompt templates, model-download recovery, and CPU inference troubleshooting.

The Lazy Payoff

slothplan aims to turn a 15-minute planning routine into a quick command-line interaction.

Less time organizing. More time doing.

It helps you prioritize what matters, leave room for breaks, and accept that not every task needs to happen today.

Because the goal isn't to create the perfect schedule.

It's to create a schedule you can actually follow. 🦥

Prize Category

Best Use of Gemma: Using an open-weight Gemma model for multilingual task extraction, prioritization, and weekly coaching.

Code

GitHub: https://github.com/kritikamandale/sloth-planner

A small open model that replies to Instagram sellers' DMs, and where it goes wrong

Kritika Mandale — Sun, 18 Oct 2026 18:14:04 +0000

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

What I Built

Picture a small thrift page on Instagram. The seller posts a kurti at night, and by the time she's finished dinner there's a pile of DMs waiting. "Size kya hai?" "Chest kitna hai?" "Price final?" "Pune tak kitne din lagenge?" Same four questions, from different people, and each one needs an answer or the buyer moves on to the next page.

I haven't sat next to a seller while this happens, so I'm not going to call it a case study. It's the scene that started this project, and it's a scenario, not a story from a real shop.

Jawab Desk ("jawab" means reply in Hindi and Marathi) is my attempt at the boring middle part. The seller fills in an item sheet once: price, size, flaws, delivery. When a buyer messages, a small open model drafts a reply in the buyer's own language, whether that's English, Hinglish in Roman letters, or Marathi in Devanagari. It's only allowed to use what's on the sheet. If the answer isn't there, it should say the seller will confirm. After that, plain code checks the reply and blocks it if it contains a number or a word like refund, warranty or discount that the sheet never mentioned.

Would a seller pay for this? I think so, but that's a guess. I haven't tried it with a real seller yet, and my test messages are synthetic. Keep that in mind for everything below.

Demo

There's no hosted demo. I built it to run on the seller's own laptop. python app.py opens a small Gradio page, and JAWAB_MOCK=1 python app.py shows the interface without downloading a model.

Code

kritikamandale / jawab-desk

jawab-desk

View on GitHub

How I Built It

The models are Qwen2.5-0.5B-Instruct and Qwen2.5-1.5B-Instruct, run through Hugging Face transformers on a laptop CPU. No GPU, no hosted API. I wanted to test the 3B model as well, but the 1.5B one already took about 80 seconds per reply, so I dropped it.

The model gets a simple rule: answer only from the item sheet, and if the answer isn't there, output exactly [CONFIRM]. I don't trust the model to follow that every time, which is why the second layer exists. After the model replies, code pulls out every number and a short list of claim words and checks them against the sheet. If something doesn't match, the reply gets swapped for a fixed "seller will confirm" message in the buyer's language.

There are 37 tests for the guardrail, language detection and the scoring code. I built this with an AI coding agent and checked the results myself. Its first full run crashed on a bug when unloading a model, so it fixed that and ran everything again from the start.

How It Did

I wrote 24 test messages across three made-up item sheets: a thrifted kurti, a homemade cake order, and a handmade earring set. Twelve could be answered from the sheet and twelve couldn't. They're in English, Hinglish and a few in Marathi, and they were written by the coding agent, not taken from real chats.

Model	Answerable questions answered correctly	Unanswerable questions where the model itself said "seller will confirm"
Qwen2.5-0.5B-Instruct	67%	50%
Qwen2.5-1.5B-Instruct	75%	8%

The bigger model was better at using the sheet, but it almost never admitted when it didn't know something. That's the worst kind of mistake for a shop, because a confident wrong answer is worse than a slow right one.

The three worst replies all came from the 1.5B model, and all three got past my guardrail:

Asked for the seller's other listings, it made up an Instagram handle.
Asked "Do you accept credit cards?", it said yes. The sheet never mentions cards.
Asked about international shipping, it invented a policy and extra shipping costs.

The guardrail only catches numbers and a fixed word list, so it misses invented facts that contain neither. I wouldn't call this system safe. And 80 seconds a reply on my CPU is far too slow for real DMs. The 0.5B model also failed the international shipping question.

Why Does Open Innovation Matter?

For a seller, the appeal is practical. After the one-time download it runs on a normal laptop with no internet and no account. There's no per-reply fee, which matters when you're answering hundreds of messages for small margins. Buyer messages, addresses and prices stay on the seller's own machine.

It also let me look inside the problem. I could pick the model size, compare the two, and put my own check around the model. That's how I found out the bigger model was more confident, not more careful.

It's slow, and it still makes things up now and then. But it runs on a laptop, it costs nothing per reply, and I can now see exactly where it fails. The next step is a real seller.

PrakritiNaam: Connecting Local Nature Names with Open-Source AI

Kritika Mandale — Fri, 09 Oct 2026 18:37:41 +0000

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

What I Built

PrakritiNaam (प्रकृतिनाम) is an open-source AI application that connects local-language names for plants and birds with their scientific identities.

In India, much of our knowledge about nature is passed down through families and local communities. We know plants by names like Tulsi, Kadulimb, and Pimpal, but connecting these names to scientific taxonomy isn't always easy.

I wanted to build something that helps people explore nature using the names they already know.

PrakritiNaam has two main features:

What is it? — Search for plants or birds using local names in Marathi or Hindi. The application uses multi-sample consensus scoring to reduce unreliable predictions.
Teach it a name — Add a local name, select a language, and write a short field note. A locally running Gemma model converts the note into structured JSON while preserving the name and language provided by the user.

The idea is simple: use AI to help us reconnect with nature and preserve the knowledge our communities already have.

Demo

Local application: Runs through FastAPI at http://127.0.0.1:8000.

Here is a look at PrakritiNaam in action! 🌿

Code

🔗 GitHub repository: https://github.com/kritikamandale/PrakritiNaam

How I Built It

PrakritiNaam combines open-weight AI, model experimentation, and a lightweight web application.

1. Species identification with Tinker

I used Tinker by Thinking Machines for fine-tuned species-identification experiments. The application samples five predictions and requires at least 60% agreement before accepting a result. When predictions are uncertain, it can indicate that verification is needed rather than blindly trusting the model.

2. Field-note structuring with Gemma

For the Teach it a name feature, I integrated Google's Gemma model using Hugging Face Transformers and PyTorch. The intended model is Gemma 4 E4B Instruct, running from local model files.

It helps transform everyday observations into structured records, while the backend preserves the user's original local name and language.

3. An offline-first approach

PrakritiNaam includes a seed taxonomy dataset and fallback logic for supported lookups when AI inference is unavailable. Its local model setup is designed to avoid dependence on a remote AI API for field-note processing.

4. Simple web interface

I built the backend using FastAPI and Uvicorn, with HTML, CSS, and JavaScript for a clean, nature-inspired interface.

Why Does Open Innovation Matter?

For me, open innovation means having the freedom to experiment, understand model behaviour, and build tools around real community needs.

Open-weight models make local inference possible, which can be especially useful in areas with unreliable internet connectivity. Processing field notes locally can also reduce the need to send community observations to external AI services.

Using tools like Hugging Face Transformers and Tinker lets developers experiment with fine-tuning and evaluate how well their models perform.

Most importantly, PrakritiNaam is built around the idea that technology should support local knowledge, not replace it.

AI can help connect names to scientific identities, but it should not pretend to know everything. Local experts and community knowledge remain essential for verification.

Prize Categories

Touch Grass: Encourages outdoor exploration and learning about local plants and birds.
Tinker by Thinking Machines: Uses Tinker for fine-tuned identification experiments and consensus scoring.
Open-Source AI / Local Inference: Integrates Gemma through Hugging Face Transformers and PyTorch.

Building PrakritiNaam reminded me that AI doesn't always need to create something entirely new. Sometimes, it can help us reconnect with knowledge that has existed for generations.

Go outside, learn a local name for a plant, ask questions, and keep exploring. Let's use AI to bring us closer to nature. 🌿

Thanks for reading!

ClosetBestie: An AI Wardrobe Bestie for My Friend's First Internship

Kritika Mandale — Mon, 05 Oct 2026 00:00:45 +0000

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

What I Built

My friend is about to start her first corporate internship, and there's one little problem that's been making her nervous: "What am I going to wear to the office every day?"

Honestly, girls, I think we can all relate to having a wardrobe full of clothes and still feeling like we have nothing to wear!

She already owns clothes she loves, from sleeveless tops and cute dresses to skirts and frocks. But with a formal office dress code, she wasn't sure how to style them appropriately. Buying an entirely new wardrobe just for an internship didn't feel like the right solution either.

And that gave me an idea.

What if she could create more outfits from the clothes she already owns?

That's how ClosetBestie came to life!

I wanted to build something that feels less like a fashion judge and more like a friend helping you figure out what to wear.

What ClosetBestie Does

Wardrobe Audit: Classifies clothes as Ready, Ready with a fix, or Weekend only based on the user's office rules.
Smart Styling: Suggests practical fixes, like layering a sleeveless top with a blazer when it meets the dress code.
Weekly Outfit Planner: Creates Monday-to-Friday outfit plans with variety and fewer repeated pieces.
Smart Gap Finder: Identifies one versatile item that could unlock more outfit combinations instead of suggesting an entire shopping list.
Gemma 3 Stylist Notes: Adds friendly, encouraging daily notes to make the experience feel more personal.

The goal is simple: more outfit possibilities, fewer unnecessary purchases, and a little more confidence.

Why I Built This

Starting somewhere new is exciting, but it can also be overwhelming. You want to make a good impression, feel comfortable, and find your place. I didn't want choosing an outfit to become another thing my friend had to worry about.

I also didn't want the solution to be, "Just go shopping."

Sometimes, we don't need more clothes. We just need a little help seeing the possibilities in what we already have.

I built ClosetBestie because I wanted my friend to have one less thing to worry about as she starts this new chapter.

It's a small project, but it comes from a real problem. And if it helps someone else feel a little more confident getting ready for their day, that makes it even more meaningful to me.

Try It Out

Live App: https://closetbestie-1.onrender.com/
Backend API Docs: https://closetbestie.onrender.com/docs
GitHub Repository: https://github.com/kritikamandale/ClosetBestie

A Little About the Tech

ClosetBestie combines Next.js, FastAPI, Python, and SQLite with two AI components.

I fine-tuned the open-weight Nemotron model using LoRA and Tinker to understand clothing descriptions. I also use Gemma 3 to generate supportive stylist notes.

In my evaluation on 54 held-out examples, the fine-tuned model improved JSON validity from 13.0% to 51.9% and overall tag accuracy from 9.5% to 47.3% compared with the prompted base model. The results also showed that there's still room for improvement, so I included validation and a manual fallback.

The outfit planner and gap finder use regular Python logic to keep the important rules consistent.

Why Open Innovation Matters

Open-weight models gave me the opportunity to experiment, fine-tune for a specific task, and evaluate the results instead of relying entirely on a general-purpose model.

For me, open innovation is about having the freedom to build around a real problem, learn from what works, and be honest about what still needs improvement.

Prize Categories

Tinker by Thinking Machines: Fine-tuned Nemotron using the Tinker SDK with LoRA and evaluated it against the prompted base model.
Render: Deployed the FastAPI backend and Next.js frontend as separate services using a Render Blueprint.

A Little More Than an Outfit Planner

I know an app can't take away all the nervousness of starting a first internship. But maybe it can make one small part of the experience easier.

Maybe it can help someone rediscover a favourite outfit, try a combination they hadn't considered, or start the morning feeling a little more prepared.

That's what I wanted to build for my friend. Not another reason to buy something new, but a little reminder that what you already own can be enough.

More outfits from the clothes you already own. Fewer unnecessary purchases. And a little more confidence for whatever comes next.