DEV Community: Samrat

Chore Starter: AI does the preparation. I keep the final say.

Samrat — Sun, 25 Oct 2026 22:57:36 +0000

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

What I Built

Some tasks aren’t difficult. They’re just annoying to start.

Ask for a refund. Write an awkward message. Figure out how to tackle the pile on your desk. You know it needs doing, but opening a blank document feels like more work than the task deserves.

Chore Starter is a minimal AI personal assistant for that first bit of effort.

Give it the messy version:

“My headphones arrived with a cracked headband. Help me ask for a replacement without sounding rude.”

It prepares an editable email, message or practical plan, alongside a short checklist and the details you still need to supply. Missing information stays as a placeholder—not an invented order number or a promise the shop never made.

The important part: preparation is not permission.
Chore Starter can prepare everything, but copying, downloading or opening an email draft requires a separate preview and confirmation. It never sends email, makes purchases, submits forms or schedules things.

The interface is deliberately small: one task box, one prepared result, and a few clear next steps. Previously prepared tasks stay on your machine, so you can come back later.

A simple walkthrough:

Describe a chore, such as asking for a replacement.
Review the draft and fill in the missing details.
Click Copy draft or Open email draft.
Inspect the exact content in the confirmation dialog.
Cancel—or explicitly confirm.

Opening an email draft only hands it to your email app. You still review and send it yourself.

Code

MasterFloppa / Chore-Starter

A local AI assistant that prepares the chores you put off. Nothing leaves without your confirmation.

Chore Starter

Give it the task. Get the first draft. You stay in charge.

A minimal, local-first AI personal assistant for the chores you keep putting off. It prepares a useful draft and a small checklist from a plain-language task. Nothing is sent, submitted, purchased or scheduled automatically.

Built for the Hacktoberfest Open-Source AI Challenge, Week 3: Slow and Steady.

Status

Initial project scaffold. Application implementation follows this commit.

License

MIT

View on GitHub

Chore Starter uses a locally installed Ollama model. The default is gemma3:4b.

How I Built It

The stack is React + Vite, TypeScript + Hono, and Gemma 3 4B through Ollama.

There are two deliberately separate parts:
Preparation: Gemma turns the request into a structured response: the draft, a short checklist, and missing information. It has no tools, account credentials or ability to perform the chore. The response is validated before it becomes a saved task.

Permission: ordinary application code controls the next step. The model cannot approve its own output.

For each action, the server creates a short-lived confirmation tied to:

the task;
its current revision;
the specific action;
the exact content being reviewed.

Edit the draft, and the old approval stops working. Cancel it, and it cannot be used. Confirm once, and it cannot be replayed.

That matters more than a reassuring “Are you sure?” button. The server—not just the interface—enforces the boundary.

The available actions are intentionally modest:

Copy draft: copies the reviewed text.
Download task: downloads a Markdown file with the draft and checklist.
Open email draft: opens the chosen recipient, subject and body in your email app without sending it.

Tasks are stored locally. Model failures produce an explicit error rather than a pretend-success response.

The automated checks cover the important boundaries: missing confirmation, cancellation, expiry, changed drafts, repeated confirmation, stale edits, persistence and failed model calls.

Why Does Open Innovation Matter?

The task can stay where it started. A refund request, personal message or household chore may include information I don’t want to upload to another AI service. Gemma runs locally through Ollama; the app does not need a hosted AI API key.

A small model is enough for a small job. I’m not asking it to operate my computer. I’m asking it to turn rough context into a useful first draft. Keeping the scope narrow makes a locally running 4B model a practical choice.

The permission boundary is inspectable. Anyone can read the application code and see that the model’s output does not trigger a send, payment or background action.

The model is replaceable. An installed Ollama model can be selected in Settings. The app’s confirmation rules remain the same regardless of which model prepares the text.

Open weights provide the language layer. Open application code makes the limits visible.

The Lazy Payoff

The payoff is getting past the blank page.

Instead of thinking through tone, structure, missing details and the next step separately, you describe the task once and review something concrete.

It does not eliminate your judgment. It eliminates some of the preparation that makes small chores feel bigger than they are.

I’m not claiming a measured number of minutes saved yet. The intended trade is simple: less time getting ready to do the thing, while keeping control over actually doing it.

Prize Categories

Best Use of Gemma: Gemma 3 4B prepares the draft, checklist and missing-information prompts locally through Ollama.
Best Use of GitHub Copilot: GitHub Copilot was used as the coding agent to build the app and its automated checks.

ConfiDict: A Private AI Vocabulary Coach

Samrat — Sun, 18 Oct 2026 19:00:35 +0000

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

What I Built

I built ConfiDict, a local-first vocabulary trainer that helps learners concentrate on the words they understand least.

