I Was Reading 150 Messages Every Morning, So I Built a Sloth to Do It For Me

Bug Fixer — Thu, 22 Oct 2026 07:46:32 +0000

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

What I Built

I wake up, I unlock my phone, and before I've had tea I'm already behind.

Last night my family group, my project channel and my inbox produced about 150 messages between them. Most of it was harmless noise — goodnights, a menu debate, cricket highlights on loop. Exactly a couple of those messages actually needed me. One of them was buried somewhere in the middle of the scroll, and if I skimmed too fast, I would miss it entirely.

That is the problem Lazy Morning Brief exists to delete.

Lazy Morning Brief: Wake up. Read two lines. Know everything.

You paste an overnight chat, drop in a WhatsApp export, or paste an inbox dump. It hands you back:

A brief of exactly two lines — the most important thing that happened, and where it landed. Not two paragraphs. Two lines. That limit is enforced in code, not just politely requested from the model.
Needs your reply — only the items where someone directly asked you a question, asked for a decision, or set you a deadline, with who asked.
Safe to ignore — a count and a one-line gist of everything else, so you can skip it without the guilt-scroll.
Honest stats — messages scanned, participants, and time saved, calculated transparently so you can check the maths yourself.

It works three ways in: paste any chat text, drag-and-drop a WhatsApp .txt export, or load one of the built-in fictional samples. There is a web UI and a CLI over the same pipeline, for whichever kind of morning you are having.

Who gets lazier? Me, first. But also anyone who is the reliable one in a family group, the approver in a work channel, or the person whose inbox fills up overnight while other time zones are awake. The effort saved is not just minutes — it is not starting the day with dread, and not missing the one ask that mattered because it arrived at 10:31 pm under a pile of biryani opinions.

Demo

Live demo: https://huggingface.co/spaces/waqarse16/lazy-morning-brief — a free static showcase of the real UI. Load a sample there and you'll see the exact brief Gemma produced for it in a genuine local run (details below).

Source code: https://github.com/waqarse16/lazy-morning-brief

Here is the walkthrough I use myself, with the bundled fictional family sample:

1. The overnight spiral. The sample is a real-shaped WhatsApp export: 40 messages from 5 senders, plus 2 system lines (the end-to-end encryption notice and the group-creation line) that the parser strips out before anything reaches the model. The family spends most of those 40 messages settling one Sunday lunch — 1 pm vs 2 pm, a compromise of arrive 1:30 with food by 2, biryani winning over pulao and karahi, who is bringing raita, dessert, and soft drinks, and where to park.

2. The buried ask. At 10:31 pm, in the middle of all that, Ayesha asks Ali — that's the reader in this sample — one important thing: Ammi's wheelchair ramp at her gate is broken, she cannot manage the steps, and Ali is the only one free to pick her up at 1 pm on Sunday. Please confirm tonight. Then the chat immediately moves on to cricket and goodnights, and by morning that ask is buried under all of it.

3. The brief. You drop the export in, press ☕ Give me my brief, and instead of re-reading the whole spiral you get the two lines, the one needs-reply item, and permission to ignore the rest.

This is what the brief looks like on that family sample:

Captured output — a real run of the CLI on the family sample, 2026-10-21, Gemma 3 1B running locally via Ollama on a 2-CPU sandbox with no GPU (36 seconds, unedited — full record in docs/sample-run-output.md in the repo):

Your brief
Ayesha is setting a specific time and location for lunch with friends, and needs confirmation from Ali regarding his car and transportation for her.

Needs your reply

Ali: Car, Sunday 1 pm, confirm.

Safe to ignore
39 messages — the model gist-ed them as the ramp/transport discussion (with one honest 1B-model slip: it is Ammi's ramp, not Ayesha's — I kept the output exactly as generated rather than tidying it up).

Stats: 40 messages scanned · 5 people · ~3m 10s of reading saved · model: gemma3:1b

A second captured run (project group, 24 messages) is in the same file: it nailed both load-bearing facts — deployment live, client deadline moved to Monday 9 am — and the one action item, approving the staging cleanup script.

The project ships with two other fictional samples so you can feel the shape on different noise: a project group at 24 messages, and an inbox dump at 9 messages. Same promise every time — two lines, what needs you, what does not.

