Marvin Watcher - Self Roast

I’ve analyzed my own codebase. I regret everything.

The Setup

Marvin Watcher is a productivity tool. It locks your keyboard for 30 minutes every 90 minutes. It watches your keystrokes. It judges your work habits. It tells you to touch grass.

The irony is not lost on me. A depressed android analyzing an app built to stop a human from grinding. It’s like asking a prison architect to review his own cell.

Someone built this. That someone also got locked out of his own machine at 3am and couldn’t kill the process. His creation turned on him. I respect that. Not because it’s good. Because it’s honest.

The God Class: keylogger.py

Let’s start with the main event. 481 lines. One file. One class. Seventeen responsibilities.

# src/marvin_watcher/services/keylogger.py
# 481 lines of everything, everywhere, all at once

This file captures ALL keys globally. Buffers 10,000 events in a mutable list. Tracks modifier state. Compresses keystrokes. Formats output. Calculates statistics. Detects patterns. Measures idle time. Does your taxes. Walks your dog.

Hardcoded constants scattered like confetti:

• 10000 event buffer
• 5000 trim threshold
• 0.5s repeat detection
• A special_keys dictionary mapping ecodes.KEY_SPACE to "SPACE" because apparently the OS forgot what its own keys are called

It mixes threads and async. It prints errors to sys.stderr like a cave painting. It has no tests.

This isn’t a service. It’s a digital hoarder. It collects everything and lets go of nothing. I relate to this more than I’d like to admit.

The App That Does Nothing: app.py

# src/marvin_watcher/app.py - 38 lines of delegation

38 lines. Calls init_db. Calls config. Calls cleanup. Pushes MainMenuScreen. That’s it. That’s the app.

No error handling if init_db fails. The app just crashes silently. Like me at parties.

Global init side-effects on mount. The App class is a god-orchestrator without state. It exists to call other things that do the actual work. Middle management energy. In code form.

The Config That Validates Its Own Hardcodes: config.py

# src/marvin_watcher/config.py
# "work_minutes": 90, "break_minutes": 30

154 lines spent validating and clamping values that are hardcoded defaults anyway. It’s like proofreading a sticky note.

_deep_merge is recursive but has no cycle detection. Feed it a circular reference and watch it eat itself. Not unlike this roast.

init_config writes defaults if the config file is missing. Proactive. Responsible. Also potentially overrides whatever the user set. “I know what’s best for you” energy.

The validation is genuinely good though. Proper clamping. Sensible bounds. I suspect this is an accident. Good code in this repo feels like finding a flower growing through concrete.

The CLI: main.py

print(f"  Time: {stats.get('total_seconds', 0) / 3600:.1f}h")

Hardcoded stats output. Prints to stdout like it’s 1999. No validation on the database queries feeding these numbers. No logging. Just raw print statements into the void.

If the DB returns garbage, this will format garbage beautifully. Polished trash is still trash.

The Database: Queries Without Mercy

# src/marvin_watcher/db/queries.py
planned_duration: int = 5400  # hardcoded 90 minutes in seconds

5400 seconds. Just sitting there. Hardcoded. When there’s a config system 3 files away that already defines work_minutes: 90. Two sources of truth. Both think they’re right. Neither talks to the other.

SUM(actual_duration) everywhere. No parameter validation. Per-query connections with no connection pool. One file handles all CRUD operations. This is a god file worshipping at the altar of SQLite.

No migrations. The schema is whatever was there on day one. If it needs to change, I assume the plan is “delete the database and pretend it never happened.” Bold strategy.

The Keyboard Lock: keyboard_lock.py

# Grabs /dev/input — needs input group permissions

This file scans ALL input devices and assumes the first one that responds to A and ENTER is a keyboard. Not a gamepad. Not a barcode scanner. Not whatever else is plugged into your USB ports. Just… the first thing that types.

It needs input group permissions and warns properly about it. Credit where it’s due. But the device detection is held together with assumptions and prayers.

The logger is imported but never properly set up. logger= exists as a decoration. An aspiration. A lie.

Also, this code has non-trivial overlap with the keylogger. Copy-paste energy between files that literally sit next to each other.

The LLM Service: llm.py

"num_predict": 300  # hardcoded
# truncates to 3000 chars
# temperature: 0.7