Most flashcard applications show an answer and ask the learner to decide whether they were correct. That self-assessment is subjective: an answer may be partially correct, use a valid synonym, or miss one important part of the meaning.

ConfiDict changes that workflow. The learner sees a word and explains its definition in their own words. A local open-weight Gemma model evaluates the response, identifies whether it is strong, correct, partial, or incorrect, and gives concise feedback.

Every word has a visible confidence score between 0 and 100. Each day, ConfiDict creates a five-card session from the learner’s 15 lowest-confidence words. Weaker words have a greater chance of appearing, but weighted selection prevents every session from repeating the exact same cards.

The intended users include:

IELTS, TOEFL, GRE, and other exam candidates
Adults improving their workplace vocabulary
Students learning subject-specific terminology
Tutors who want learners to practice a curated word list

A learner is not paying for another digital deck of cards. They are paying for focused practice, objective feedback, and less time wasted reviewing words they already know.

Code

The project is open source under the MIT License:

MasterFloppa / ConfiDict

Local-first AI vocabulary confidence trainer for Hacktoberfest 2026

ConfiDict

ConfiDict is a local-first vocabulary confidence trainer. Learners import the words they want to remember, define five words in their own language each day and receive semantic grading from an open-weight model that runs in the browser.

This project is being built for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle.

The copy-ready DEV submission draft is in docs/dev-submission.md.

The problem

Traditional flashcards usually ask learners to reveal an answer and grade themselves. That makes progress subjective and gives learners little help when their answer is close but incomplete.

ConfiDict uses open-source AI to compare the learner's free-text definition with the reference meaning. It then adjusts a transparent confidence score and prioritizes the words that need the most attention.

MVP scope

The first version deliberately supports one learning task:

See a word and explain its definition in your own words.

The MVP includes:

Individual and…

View on GitHub

Repository: github.com/MasterFloppa/ConfiDict

How I Built It

ConfiDict uses a deliberately small architecture:

React 19 and TypeScript for the responsive web interface
Vite for development and production builds
IndexedDB through Dexie for local persistence
Ollama with Gemma 4B for private semantic answer grading
Vitest for confidence-selection and import tests

Local-first storage

The MVP uses IndexedDB rather than a hosted SQL or document database.

The learner’s word list, definitions, confidence scores, daily sessions, and review history remain in their own browser. There are no accounts, database credentials, or backend storage costs.

The application stores only the information needed for learning:

Word
Reference definition
Confidence score
Number of attempts
Previous result
Local review history

Selecting the daily five

New words begin with a confidence score of 25.

For each daily session, ConfiDict:

Sorts the library from lowest to highest confidence
Creates a pool from the 15 weakest words
Selects five cards using weighted randomness
Gives lower-confidence cards a greater probability of selection

The confidence changes are intentionally transparent:
| Result | Confidence change |
| --- | ---: |
| Strong answer | +12 |
| Correct answer | +8 |
| Partially correct | -5 |
| Incorrect answer | -15 |

Gemma does not secretly choose review dates or directly manipulate scores. It returns a structured assessment, while deterministic application code applies the published confidence rules. The learner can also override an unfair AI assessment.

Local Gemma grading

The grading prompt sends Gemma:

The word
Its reference definition
The learner’s answer
A strict grading rubric

Gemma returns structured JSON containing the grade, a short explanation, and the important detail the learner captured or missed.

Running Gemma through Ollama keeps the inference pipeline under the learner’s control. No proprietary AI API receives the vocabulary list or answers, and there is no per-card inference bill.

Why Does Open Innovation Matter?

Open innovation is what makes ConfiDict’s side-hustle model practical.

A vocabulary product may grade thousands of short answers. With a closed API, every practice session creates a recurring inference cost. Those costs either reduce the product’s margin or force the learner into a more expensive subscription.

An open-weight model changes the economics:

Private: Personal vocabulary and answers can remain on the learner’s computer.
Affordable: Local inference removes per-answer API charges.
Replaceable: The model can be upgraded or exchanged without redesigning the learning system.
Customizable: Tutors and schools can change the rubric for a language, exam, or subject.
Self-hostable: Organizations can operate the complete grading pipeline themselves.

Open source also makes the product easier to trust. The confidence formula, selection algorithm, prompt, and storage model can all be inspected instead of being hidden behind a proprietary recommendation system.

Prize Categories

Best Use of Gemma
Best Use of GitHub Copilot

Go Window: the best time to go outside

Samrat — Sun, 11 Oct 2026 18:06:13 +0000

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

What I Built

I live in Hyderabad, and in October "should I go for a walk?" has a different answer depending on when you ask.

At 1 PM it feels like 35°C. At 7 AM, the hour every wellness app recommends, PM2.5 is sitting around 45 µg/m³. At 6 PM it's actually pleasant, and that's exactly when I'm in a meeting.

