I built an AI-powered PC monitor in Python. 28 strangers shaped its brain.
This article is about PC Workman 1.7.6.
But it's also about what indie dev actually looks like, between retail shifts, late night compiler sessions, and debugging Polish character encoding bugs at 4 AM.

Where it started

PC Workman has created, when I live and work in Nederlands by Agency.
Then 5 months later, I come back to Poland and trying to get a place for me.
For 3 weeks I working by International Trucker.
Then I got my little stop from coding, but after visits Slovakia and Czechy I have seen I carry a... 900% OVER MASS THAN LIMIT.
I don't get anything, I just see that before next trip to France.
Next
I was working as a cashier. Coming home after 8-hour shifts and sitting down to code.

Not because I had energy. Because I couldn't stop.

PC Workman started from one problem: my PC would slow down and I had no idea why. Task Manager said "CPU: 87%." But which process? Since when? How long? Nothing.

Every monitoring tool was either outdated, required installing 3 extra libraries, or looked like it was designed in 2009 and nobody touched the code since.

So I thought: I'll build my own.

Classic mistake. Best decision I ever made.

10 months, 96 files, 48,000 lines

Current state:

Python files:     96
Total lines:      48,081
Response builder: 255,065 chars (yes, one file)
Process library:  241 entries
AI intents:       82
Response handlers: 65

None of these numbers are what I'm most proud of.

Part 1: AI that understands "how much RAM is Chrome eating"

The most technically interesting part of PC Workman is hck_GPT — an AI assistant built directly into the app.

No external API. Doesn't send your data anywhere. Works locally through a hybrid engine: if the intent gets recognized by the 82-intent parser, it responds deterministically from real data. If not, it delegates to a local Ollama LLM.

user input
    → IntentParser (vocab match + ML classifier)
    → HybridEngine (rule dispatch vs LLM fallback)
    → ResponseBuilder (65 handlers, real sensor data)
    → bilingual response (PL/EN auto-detected)

82 intents cover everything from "why is CPU high" to "can I run Cyberpunk" to "what's eating my battery." Each intent has dozens of patterns — because users ask the same thing 15 different ways.

The bilingual helper looks almost embarrassingly simple:

def _t(lang: str, pl: str, en: str) -> str:
    return en if lang == "en" else pl

Behind that sits 854 lines of vocabulary patterns in two languages.

Part 2: The Polish ł that broke routing

This is one of my favorite bugs because it was so non-obvious.

The parser normalizes text before matching — strips diacritics so "dlaczego" (why) with or without accents hits the same intent:

def _ascii_fold(self, text: str) -> str:
    import unicodedata
    return "".join(
        c for c in unicodedata.normalize("NFD", text)
        if unicodedata.category(c) != "Mn"
    )

NFD normalization decomposes "ą" into "a" + combining ogonek, then the filter removes combining characters. Works great for ą, ę, ó, ź, ż, ń.

But not for ł.

ł (U+0142) isn't "l" with a combining stroke. It's a separate character that NFD doesn't decompose at all.

user types:    "jak dlugo wytrzyma bateria"   (plain l)
vocab pattern: "jak długo wytrzyma bateria"   (ł stays as ł after fold)

fold("długo") → "długo"   <- ł preserved
fold("dlugo") → "dlugo"   <- l preserved

"długo" ≠ "dlugo"  -> NO MATCH

The battery_estimate intent was returning conf=0.00 on a perfect question.

Fix: explicit ASCII fallback patterns for every intent containing ł:

# vocabulary.py - battery_estimate patterns
"jak dlugo wytrzyma bateria",     # ASCII fallback
"jak długo wytrzyma bateria",     # canonical Polish
"how long will battery last",     # English

This is the type of bug you only find when building an app in two languages simultaneously and one of them has characters that don't behave the way you think.

Part 3: 28 strangers designed 6 new features

Few weeks ago I posted a simple question on GitHub Discussions and LinkedIn:

"What would you ask an AI that lives inside your system monitor?"

28 answers. From GitHub, LinkedIn DMs, comments.

Every answer became a real function in the response builder.

When you ask hck_GPT "can I run Cyberpunk" it checks your psutil RAM, WMI VRAM, free disk space and responds with specific numbers. No hallucination. No "usually..." No guessing.

The no-data fallback is deliberate:

def _no_data(self, intent, lang, what_missing=""):
    if lang == "en":
        return [
            f"{self.PREFIX} Not enough data for a reliable answer.",
            f"  I'd rather tell you honestly than guess.",
        ]

If I don't have data, I say so. AI that guesses is worse than AI that stays quiet.

Part 4: DeepMonitor - from ugly table to real tool

For a long time the hardware view in PC Workman was weak. Inline min/max values with no alignment, dark uneven colors, no structure.

Rewrote it from scratch on ttk.Treeview with 4 fixed columns:

Sensor                    | Value     | Min       | Max
----------------------------------------------------------
  CPU
    [Temperatures]
      Package             | 52.1°C    | 44.0°C    | 52.1°C
      Core #0             | 49.3°C    | 45.1°C    | 51.8°C
    [Utilization]
      Processor           | 13.7%     |  0.0%     | 23.6%
    [Clocks]
      Current             | 3.990 GHz |           | 4.011 GHz

Each category has its own background tint. Temperatures go from white to amber at 70°C to red at 83°C. Utilization hits red at 88%.

Action bar: Save Data (exports .txt/.csv), Pause (freezes the view, button turns amber), Reset (clears session min/max).

Same psutil and hardware_sensors feed hck_GPT. When DeepMonitor shows a red CPU temp line, the proactive monitor probably already sent an alert through hck_GPT a few minutes earlier. Two views, one data source.

Part 5: Proactive monitor - AI that doesn't wait for your question

One of my favorite modules. Runs in background and starts conversations on its own.

THROTTLE_RATIO   = 0.60   # below 60% of max freq = throttled
CPU_SPIKE_PCT    = 30.0   # single process >30% = spike alert
SESSION_BUDGET   = 3      # max 3 unsolicited alerts per 30 min
SESSION_WINDOW_S = 1800

SESSION_BUDGET isn't random — based on CHI 2025 research on proactive AI assistants and when proactivity becomes annoying.

Throttling alert:

hck_GPT: CPU power limit hit (58% of max). Heat is usually the cause. Type 'temperature'.

GPU temperature:

hck_GPT: GPU temperature spike to 89°C. Check cooling or lower graphics settings.

One alert. Specific reason. Specific next action. Not "your computer may be experiencing reduced performance."

Part 6: Language sync — one hour debugging for one line

For 10 months I built an app for Polish users entirely in English. That was a mistake I finally fixed.

But the Settings language toggle didn't sync with hck_GPT. Click "PL" — interface changes, hck_GPT keeps responding in English.

The fix was clean: utils/i18n.py has a callback system:

# panel.py __init__:
_i18n_register(self._on_i18n_lang_changed)

def _on_i18n_lang_changed(self):
    new_lang = _i18n_get_lang()
    self._ui_lang = new_lang
    proactive_monitor.set_language(new_lang)
    self.parent.after(0, self._refresh_welcome_for_lang)

After switching to PL:

hck_GPT: Witaj z powrotem — PC Workman gotowy do działania.

One callback registration. One hour understanding why the widget wasn't refreshing at the right moment.

Numbers that surprised me

• 28,000 LinkedIn views on the "building what 28 people asked for" post
• 27,500 views on "most developers never ship an .exe"
• 1,135 em-dashes found and replaced in one maintenance session across 58 files
• 241 processes in the knowledge base
• 82 intents in the parser, each with dozens of PL+EN patterns
• 0 external APIs — everything local Most surprising: the two most viral posts weren't about the most technically interesting things. They were about truths every developer recognizes but rarely says out loud.

What's next

Security module — offline, no signatures, no cloud. Pattern detection on data PC Workman already collects.

svch0st.exe pretending to be svchost.exe? Flagged.
Crypto miner with abnormal CPU pattern 24/7? Flagged.
New high-privilege process that wasn't there yesterday? Flagged.

Your antivirus knows about threats from around the world. PC Workman knows what's normal for YOUR specific machine.

And Microsoft Store submission. I've been saying this since v1.6.3. This time I mean it.

Current stats: 56 GitHub stars, 270+ downloads, 270+ commits, 82 AI intents, 48,081 lines, 10 months, one €1.50 coffee donation.

Repo: github.com/HuckleR2003/PC_Workman_HCK
All links: linktr.ee/marcin_firmuga

If you have a question you'd ask an AI inside your system monitor — drop it in the comments. Every one becomes a real feature.

Marcin Firmuga | 22 | Poland | HCK_Labs
Building PC Workman and GuideAI publicly. 10 months. 4 rebuilds. Still shipping.

About the Author

I’m Marcin Firmuga. Solo developer and founder of HCK_Labs.

I created PC Workman, an open-source, AI-powered PC resource monitor who learns, after time, your natural PC behavior (spikes, voltage, temps, usages) built entirely from scratch on dying hardware during warehouse shifts in the Netherlands.

Before this: game translations, PC technician internships, warehouse operations in multiple countries, and countless failed projects I never finished.

But this one? This one stuck.
1000+ hours of code. 4 complete UI rebuilds. 16,000 lines deleted.
3 AM all-nighters.Energy drinks and toast.

And my own hck_GPT AI, building for months to give a PC Workman a brain and heart.
And finally, an app I wouldn’t close in 5 seconds. That’s the difference between building and shipping.

PC_Workman is the result.