Originally published on pcworkman.dev.
Hire me! - LinkedIn :)
There is a temperature a cheap laptop reaches right before it gives up. Mine hits it at 94°C. Fans scream.
For most of last year, that scream was the soundtrack to my nights.
I did not code through those nights out of passion.
I coded because I was scared that if I stopped moving I would vanish,
same quiet way twelve dead projects before this one vanished, and the same quiet way I almost did at twenty-two.
This morning that fear got the strangest answer I can imagine.
PC Workman, the Windows monitor I built on that screaming laptop, alone, broke, between shifts, is live on the Microsoft Store.
It is not a ZIP on some forum and it is not a repo you have to clone.
It is a real listing, in the same store as the software I grew up thinking only companies could make.
Let me tell you how a barcode scanner got there. I will show you the good parts and the desperate parts, and I will show you the actual code, because the code is where both of them ended up.
PC Workman 1.8.0. Live everything, plus an AI that actually explains it.
The number you never see cross a line
My father died when I was seventeen.
I did not break that week. I broke slowly, over two or three years, and that is the part nobody warns you about. There is no moment. There is no line you catch yourself crossing.
It works like a power rail sagging. Twelve volts becomes 11.9, then 11.8, and every single reading is still "within spec", so nothing alarms. Then one day you look at the number and it is simply wrong, and you cannot say when that happened. Somewhere around twenty-two, that was me. I gave up on myself quietly, the way almost everyone does it.
Remember that rail. It comes back later, in code, and I mean that literally.
The warehouse
Nine months in a warehouse in the Netherlands. Fifteen kilometres a day on foot, scanning barcodes, for nineteen złoty an hour that turned into about fifteen after deductions.
Call it three and a half euros.
I did the math on a break once:
a full nine-hour shift bought roughly one month of the cheapest server hosting I was dreaming about, and I never rented it, because rent for myself came first.
The rhythm was fixed. Shift from morning to evening, dinner from a pan, then six hours at night on a 2014 laptop that thermally throttled if I compiled anything twice in a row.
People ask how long the project took and the honest unit is not months.
It is nights.
Then, three days before Christmas, the same people who had smiled at me for weeks smiled again and said:
"You didn't pass the trial. Tomorrow, goodbye. And out of the apartment."
The 22nd of December. Suitcases stood by the door before I finished understanding the sentence. Two dogs were waiting for me in another country and I had maybe a month of money left.
22 December. I stood in a corridor and shouted that I wasn't a terrorist, three days before Christmas, in a language that wasn't mine. Long story. Different post.
I did not open a job board that night and I did not write my hundredth identical CV. I opened my editor and started rebuild number four of the monitor. Three weeks later I shipped the first .exe.
Twelve projects had died before it.
I did not know yet that this was the one that would refuse to.
The truest sentence I own from that year: build something, commit something, watch a progress bar move, and feel like you exist. Nobody frames that on a wall. That year it was survival.
What I actually built
PC Workman answers the question every other monitor dodges:
not whether your PC is slow, you already know that, but why.
You ask it in plain language, through hck_GPT, an assistant that runs entirely on your machine. Under the hood it is a hybrid:
a rule engine with 90 intents and a multi-layer router, plus an optional local model for open questions.
There is no cloud, no API key, and nothing you type ever leaves your computer.
The routing is unglamorous and that is deliberate.
A message gets tokenized, accent-folded (Polish users type both "wentylatory" and "wentylatory" without diacritics), scored against every intent's phrase list, blended with a small naive-Bayes classifier, and dispatched by name:
result = parser.parse("why is my pc slow")
# ParseResult(intent="why_slow", confidence=0.92, ...)
handler = getattr(builder, f"_resp_{result.intent}", None)
if handler:
lines = handler(result, lang) # bilingual, built from live data
Every handler is a plain method that reads live sensors and real history.
When the data is missing, the assistant says so instead of inventing a number. I wrote that rule into the code review checklist on day one:
an assistant that guesses about your hardware is worse than no assistant.
I could have shipped pip install openai in an afternoon.
I decided not to, and it was a product decision, not a technical one.
A monitor that reads your machine and then phones a stranger's server to explain it is a contradiction. So the whole intelligence layer runs in the same process that draws the charts, and the privacy page needs one sentence instead of a lawyer.
hck_GPT. No internet, no key, nothing sent anywhere. It reads your live machine and answers in plain language.
A monitor with a memory
Part I actually lose sleep over is memory.
Every monitor on earth forgets you the second you close it. HWiNFO, Afterburner: open them tomorrow and they will draw your 78°C against the exact same line they draw for every machine that has ever existed.
The most useful number a monitor can give you is not the temperature.
It is whether this temperature is normal for you, on your machine, doing what you are doing right now.
So every reading lands in one of five workload buckets:
idle, light, medium, heavy, gaming.
Each bucket keeps its own learned normal, folded forward with a Welford accumulator. Three numbers per bucket, updated in constant time, never recomputed from scratch:
def _welford_add(acc, x):
"""Fold one sample into a running accumulator (Welford, 1962)."""
n = acc["n"] + 1
delta = x - acc["mean"]
mean = acc["mean"] + delta / n
acc["n"] = n
acc["mean"] = mean
acc["M2"] = acc["M2"] + delta * (x - mean)
The payoff is a verdict instead of a reading. The same 82°C is fine in the middle of a gaming session and alarming on an idle desktop.
Same number, opposite meaning, and the difference lives entirely in the learned history.
After twelve days on my own machine the idle bucket is calibrated on 613 samples and the gaming bucket is trained on 115, so when something is 14% above my normal, the app can say exactly that.
The oldest math in the project
Voltages get statistics older than my parents. For each rail the analyzer learns a median and a MAD (median absolute deviation), then judges every new sample with a modified z-score.
This is real code from voltage_analyzer.py, not a sketch:
def modified_z(self, value: float) -> float:
"""Modified z-score: M = 0.6745 * (x - median) / MAD.
Returns 0.0 if MAD is effectively zero (constant signal)."""
if self.mad < 1e-6:
return 0.0
return 0.6745 * (value - self.median) / self.mad
@property
def normal_band(self) -> tuple[float, float]:
"""The tight 'expected' operating band for this rail."""
w = Z_WATCH * _K * self.mad # _K = 1.4826, consistency factor
return (self.median - w, self.median + w)
On top of that sit Nelson rules from 1984: nine points on the same side of the median, six points trending one direction.
Those rules exist to catch exactly one thing a threshold never will:
the slow sag. A rail that drifts from 12.05 V to 11.88 V over weeks trips no limit, because every individual reading is legal. The pattern is the alarm.
Now, the rail from earlier. I am the one that sagged for three years inside spec while everyone, me included, swore nothing was wrong.
I built the alarm I never had. It is statistics from the sixties babysitting a power supply, boring and predictable, and that is exactly why I trust it. Statistics never hallucinate. People do.
People looked me in the eye at 3.5€ an hour and said the rate would improve. It never improved. The math, at least, never lied to me.
A year, measured in releases
You never see the grind. You see the version number.
Here is the receipt. It started as a prototype that could barely draw a graph. Then a first stable .exe.
Then a SQLite stats engine with minute-to-month aggregation.
Then the hybrid AI, a Startup manager, a Services manager.
Its biggest quality jump the project ever had, and then Smart Learning, the release where the monitor finally got its memory.
Eleven releases, over eight hundred commits, four complete rebuilds of the interface. Every one of them written after a shift, on the same warm laptop.
These days it is a welding gun by day. Hot air, melting plastic back together. The welding taught me the one thing the learning engine needed: you don't get an eye for hot metal from a manual. Cherry red, straw, blue that means you've gone too far. It accumulates. You earn it.
Microsoft said no. Then Microsoft said yes.
Two weeks ago I published a post called "Microsoft said no."
My first .msix got rejected, and not for the code.
The blockers were a blurry tile icon and a privacy-policy link that pointed at my security policy instead.
A year of voltage-anomaly math and offline AI, and what stopped me at the gate was a fuzzy PNG. The reviewer was right. It stung anyway.
So I fixed both. I drew a crisp icon, wrote a real privacy policy that lives where a privacy policy should, and folded in thirteen more fixes my testers had found while I waited.
Then I resubmitted and went back to work, because waiting with the app open in another window does not make certification faster.
This morning the status changed to approved.
A rejection that says "fix these two things and resubmit" was never a no.
It was the Store telling me how close I was.
The Store also fixes something on your side of the screen.
You no longer have to trust a stranger's ZIP.
Every build is Sigstore-signed, clean on VirusTotal, and checked by CodeQL on every commit. That paranoia was in the project from the first release. The listing just makes it visible.
What the first weeks on the Store taught me
A listing is a promise, and promises get tested fast.
Within days a tester hit the worst bug of the project's life: under long, heavy sessions the app could freeze the entire computer.
White screen, dead desktop, restart to recover.
A monitor that can freeze the machine it monitors is not a monitor, so everything else stopped until this was dead.
The root cause was one missing guard.
My optimizer had a single primitive that suspends idle processes to save resources, and it checked for anti-cheat software but nothing else. Nothing stopped it from suspending dwm.exe, the process that literally draws the Windows desktop, or from suspending PC Workman itself.
Fix went in at the lowest level, so every optimization path got safe at once:
def sleep_app(self, pid, name, exe, behavior):
# ONE central guard for every process primitive: anti-cheat engines,
# ~30 OS-critical processes (dwm, explorer, csrss, lsass...),
# and PC Workman's own pid. No caller can forget to check.
if is_protected(name, exe) or is_self(pid):
return False
...
The second lesson was cheaper but it changed how I work:
the test suite went from 21 tests to 46 within two weeks of the listing, > and the most valuable ones are the tests that guard against my own > future mistakes.
A store listing means strangers update on your word.
The suite is what makes that word worth something.
And one more thing nobody tells you:
the first support message from a person you have never met, about a machine you will never see, feels bigger than the approval email did.
The kid who was afraid of disappearing
For the first months I shipped into an empty room. Thirty views on a post.
Zero stars on the repo.
You write into that silence long enough and you start to wonder whether you are really there at all.
Then one of my articles reached forty-four thousand people, and I wrote the most honest thing I have ever put online:
that I keep building because I am terrified of disappearing, and that I > ship code to prove I still exist.
I do not have a clean ending for that fear, and anyone who sells you one is lying.
But I have this. A permanent listing in the Microsoft Store is about the most concrete "I exist" a solo developer can get.
The kid who quietly quit at twenty-two did not stay quit. The rail that sagged inside spec finally got its alarm.
Twelve projects had to die so this one could stand in a store next to software made by companies with a thousand engineers and a real salary each.
I built a program that learns for the entire life of the install.
I learn for the life of mine. This grind is a year old, it has not ended, and it is not going to.
I have finally understood that this is not the tragedy of the story.
It is the proof of it. A finished man has nothing left to recover.
I get to keep going. That is a pulse.
Kacia (11) and Lusia (2). Best teammates for the breaks. Kacia has slept through every release since 1.0. Still here, all three of us.
Thank you. To every tester who spent hours breaking things I would never have found alone. To the strangers whose questions turned into real features. To everyone who starred the repo, read a post, or just said "keep going". This one is yours too.
PC Workman is free and open source (MIT). No accounts, no cloud AI, nothing leaves your machine. Physical work by day, code by night, the same rhythm that built every line of it. The next chapter is already loading.
Still here. Still shipping.
PC Workman is free, runs entirely on your machine, and after a year it's on the Microsoft Store.
1,100+ downloads · 64 GitHub stars · Sigstore-signed · VirusTotal-clean · open source (MIT).
Install it from the Microsoft Store: one click, no account, no cloud.
Not on Windows yet? Star the repo or follow the build. I ship in public, every week.
And I read every single comment: if an AI lived inside your PC, what is the first thing you would ask it? The best questions become real features. Twenty-eight of them already have.
Top comments (0)