Weather apps answer "what's the weather?" None of them answer the question I actually have: "when, inside the hours I'm free, is it good enough to go outside?"

So I built Go Window.

You tell it when you're really free (say, weekdays 7:00–8:30 and 18:00–20:00). It looks three days ahead at open weather and air-quality forecasts, scores every hour against your limits, and gives you one answer: your next "go window". A local open-weight model (Gemma 3, running through Ollama on your laptop) explains each day in a sentence. A nudge reaches your phone when the window opens. Afterwards, one tap ("too hot", "air felt bad", "felt great") teaches it what those words mean to you.

What it does:

Plans around your real day. It never suggests 3 PM if you're not free at 3 PM.
Explains the misses. "07:00–08:30: PM2.5 47 µg/m³ (your limit 35)." If a clearly better slot sits just outside your free hours, it says so, in case you can move something.
Never a dead end. In a hot, smoggy city, sometimes nothing fits all your limits. Instead of an empty screen, it offers the closest slot, marked best available, with exactly what's over: "PM2.5 30 (your limit 25)". You choose how much give there is (strict, a little over, more flexible).
Check in by just saying it. Write "skipped it, got stuck in a meeting till 8" or "went to the lake but it got muggy" and Gemma turns it into structured feedback.
Phone alerts via ntfy: a morning digest, a nudge 10 minutes before the window, and a one-tap "how was it?" afterwards.
A park that fits the window, from OpenStreetMap, plus Add to calendar so the slot gets defended like a meeting.

The screen time is the point. The plan page is one card and three lines: ten seconds in the morning, one tap afterwards. Everything else happens outside.

Demo

 1. Plan page: the "next go window" card + "Next 3 days"

 2. A day opened: Gemma's note, the reasons other free slots don't work, the hour-by-hour strip

 3. A "best available" day (turn on "Sensitive" in Settings to see one in Hyderabad)

 4. My limits: the learning log

Code

MasterFloppa / Go-Window

Go Window 🌿

The best time to go outside, inside the hours you are actually free.

Go Window looks at the next 3 days of weather and air quality, keeps only the slots you said you are free, and tells you when to step outside. A local open-weight model (Gemma, through Ollama) explains the plan in plain words. Every time you tell it how a walk felt, it learns your personal heat, humidity, air and rain limits.

Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass.

What it does

Plans around your real day. You set free hours (e.g. Mon–Fri 07:00–08:30 and 18:00–20:00). It only suggests time inside them.
Never a dead end. If nothing fits all your limits (common in a hot, smoggy city), it offers the closest free slot within a tolerance you choose (Strict / Balanced / Relaxed), clearly marked with what is…

View on GitHub

With Ollama running and gemma3:4b pulled: npm install && npm start, then open http://127.0.0.1:8787.

How I Built It

flowchart LR
  UI[Browser UI - React] --> API[Local API - Node + Hono]
  API --> OM[Open-Meteo: weather + air quality]
  API --> OSM[OpenStreetMap: parks]
  API --> ENG[Scoring engine: every hour vs YOUR limits, inside free hours]
  ENG --> LLM[Ollama + Gemma 3 4B: narrate days, read check-ins]
  API --> LEARN[Learning: bounded limit changes + plain-English log]
  API --> NTFY[ntfy: scheduled phone alerts]

The model narrates; code decides. The app picks the good hours, the best window, the reason a slot fails and the park. Gemma gets one day's facts as short sentences and writes three lines: a headline, the why, and an idea. Every number it writes must appear in those facts; if one doesn't, it gets one retry, then that day falls back to template text.

Running a 4B model on a laptop CPU taught me four things:

Sentences beat JSON for small models. Given nested JSON, Gemma planned a walk for a day that was already over and turned the park's distance (walk_minutes: 3) into "walk for 3 minutes." One call per day, with facts written as sentences, fixed both.
Make the model quote you. Reading "muggy, and the smoke had me coughing", Gemma added too cold, which moved a limit by 7°C. Now every feeling needs a word-for-word quote from the note, and one check-in can only move a limit a little.
One job at a time. Parallel narrations timed each other out on Ollama, so now they queue and outdated ones are skipped.

Learning is lopsided on purpose: bad check-ins tighten a limit fast, good ones loosen it slowly, and a "best available" walk that felt fine pulls the limit toward what you handled. That mode came from my own first run: with "sensitive to air" on, Hyderabad never dropped below my 25 µg/m³ limit, so the app showed zero windows for three days. Now it offers the least-bad slot and says exactly what's over.

Also worth knowing:

