I talk for 30 seconds, and my to-do list writes itself (Whisper + Gemma 4, local)

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

What I Built

TalkDown turns rambling voice memos into a dated, de-duplicated to-do list in a markdown file.

Say this on the drive home:

"Okay, quick one before I forget. I need to call the dentist to book a cleaning, ideally before Friday. Also send the invoice to the client by tomorrow, that's urgent. And I need to buy milk and eggs on the way home. The weather is really hot today, anyway."

and tasks.md gets the dentist task due Friday, the invoice due tomorrow and flagged high priority, and the milk and eggs with no date. The weather comment is ignored.

The next memo is the one that matters: "I sent the invoice to the client already, and the dentist can only do next Monday now." TalkDown ticks off the invoice, moves the dentist appointment to Monday, and adds nothing new. Most "voice to tasks" demos only append. TalkDown maintains a list.

Demo

Code

clyv / talkdown

🦥 TalkDown

Talk for thirty seconds. Your to-do list writes itself.

TalkDown turns rambling voice memos into a clean, dated, de-duplicated to-do list in a markdown file. Speech is transcribed by an open Whisper model, understood by Gemma running locally through Ollama, and written to tasks.md. Nothing leaves your computer.

🎬 Demo: Watch on YouTube

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

---

What it does

Say something like this into your phone on the drive home:

"Okay, quick one before I forget. I need to call the landlord about the AC, ideally before Thursday. Also pay the DEWA bill by the end of the month, that's important. Oh, and get Sara a birthday gift. The traffic on Sheikh Zayed Road is insane today, anyway."

and tasks.md becomes:

## 🗓️ Next 7 days
- [ ] Call landlord about the AC —

…

View on GitHub

How I Built It

flowchart LR
    A[🎙️ Voice memo] --> B[faster-whisper]
    B -->|transcript| C[Gemma 4 via Ollama<br/>+ current open tasks]
    C -->|JSON: new / done / updated| D[Deadline resolver<br/>+ duplicate guard]
    D --> E[(tasks.json)] --> F[📄 tasks.md]
    F -->|ticked boxes| E

The open stack:

• faster-whisper running OpenAI's open Whisper weights for speech to text. It reads phone formats like .m4a and .opus directly.
• Gemma 4 (gemma4:e4b) served by Ollama for understanding the memo. This is the brain of the project.
• Plain Python for everything else, with no framework. The Ollama client is standard-library HTTP.

Three decisions made the difference between a toy and something I actually use.

1. Gemma sees the list, not just the memo. Every prompt includes the open tasks with short ids (T1: Call landlord about the AC [2026-10-23]). That lets a memo say "paid the bill" and get back "completed_ids": ["T2"] instead of a new task called "pay the bill". Ollama's structured outputs constrain the reply to a JSON schema:

{
  "new_tasks":     [{"title": "...", "due_text": "...", "priority": "high|normal|low"}],
  "completed_ids": ["T2"],
  "updates":       [{"id": "T1", "due_text": "Friday"}]
}

2. Gemma reads the language; Python does the calendar. Small models are unreliable at date arithmetic, so Gemma returns the deadline words as spoken ("before Thursday"), and a deterministic resolver turns them into a date relative to when the memo was recorded:

resolve("before Thursday", date(2026, 10, 20))   # -> 2026-10-22
resolve("end of the month", date(2026, 10, 20))  # -> 2026-10-31
resolve("next week", date(2026, 10, 20))         # -> 2026-10-26

Gemma does what language models are good at, and code does what code is good at.

3. Trust, then verify. Gemma is told not to repeat open tasks, but every "new" task is still fuzzy-matched against the open list and against anything it just marked done in the same memo. Near-duplicates get merged instead of added.

A few lazy-person features rounded it out:

• talkdown watch polls a folder. Point it at a folder your phone syncs to and you never touch the laptop. It waits for files to finish syncing and moves failures aside with an error note.
• Two-way markdown. Each line carries a hidden <!-- T3 --> id, so ticking a box in VS Code or Obsidian marks the task done on the next run.
• A morning digest of what's overdue, due today and coming up.
• talkdown stats, which is where the numbers in the Lazy Payoff section come from.

The repo has 72 tests that replace Whisper and Gemma with fakes, including a fake Ollama HTTP server, so the logic is checked without a GPU. They pass on Python 3.10 and 3.12.

What broke on the first real run

The tests passed, but the first real run on Windows hit two problems, both now fixed in the repo:

• The newest av audio library dropped an argument that faster-whisper 1.2.1 passes, so decoding failed. The dependency is now pinned below version 16.
• With device = "auto", Whisper tried to load CUDA libraries that weren't installed. The default is now cpu, and CUDA is opt-in.

Both are easy to miss, and the test suite alone wouldn't have caught them.

Why Does Open Innovation Matter?

Voice memos might be the most personal data I produce. I don't want a transcript of my landlord calls, bills and appointments in someone else's logs just so I can get a to-do list.

With Whisper and Gemma running locally:

• It works with Wi-Fi off. I turned Wi-Fi off and processed a memo end to end. Recordings and transcripts stay on my machine.
• It costs nothing per memo. A closed API would bill me for every ramble. Here talking is free, which matters for a tool you use constantly without thinking.
• It's mine to change. The prompt, the schema, the date rules and the duplicate threshold are all in the repo. If the model misreads how I talk, I can fix it.

Where closed models are better: a frontier API would handle very long, chaotic memos more reliably than a 4B-class model on a laptop. The trade-off is setup: a one-time model download instead of an API key. For short personal memos the open stack has been good enough, and the design choices above (structured output, deterministic dates, duplicate guard) close most of the gap.

Timings from my runs

On a Windows laptop, CPU only:

• Whisper: about 6 to 7 seconds to transcribe a 30-second memo.
• Gemma 4 (gemma4:e4b): 18 to 45 seconds per memo, depending on how much it has to decide.

The Lazy Payoff

📊 TalkDown since 22 Oct 2026

Memos processed: 2
Audio: 1.0 min (30s per memo)
Words spoken or typed: 67
Tasks captured: 3
Tasks ticked off by voice: 1
Tasks updated by voice: 1
Average time per memo: Whisper 5.0s + Gemma 23.0s
Typing avoided (estimate): ~2 min, assuming ~40 words/min

Prize Categories

• Best Use of Gemma. Gemma 4 is the core of TalkDown. It reads every transcript alongside the live task list and decides what to add, complete and reschedule, running locally through Ollama with structured outputs.

Thanks for reading, and happy Slow and Steady. 🦥