Focus67Dumby：100% 離線、具視覺感知能力的便利貼，可分辨編程教學與無腦娛樂內容

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

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

• 🌐 Live Product Landing Page & Interactive Checkout Demo: https://focus67dumby-landing-page.onrender.com/
• 💻 Desktop Application & Source Code: https://github.com/Thrizzio/Focus67Dumby

(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

Thrizzio / Focus67Dumby

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.