Alerts are scheduled on the ntfy server, so they still arrive if the laptop sleeps, and they're replaced or cancelled when the forecast changes.
Open-Meteo counts forecast days from the UTC date, which emptied my third day just after midnight in India.

Stack: Node + Hono, React + Vite, Ollama with gemma3:4b, Open-Meteo, OpenStreetMap, ntfy.

Why Does Open Innovation Matter?

It runs on the laptop I already have. No CUDA here; Ollama runs Gemma 3 4B on the CPU at roughly 15 tokens per second, which works out to about 15 seconds to narrate a day. That would feel slow in a chat, but here it happens in the background while the page shows plain text, and it refreshes every 20 minutes.

My routine is private data. When I'm free, where I walk and how I felt add up to a detailed picture of someone's day. With a local model, none of that leaves the machine. The only things that go out are a location rounded to about 1 km (to Open-Meteo and OpenStreetMap) and the alert text (to an ntfy topic you can self-host).

Zero keys, zero cost. Open-Meteo, OpenStreetMap, ntfy and Ollama need no account and no API key. Anyone can clone it and run it tonight.

Open data stays the source of truth. The model can't make up a forecast, because it never produces one.

Prize Categories

Best Use of Gemma: Gemma 3 4B (open weights, running locally via Ollama) is the language layer. It narrates each day under a numeric grounding check, and turns free-text check-ins into quote-verified signals that drive the learning loop.
Best Use of GitHub Copilot: the app was built end to end with GitHub Copilot as a coding agent, from probing the data sources and building the scoring engine to tests, browser end-to-end runs and the UI redesign.

Cheomil: A Local AI Cooking Companion

Samrat — Sun, 04 Oct 2026 20:27:23 +0000

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

What I Built

I built Cheomil, a local AI cooking companion for a friend who wanted to know what they could cook with the ingredients already in their kitchen.

Unlike a generic recipe chatbot, Cheomil starts with a pantry containing actual quantities and units. My friend can ask “What can I make for lunch?” and receive suggestions with ingredient amounts and cooking steps.

After cooking, they review and confirm the quantities used before anything is deducted. Grocery purchases follow the same review-and-confirm process.

Chat supports follow-up questions, while New chat clears conversation memory without erasing the pantry. The goal is simple: help one person choose their next meal and keep track of what remains

DEMO

Code

MasterFloppa / Cheomil

Cheomil

Good food, already at home. A local-first cooking companion built for a friend who wants to turn the ingredients at home into meals, without losing track of what remains.

Run on Windows

Prerequisites: Node.js 24.12 or newer, Ollama, and the Gemma 3 4B model.

git clone https://github.com/MasterFloppa/Cheomil.git
Set-Location Cheomil
ollama pull gemma3:4b
npm start

Open http://127.0.0.1:3000. Ollama must be running at http://127.0.0.1:11434.

The production app has no npm runtime dependencies. npm install is only required for the optional Edge browser test.

The everyday loop

Enter the ingredients you have, including their quantities. Use g, ml, or pcs. Adding an existing ingredient tops up its stock.
Ask a question such as "What can I make for lunch?" The local model proposes recipes with pantry ingredient references, quantities, serving counts, and cooking steps.
Say "I cooked [dish name]" or…

View on GitHub

How I Built It

Cheomil uses Gemma 3 4B, an open-weight model served locally through Ollama. It interprets cooking requests, generates recipes, and identifies previously suggested dishes.

The application uses a native Node.js server, SQLite, and vanilla JavaScript, with no npm runtime dependencies.

The key design decision is separating AI suggestions from inventory changes. Application code validates ingredient references and quantities, and the person confirms every cooking or restocking action.

One revealing edge case was a recipe treating 2 grams of onion as a meaningful ingredient. I added ingredient-specific quantity checks and explicit rejection of invalid drafts. These safeguards improve reliability but do not replace human judgment or food-safety checks.

I used GitHub Copilot CLI for implementation, debugging, and regression coverage.

Why Does Open Innovation Matter?

After downloading the model, Cheomil runs without an internet connection or cloud AI API key. Pantry and conversation data stay on the local machine.

Local inference avoids per-request API charges, although it still uses the computer’s processing power, memory, and electricity. CPU inference can also be slower than a hosted service.

The model and prompts can be changed without tying the application to one cloud provider. Gemma is open-weight, not fully open-source, and its terms apply; Ollama supplies the open-source runtime.

For a personal kitchen companion, local control is part of the product—not just a technical choice

Prize Categories

Best Use of Gemma: Gemma 3 4B powers local cooking-request interpretation and pantry-grounded recipe generation.

Best Use of GitHub Copilot: GitHub Copilot CLI assisted with implementation, debugging, and automated regression coverage

New to the community

Samrat — Sun, 04 Oct 2026 13:02:08 +0000

Grittings everyone!