# Focus67Dumby: A 100% Offline, Vision-Aware Sticky Note That Tells Coding Tutorials from Brain-Rot > Source: > Published: 2026-10-17 19:00:28+00:00 *This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle](https://dev.to/challenges/hacktoberfest-week2-2026-10-12)* ## What I Built ### The Problem: The "Coding Tutorial vs. Brain-Rot" Dilemma As developers, students, and freelancers, we all know the pain of opening YouTube to watch a 15-minute system design breakdown or documentation walkthrough—and waking up 45 minutes later deep in a YouTube Shorts or gaming rabbit hole. Existing productivity tools fail developers in two ways: 1. **Traditional Website Blockers (Cold Turkey, Freedom):** They are blunt hammers. They block*all* of YouTube or Reddit indiscriminately, which immediately breaks your workflow when you actually need a coding tutorial or debugging thread. 2. **Cloud AI Activity Trackers (Rize, Reclaim):** They charge $15+/month subscriptions to continuously stream your window titles, private repo names, and screen activity to third-party servers—an absolute non-starter for privacy-conscious engineers or freelancers working under client NDAs. ### The Solution: Focus67Dumby **Focus67Dumby** is an ultra-lightweight, 100% offline floating sticky-note accountability companion powered by local open-weight models (`gemma4:e2b`, `gemma4:e4b`, `qwen3-vl:2b`, `gemma3:1b`, and `gemma3:270m`) via **Ollama**. It sits quietly in the corner of your screen like a minimalist `350x530` dark-amber sticky note. You lock in what you are working on (e.g., *"Fix Express auth middleware"*), pick a sprint duration (`25m`), and choose your local Ollama model. In the background, it observes your active window transitions and downscaled in-memory screenshots (`512x288`) to distinguish productive work and relevant tutorials from off-task entertainment—nudging you back on track without ever sending a single byte of data to the cloud. ### Who Would Pay For It? (The Side Hustle Model) Developers, indie hackers, and remote freelancers suffer from horrific subscription fatigue. Because **Focus67Dumby** runs 100% on the user's local hardware via Ollama, our marginal cloud inference cost is **$0.00**. That allows us to sell the packaged Pro Desktop Edition as a **$19 One-Time Lifetime License** (zero recurring monthly fees, zero cloud telemetry) alongside a free self-built open-source edition. ## Demo *(Tip: On the live landing page, you can interact with the Sticky Note preview directly, test the checkout flow, and explore the local architecture!)* ## Code ### A tiny, privacy-first desktop accountability widget that uses local open-weight AI (Ollama + Gemma) to tell coding tutorials apart from YouTube rabbit holes. # 📌 FocusDumbyDumb (FocusSticky) **Stop blocking all of YouTube. Just block the brain-rot.** An ultra-lightweight, 100% offline floating sticky-note accountability partner powered by tiny local open-weight models (`gemma3:270m` / `gemma2:2b`) via Ollama. ### 💡 Why This Exists Traditional website blockers are blunt hammers—they either block YouTube completely (breaking your workflow when you need a system design breakdown or documentation tutorial) or let you slip into a 45-minute Shorts rabbit hole. Meanwhile, cloud AI productivity trackers stream your private window titles and screen data to third-party servers while charging a monthly subscription. **FocusDumbyDumb** lives as a tiny, frameless sticky note in the corner of your screen: 1. **Lock in your goal & timer** (e.g.,*"Fix Express auth middleware — 45 mins"* ). 2. **Pick your local model** dynamically from your Ollama installation (`gemma3:270m` uses <400MB RAM). 3. **Stay accountable privately:** A background watcher evaluates active window changes locally in ~40ms. Coding tutorials pass… ## How I Built It **Focus67Dumby** was engineered around small, fast open-weight models running locally through the **Ollama REST API** (`http://127.0.0.1:11434`), wrapped in a modular Python 3.11 desktop architecture (` CustomTkinter` + `Win32 ctypes` + `Pillow`). ### 1. Local Open-Weight Models Used (Gemma & Qwen) Through live discovery via Ollama's `GET /api/tags`, the sticky note dynamically populates a dropdown so users can hot-swap models based on their hardware: - **`gemma4:e2b` & `gemma4:e4b` (Primary Multimodal Vision + Text Engine):** Google's compact open-weight Gemma models evaluate both the foreground window title and a compressed`512x288` base64 screenshot payload via`POST /api/generate` in strict JSON mode. - **`gemma3:270m` & `gemma3:1b` (Ultra-Edge Text Mode):** For users on low-spec laptops running on battery,`gemma3:270m` (~290MB footprint) evaluates window titles in sub-50ms using almost zero RAM. - **`qwen3-vl:2b` & `qwen3.5:2b`:** Supported as drop-in open-weight vision alternatives for reading small UI text inside split-screen browser tabs. ### 2. Solving Real-World Desktop Edge Cases Building a local AI watcher that actually feels good to use required solving several gnarly systems challenges: - **👁️ Hybrid Vision + Perceptual Diff Caching (`<3%` Threshold):** Window titles alone can be deceptive (e.g., Chrome just saying`"LinkedIn"` when you're actually playing the LinkedIn Zip puzzle game, or watching a coding tutorial with a vague title). In Vision Mode,`window_watcher.py` grabs an in-memory screenshot, resizes it to`512x288` (JPEG quality 65), and computes a fast`16x9` grayscale perceptual signature. If the screen pixels change by`<3%` and the window title is identical (like reading static documentation), it hits the local session cache (`0ms` latency,`0` GPU calls). - **⏱️ 30-Second Workspace Calibration & Multi-Window Breadcrumbs:** Real engineering tasks span multiple windows (VS Code + Terminal + Localhost Browser + Google OAuth popups). During the first 30 seconds of a sprint, Focus67Dumby enters a**Workspace Calibration Phase** , automatically whitelisting the windows you touch into a trusted workspace (`0ms` instant switching), plus tracking a rolling 4-window breadcrumb trail so the model understands when a secondary login popup was spawned from your primary task. - **🚨 Two-Strike Grace Period & Escalating Interference:** Quick Alt-Tabbing never triggers a false alarm. If you stay on an unaligned distraction for 2 consecutive checks (`Strikes 2, 4, 6...` ), it fires your chosen interference level: 1. `Gentle Toast` (Native Windows notification with custom auto-generated`.ico` icon) 2. `Toast + Sound` (System audio alert + toast) 3. `Popup Takeover + Sound` (Forces the sticky note to the front via Win32`WS_EX_APPWINDOW` , flashes the border bright red, and physically shakes the widget horizontally on screen until you get back to work). - **🐧 Headless Linux & Docker Determinism:** All GUI (`customtkinter` ), screen-capture (`Pillow` ), and Win32 (`ctypes.windll` ) imports are lazily guarded so the app runs a deterministic offline CLI simulation (`python -m src.main --headless --demo` ) and passes all unit tests inside a clean headless Linux Docker container in`0.75s` . ## Why Does Open Innovation Matter? This is a product category that **literally cannot exist as a sustainable, trustworthy business on closed-source cloud APIs**: 1. **Absolute Data Sovereignty (Zero Screen-Spying):** To know whether you are watching a React tutorial or scrolling memes, an AI needs to see your window titles and screen context. Sending screenshots of a developer's desktop every 10 seconds to a closed cloud API means leaking`.env` files, proprietary company source code, private messages, and banking tabs to external servers. Running`gemma4:e2b` or`gemma3:270m` locally on`127.0.0.1` guarantees that screenshots never even touch the disk—they are evaluated in RAM/VRAM and immediately discarded. 2. **Unit Economics That Make a $19 One-Time Price Possible:** Polling a frontier vision API every 10 seconds across an 8-hour workday equals**2,880 multimodal API calls per user per day** . With closed API pricing, a single heavy user would burn through $20–$40+ in token costs every single month, forcing a bloated recurring SaaS subscription. By running open-weight Gemma models locally on the user's existing hardware, inference costs**$0.00 forever** . 3. **Zero Vendor Lock-In & Offline Freedom:** Whether a user has an 8GB VRAM GPU running`gemma4:e2b` in Vision Mode or an older laptop running`gemma3:270m` on CPU while studying on a train with zero Wi-Fi, the open-weight architecture adapts to them—and still includes a deterministic heuristic fallback if Ollama isn't running. ## My Agent Session I built and verified this project using an agent-driven workflow anchored by strict repository guardrails (`AGENTS.md`, `ARCHITECTURE.md`, `MISTAKES.md`, and a custom `focus67dumby-master` skill specification). Instead of letting coding agents hallucinate monolithic spaghetti code, the master skill enforced thread-safe `queue.Queue()` / `root.after()` UI marshaling, sub-60-word structured JSON prompts tailored for small models, Win32 foreground window detection, and an 8-point clean-Linux Docker rebuild gate verified by a 15-test `pytest` suite. ## My First User I put **Focus67Dumby** in front of its first real user—a college mate of mine who constantly battles the exact "open YouTube for a lecture/tutorial, end up watching random videos for an hour" loop during study and coding blocks. ### How the Test Went: - **What clicked immediately:** He loved the floating sticky-note form factor and the fact that it wasn't a heavy browser extension or a full-screen dashboard app. Seeing the widget distinguish between a legitimate task window and off-topic browsing—plus the**"Popup Takeover + Shake"** interference mode physically shaking the sticky note on screen when he drifted off-task—got him genuinely excited about using it for daily sprints. - **Real-world friction we discovered during testing:** Early in our testing, we noticed that real workflows involve bouncing between multiple windows (like opening a secondary login popup or switching between a browser puzzle/task and a terminal), and that unchecking "Always on Top" on a frameless Windows widget could hide it behind the browser. - **What we iterated on next:** That feedback directly inspired our**30-Second Workspace Calibration** feature (where the app automatically learns and trusts the tabs/windows you open in the first 30 seconds of a sprint) and our native Win32 taskbar persistence fix (`WS_EX_APPWINDOW` ). - **Would they pay?** For students and indie devs, monthly subscriptions are a dealbreaker, which validated positioning the packaged desktop installer as a low, one-time lifetime utility while keeping the core repo 100% open-source. ## Prize Categories - **Best Use of Gemma:****Focus67Dumby** is built around Google's open-weight**Gemma** family (`gemma4:e2b` and`gemma4:e4b` for local multimodal vision-and-title classification, plus`gemma3:270m` and`gemma3:1b` for ultra-low-memory CPU edge classification) served locally via Ollama with strict JSON schema validation and`keep_alive` VRAM management. - **Best Use of Entire:** Shared the full agent-driven engineering workflow, session history, and repository memory artifacts (`AGENTS.md` ,`ARCHITECTURE.md` ,`MISTAKES.md` , and`focusDumby67-skill.md` ) that governed why each module, thread-safety queue, and headless fallback exists in the codebase. - **Best Use of Render:** Deployed and hosted the**Focus67Dumby** interactive product front-end, sticky-note state simulator, and license checkout portal on**Render** with automated GitHub continuous deployment.