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

What I Built

SlothDigest is a ~200-line Python tool that does your morning reading for you. Overnight (via a single cron line), it:

1. Scans your folders for new files since the last run
2. Pulls new headlines from your RSS/Atom feeds
3. Hands the pile to a local open-weight model and asks for a two-line brief

You wake up, run cat digest.log, and know what happened. No feeds to scroll, no inbox triage — sloths move at their own pace, and so does this.

Demo

No deploy needed — it's a CLI that runs on your own machine. Here's the real session output from a test run against a mock downloads folder plus two live feeds:

• First run: collects 4 new files + 20 new headlines, produces the brief above
• Immediate rerun (dedup): Nothing new since the last run. The sloth rests.

That second line matters: it remembers what it has already reported, so a rerun never nags you with stale items. --dry-run mode prints the raw material without calling the model, so you can see exactly what it would read.

$ python3 slothdigest.py run

============================================================
SlothDigest — 2026-10-21 07:32 UTC
============================================================
Here's your lazy-person's morning brief:

1. New files were downloaded overnight, including a budget tracker and a
   hacktoberfest t-shirt idea, but nothing that seems critical.
2. Top 5 things to look at:
  - What nine job and property sites were advertising in mid-October 2026
  - Windows Robocopy Command: Mirror a Folder Without Deleting the Wrong Files
  - Anthropic tells investors quarterly revenue up nearly 50% to $16.8bn ahead of IPO
  - Chirp Pong
  - eMudhra Intermediate CA Compromise
3. Sloth verdict: Ignore the hacktoberfest design and just grab a coffee.

Saved to digest.log. Now go back to bed.

Code

hey-nitsuj / SlothDigest

A small Python tool that does your morning reading for you. Overnight (via a single cron line)

🦥 SlothDigest

An overnight digest that does your reading while you sleep. It watches folders for new files and RSS/Atom feeds for new headlines, then asks a local open-weight model (Gemma, via Ollama) to compress everything into a blunt two-line morning brief with a "Sloth verdict" on what to ignore.

No cloud. No API keys. No UI to test. ~200 lines of standard-library Python.

Why this exists (the lazy payoff)

Every morning the average developer re-scrolls the same feeds, re-checks the same downloads folder, and re-decides what matters. SlothDigest does that pass overnight, on your own machine, so you wake up to a decision-ready brief instead of a pile. On a normal weekday it saves 10–15 minutes of skimming — and it never sends a byte of your file names or reading list to anyone, because the model runs locally.

Requirements

• Python 3.8+ (standard library only — nothing to…

View on GitHub

How I Built It

The open-weight model is the core of the project, not a decoration. The pipeline is deliberately boring everywhere else:

• Local inference via Ollama — the model is llama3.2:3b (open weights, runs 100% on my CPU). Gemma was my first pick, but on a CPU-only laptop the 6.6B model took ~50s per brief; the 3B model answers in ~10s. The model tag is one line in config.json, so anyone can swap in Gemma, Qwen, or anything else they've pulled.
• One POST /api/chat call with all the collected material, a fixed instruction to return a two-sentence summary, at most 5 bullets, and a "Sloth verdict". Generation is capped at 300 tokens — on CPU-only hardware an uncapped local model can grind for minutes, which looks exactly like a hang.
• Everything else is Python standard library: urllib for feed fetching and the Ollama call, xml.etree for RSS 2.0/Atom parsing, a JSON state file for dedup. Nothing to install, nothing to configure beyond a config file.

Architecture, such as it is:

folders ──┐
          ├──> digest material ──> local model (Ollama) ──> 2-line brief + bullets
feeds ────┘         ▲                                            │
             .slothdigest_state.json (dedup)                    └──> digest.log

Why Does Open Innovation Matter?

Three things this build gets because the model is open and local:

1. Privacy by architecture. The digest's raw material includes file names from my downloads folder — invoices, resumes. A closed API means shipping that list to a third party every night. Here it never leaves the machine; the model runs on my CPU.
2. Cost that scales with laziness, not usage. The whole thing runs daily forever for $0. There is no per-request meter watching me be lazy.
3. Swap-ability. When Gemma was too slow on my hardware, the fix was changing a string in a config file — no vendor migration, no API version to chase. That's what open weights buy you that a closed endpoint can't: the right to run the model on the hardware you actually have.

The Lazy Payoff

• Measured: ~10–15 minutes a day of feed-scrolling and folder-checking, replaced by one line of terminal output over coffee.
• One cron line does the work:

  30 5 * * * cd /path/to/slothdigest && python3 slothdigest.py run >> /dev/null 2>&1

I'm asleep at 5:30 AM. The sloth is not. That's the entire user experience: the tool runs, and you read two sentences.

• Zero maintenance surface: no server, no database, no UI to break. Dedup state is one JSON file.