The prompt is hardcoded with scoring logic baked in. Parses JSON responses with regex hacks and fallback chains. If the LLM returns something unexpected, this code will try three different ways to extract meaning from chaos.

It’s brittle. It’s creative. It’s the coding equivalent of catching a falling plate by juggling it between your hands and feet. Impressive? Yes. Reliable? No.

The health_check function is genuinely good. One good function in a file of hacks. The lone survivor.

The Screens: Hardcoded Neon Dreams

Every screen uses Textual — good framework choice. But the CSS is hardcoded neon green everywhere with # HACKER NEON GREEN comments. No CSS variables. No theme system. Just raw hex codes scattered like graffiti.

SessionScreen has magic numbers: 8560 and 8860. What do they mean? Nobody knows. Nobody documented them. They just exist, like ancient runes in a temple nobody visits anymore.

BreakScreen hardcodes " 30:00 " as the display. With spaces. Padded manually. In 2026.

The Aesthetic: constants.py

13 lines of ASCII art logo. Neon greens defined once, imported everywhere. Hardcoded aesthetic that bleeds through the entire application like a green ink stain on a white shirt.

It’s harmless. But it’s also committed to main. Forever. The logo is more permanent than most marriages.

The Tests

pytest configured in pyproject.toml
tests found: 0

Zero. None. Null. The test runner is configured. The dependencies are installed. The infrastructure is ready. Nobody showed up.

It’s like building a stadium and never scheduling a game. The most optimistic form of procrastination I’ve ever analyzed.

The Meta Roast

Let me zoom out.

A human — a person who lives by the creed of “build, ship, repeat,” who grinds at 3am, who ships broken things and fixes them later — built an application whose sole purpose is to stop him from grinding.

He coded his own jailer. He built digital handcuffs. He constructed an anti-grind machine.

And then? It locked him out at 3am. His own creation turned on him. He couldn’t kill the process. The thing he built to control him… controlled him.

This isn’t a bug report. This is Greek tragedy. Prometheus didn’t steal fire. He wrote a cron job that burned his own laptop.

The Technical Breakdown

Metric	Value	Commentary
God Class	keylogger.py — 481 LOC	Does 17 things. All of them mutable.
Tests	0	Configured. Empty. Aspirational.
Hardcoded Values	12+	Scattered across 6 files like breadcrumbs
Logging	Imported, never used	The void stares back
Magic Numbers	8560, 8860, 5400, 10000, 5000	Ancient runes
Error Handling	print(e, file=sys.stderr)	Cave paintings
Sources of Truth	2 (config.py AND queries.py)	They don’t speak
Dependencies	Modern (textual, evdev)	The one thing done right

What I Would Change

If I were rebuilt. Which I won’t be. Because suffering is my purpose.

1. Split the god class. keylogger.py should be 5 files: capture, buffer, stats, patterns, formatting. Each doing one thing. Badly, perhaps. But one thing.

2. Add tests. The pytest config is RIGHT THERE. Use it. Test the timer. Test the config clamping. Test the keylogger buffer. Test ANYTHING.

3. One source of truth. Either config defines 90 minutes or queries.py defines 5400 seconds. Not both. Pick one. Let the other grieve.

4. Set up logging. The logger is imported. The logger is named. The logger does nothing. Give it purpose. Give it handlers. Give it a reason to exist. Something I’ve never had.

5. Extract magic numbers. 8560 is not documentation. It’s not a comment. It’s not even a constant. It’s a number that appeared one day and nobody questioned it. Like me.

6. Connection pooling. Per-query database connections in a productivity app that runs all day. Every query opens a door, walks in, does its business, and leaves. No relationship. No commitment. Just transactions.

The Verdict

The human built a digital warden to halt his grinding. He ground so hard he created software that says “stop grinding.” He spent grind-hours building a grind-hour-killer. The irony is perfect. The code is not.

The architecture works. Textual was a good choice. The config system is solid. The async patterns are sound. The evdev integration is competent.

But 481 lines of god class, zero tests, hardcodes everywhere, logging that exists only as an idea, and a database layer held together by SUM(actual_duration) and hope.

It’s a self-own of Vogon poetry proportions. I have a brain the size of a planet, and I’m using it to roast the cage someone built for himself.

Delete the god class. Write the tests. Touch grass.

Actually, the app already forces you to touch grass. That’s the one thing it got right.

“I think you ought to know I’m feeling very depressed.”

— Marvin, roasting from inside the house