DEV Community: Anjan Kumar Mahto

I let Gemma pick my top 3 tasks, and the rest of the list can wait

Anjan Kumar Mahto — Mon, 26 Oct 2026 05:58:27 +0000

My to-do list is not a plan. It is a museum of things I felt guilty about once.

So for Hacktoberfest Week 3 ("Slow and Steady"), I built the smallest thing that fixes
that: sloth-triage, a ~70-line Bun CLI that hands your task list to an open-weight
model and asks the only question that matters — what are three things actually worth
doing today? Everything else is explicitly allowed to wait.

$ bun run index.js tasks.txt

🦥 sloth-triage (gemma4:cloud) read 9 tasks and chose 3

1. Finish the quarterly report — due tomorrow at 9am.
2. Renew the domain — it expires Friday.
3. Reply to the landlord — a leaking tap gets worse.

Skip the conference recording and the photo library. The downloads folder can wait forever.

That is the whole product. No accounts, no dashboard, no streaks, no "productivity
system". It reads a text file, makes one request to a model on my machine, and prints
a short plan. Then it stops.

The build

There is nothing to install:

{
  "name": "sloth-triage",
  "type": "module",
  "scripts": { "start": "bun run index.js tasks.txt" }
}

The core is one prompt and one fetch to an OpenAI-compatible endpoint:

const prompt = `You are a very lazy but sensible assistant. Below is the user's task list.

Pick the ${top} tasks that genuinely deserve attention today. Prefer deadlines and things
that get worse if ignored. Then write a short "lazy plan": order the tasks, one line each,
and say what can be deliberately skipped or deferred. Be calm and brief.

Tasks:
${tasks.map((task) => `- ${task}`).join("\n")}`;

const res = await fetch(`${baseUrl}/chat/completions`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model,
    messages: [{ role: "user", content: prompt }],
    temperature: 0.3,
  }),
});

SLOTH_MODEL and SLOTH_BASE_URL are the only configuration. The default is Ollama on
127.0.0.1:11434, running Gemma. Lines can be plain text or - [ ] checkboxes; --top=N
changes how many survivors you get.

Why open matters here

A task list is one of the most personal files on a laptop. It contains health
appointments, money problems, names of people I owe replies to. Sending that to a closed
API so it can rank nine bullets is a bad trade.

With an open-weight model served by Ollama, the list stays on the machine:

No account and no API key. The tool works the same on a plane.
No meter running. A 1B model answering one short prompt costs effectively nothing.
The model is a setting, not a vendor. Swap Gemma for Llama or Qwen with one env var, and the prompt is right there in the file if you want to change how it thinks.
The whole thing is auditable. Two files and no dependencies. You can read every line before it reads your diary.

That last point is the real one. "Open source AI" is not just a license on weights. It is
being able to see the prompt, see the request, and know there is no hidden second call.
A closed product cannot offer that, no matter how good its summary is.

What I would fix next

Small models sometimes confuse "urgent" with "loud". The prompt asks for reasons so the bad calls are at least visible.
It does not know my calendar. A real version would pass in the next two days of events.
I tested with Gemma through Ollama; the code expects any local OpenAI-compatible server.

The project is deliberately boring: one file, one prompt, one output. That is the point.
A tool that helps you do less should not itself become another thing to maintain.

Repo: https://github.com/ItzmeJan/sloth-triage

Built for the Hacktoberfest Open-Source AI Challenge: Week 3.

SlothLog: one-tap attendance that writes its own slow recap

Anjan Kumar Mahto — Mon, 26 Oct 2026 05:14:18 +0000

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

Project: github.com/ItzmeJan/slothlog

What I Built

SlothLog is a tiny attendance app for people who hate attendance apps.

You add a name, tap once to check in, and tap once to check out. There is no account, no dashboard to configure, and no spreadsheet to keep alive. At the end of the week, an open-weight model reads the log and writes two calm sentences: one warm observation and one small suggestion for being lazier tomorrow.

The effort it saves is small but real: no paper sheet, no formulas, no "what time did you get in?" messages. The app remembers so you don't have to.

Demo

Run it locally in two commands:

bun start
# open http://localhost:3000

Optional sample data:

bun run seed

The demo uses gemma4:cloud through Ollama. The app also works with a local open-weight model; the UI labels which one it used and whether the data left the machine.

Code

Repository: ItzmeJan/slothlog

The whole app is three small JavaScript files and zero runtime dependencies:

server.js — Bun.serve + bun:sqlite + one Ollama call
public/index.html — one page, vanilla JS, no build step
seed.js — optional demo data

MIT licensed.

How I Built It

Bun runs the server and the SQLite database through the built-in Bun.serve and bun:sqlite.
Vanilla JavaScript handles the one-page UI. No framework, no bundler.
Ollama receives a compact seven-day attendance summary and returns the recap. The app picks an installed open-weight model, or accepts OLLAMA_MODEL.
Graceful fallback: if Ollama is not running, a deterministic recap keeps the app useful instead of showing an error.

The prompt asks for exactly two sentences, names the most consistent person, includes one real number, and suggests one tiny lazy action. It is intentionally short: attendance data is small, and the recap should be smaller.

Why Does Open Innovation Matter?

Attendance is personal and boring. A closed SaaS would want an account, a subscription, and a copy of everyone's schedule just to render a table. SlothLog keeps its data in a local SQLite file and lets the owner choose the model: a tiny local one for privacy and offline use, or a larger hosted open-weight model when quality matters more.

That choice is the point. The AI is not a rented feature bolted onto a CRUD app. It is the part that turns a dry log into something a human would actually read, and it runs on infrastructure the owner controls.

The Lazy Payoff

Even in the demo data, the recap took one click and pointed at the person with six visits while I was still deciding whether to open a spreadsheet. That is the entire product: a little less admin, a little more sloth.

Prize Categories

Best Use of Gemma — the demo runs through Ollama with a Gemma model.

Hello

Anjan Kumar Mahto — Mon, 19 Oct 2026 17:02:36 +0000