From a Warehouse Floor to the Microsoft Store - PC Workman Marcin Firmuga

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.

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.

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.

: one click, no account, no cloud.

Not on Windows yet? . 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.