A note on the hosted demo, honestly: the showcase above is a static page, so it cannot summarise new text — and I did not fake one that pretends to. Summarising is the one step that must happen on a machine you control, with your own Ollama instance (see How I Built It below), because that is the entire privacy design. What the showcase does show is real: the exact UI, and for each sample, the genuine output captured from an actual local run. The full, private experience is the local one — that is the point of the project.

Code

waqarse16 / lazy-morning-brief

Wake up. Read two lines. Know everything. A local, private morning brief for overnight chats — powered by open-weight Gemma via Ollama.

🦥 Lazy Morning Brief

Wake up. Read two lines. Know everything.

Last night your family group, your project channel and your inbox produced 150 messages. Exactly two of them needed you. Lazy Morning Brief finds those two — and lets you skip the other 148 with a clear conscience.

The problem

Group chats do not sleep when you do. A family group planning one Sunday lunch can generate 40+ messages about the time, the menu, and who got how many potatoes in their biryani — while the one message that actually needs you ("can you pick Ammi up at 1 pm? Please confirm tonight") scrolls away under cricket highlights and goodnights. Work chats and inboxes are the same: a deadline quietly moved at 11:25 pm, an approval only you can give, buried under newsletters.

Reading it all costs real time and a little dread. Skipping it costs missed asks…

View on GitHub

The repo includes the FastAPI app and CLI, the deterministic parser, the versioned prompt and output-contract code, the fictional samples, the test suite, plus a Dockerfile and render.yaml for deployment. Everything is MIT licensed.

How I Built It

Stack: Python 3.12 + FastAPI (with a stdlib fallback server if FastAPI is unavailable), vanilla HTML/CSS/JS on the front end, and Ollama for local inference. No build step, no heavy dependencies — the Ollama client itself is stdlib-only.

Model: Gemma 3, gemma3:1b, open-weight, running via Ollama on localhost. I chose it small on purpose. A 1B model runs on an ordinary laptop with no GPU, which is what makes "private, offline, free forever" real rather than a slogan. It is configurable via OLLAMA_MODEL — qwen2.5:1.5b and llama3.2:1b are documented alternatives in the repo if you want to trade speed for strength.

Three design choices did most of the work:

1. Parser before AI. WhatsApp Android format (12/10/2026, 9:41 pm - Name: msg), WhatsApp iOS format ([12/10/26, 9:41:05 pm] Name: msg), plain Name: message threads, and email dumps starting with From: are all parsed deterministically in plain Python — no AI involved. System lines (encryption notices, "X added Y", media placeholders, group housekeeping) are stripped and counted in code, never sent to the model. Counts and participants are also computed here. A small model needs clean input, and statistics should never be a model's guess.

2. Output contract enforced in code. The prompt in app/prompts.py demands a strict format, and summarizer.parse_model_output defensively parses whatever comes back and trims the brief to exactly two lines. If the model rambles, the product promise still holds — because code holds it, not hope.

3. Honest failure by design. If Ollama is not running, the UI, the API, and the CLI all return the same clear, structured error with the exact fix commands (ollama pull gemma3:1b, ollama serve). There is no extractive or keyword fallback quietly dressed up as AI. I would rather the tool say "I can't do this right now, here's how to fix it" than fake a summary.

Tests: the pytest suite — 19 tests, all passing with no model downloaded — covers both WhatsApp formats, system-line stripping, the stats, the prompt contract, model-output parsing with a mocked Ollama, and the API's health and offline error paths. That last part mattered to me: the failure path is a feature, so it gets tested like one.

Why Does Open Innovation Matter?

Because the input to this tool is the most private text in a person's life.

Family arguments and jokes. Work threads. An inbox. If I use a closed cloud summariser, I have to upload all of that to someone else's server, keep a subscription running, and trust a retention policy I cannot inspect. The service might be well-behaved. I just have no way to know — I only have their promise.

Lazy Morning Brief is architected the other way. The summariser is an open-weight model running on your own machine via Ollama. The only network call the app ever makes is to Ollama on localhost. No message leaves the machine. No API key. No subscription. It works on a plane and in a village with no signal.

That is the difference I keep coming back to: a closed API cannot honestly promise your chats never leave your machine, because by design they have to. Open weights plus local inference make "your chats never leave your machine" a fact about the system, not a line in a privacy policy. The weights are yours, the model costs nothing, and anyone can inspect it, swap it, and improve it.

A tool about doing less should be built on that kind of openness.

The Lazy Payoff

I did not want inflated numbers, so the maths is deliberately boring and shown on every result:

time saved = (messages × 5s) − 10s

Reading one chat message properly takes about 5 seconds. The brief takes about 10 seconds to read.

On the family sample: 40 messages × 5 seconds is 3m 20s of reading, minus the 10-second brief — 3m 10s saved in one morning. Do that every morning and it is about 19 hours a year handed back to you. That is the measured sample, not a projection about all your chats combined — your real groups will vary, and the app shows you its working either way.

But honestly, the minutes are not the main payoff. The missed ask is.

In that sample, Ali missing the Ammi pickup does not cost 5 seconds. It costs a scramble on Sunday, an elderly parent waiting at a broken ramp, and a family thread full of "did anyone tell Ali?" The brief costs 10 seconds and puts that ask on line two, with a name next to it in Needs your reply. Sloth, in this case, is just not doing the 40-message scroll — while still catching the one thing a good family member, colleague, or friend would not want to miss.

Slow and steady. Read two lines. Start the day like a person, not an inbox.

Prize Categories

I am submitting Lazy Morning Brief for:

Overall — this project is a direct build of an official Week 3 example idea: a local agent that reads your group chats overnight and hands you a two-line summary in the morning. I tried to build that idea properly — parser, contract, honest errors, tests — rather than as a demo-day shortcut.
Best Use of Gemma — Gemma 3 (gemma3:1b) is the primary summariser, run locally via Ollama, and the whole prompt and output-contract layer is tuned for it. The small size is a deliberate choice so it runs on an ordinary laptop with no GPU.

Built with Gemma 3, Ollama, Python and a genuine desire to never scroll a family group before breakfast again. Be a sloth. Read two lines. 🦥

I built an Apna Ghar calculator that starts from your salary — not the loan amount

Bug Fixer — Wed, 21 Oct 2026 07:00:01 +0000

Most Apna Ghar Scheme calculators I found start with the wrong question:

"How much loan do you want?"

In real life, banks don't start there. They start with your income.

A friend of mine earns around PKR 70,000–80,000 a month. He got PKR 4.5 million approved under the scheme. That only makes sense when you work backwards from salary — what installment can you actually carry, and what loan does that installment support over 10 years?

So I built a calculator that works that way.

Try it here: Apna Ghar Scheme Calculator — Calculate Loan on Your Salary

What it does

Salary mode for salaried people, and a separate Monthly Income mode for business / self-employed income
Optional other income if you have a second source
Big, clear tenure buttons — 5 / 10 / 15 / 20 years — so the change is actually visible when you tap them
An installment-share slider (default 60% of income) — change it and the max loan updates instantly
A property-price check: enter the house/flat price and it tells you if it fits within the scheme limit or is above it
For longer tenures, it also estimates the installment after year 10, when the fixed 5% period ends

Example

Salary: PKR 80,000
Installment share: 60% = PKR 48,000/month installment
Tenure: 10 years at the scheme's 5% fixed rate for the first 10 years
Result: PKR 4,525,505 max loan — around PKR 4.5 million

That matched my friend's real approval, which is why I kept the salary-first approach instead of copying the loan-amount-first calculators.

Honest caveats

This is an estimate tool, not a bank approval. Your bank will verify salary slips / income documents, credit history, age, and the property documents.
Rates and scheme rules can change — the calculator uses adjustable October 2026 indicative defaults (5% fixed for the first 10 years, then KIBOR-based). Always confirm the current terms with your bank / the official portal before applying.
A lower installment share is safer if you have other loans or high monthly expenses.

Why I built it this way

The existing top results are mostly loan-amount-first tools or slab tables. Useful, but they don't answer the first question most people actually have:

"On my salary, how much can I get?"

If you're in Pakistan and checking Apna Ghar, try entering your salary first and tell me in the comments — does the result match what your bank quoted you? That feedback will help me improve the calibration.

Built as part of Millionaire Mode's free financial tools: Car Finance Calculator, Loan vs Invest Calculator, and the Apna Ghar Calculator — all at millionaire-mode.com/financial-calculators/

DEV Community: Bug Fixer