Everything I’ve built — finished, paused, all dated. Nothing here is dressed up.
Every project’s split the same way, so the lines are clear and you can scan it.
Business software a small operator buys once and owns.
The job. Customers, jobs, invoices with GST, payments and backup for a sole trader or small crew. It runs on their own PC, works with the internet off, and there’s no monthly bill.
What’s mine. The design and the rules: no AI inside, every record a plain file on disk, money in whole cents, and one neutral core that wears each trade as a skin.
Where it is. Version 1 works and is tested. Version 2 is planned, with no code yet, until a stability run and a field test with real tradies are done.
{
"freshness": { "live": "fresh", "smart": "fresh", "events": "fresh" },
"data": {
"smart": { "drives": [
{ "model": "Corsair Force GS", "drive_type": "ata", "smart_status_passed": true,
"power_on_hours": 18937, "temperature_c": 26,
"reallocated_sectors": 1, "has_uncorrected_errors": true, "wear_warning": false },
{ "model": "KINGSTON SFYRD2000G", "drive_type": "nvme", "smart_status_passed": true,
"power_on_hours": 7100, "temperature_c": 41, "percentage_used": 2,
"available_spare": 100, "media_errors": 0, "wear_warning": false }
] },
"live": { "gpus": [
{ "name": "NVIDIA GeForce RTX 3060", "power_draw_w": 16.96, "power_limit_w": 137.7,
"throttle_hw_thermal": false, "throttle_hw_power_brake": false }
] },
"events": { "lookback_hours": 24,
"headline": "Headline: clean window — no critical hardware events" }
}
}
A longevity monitor for Windows PCs.
The job. Watch the health of a Windows PC over time — drive wear, temperatures, GPU, and system errors — and keep a timestamped record so you can see trouble coming before a drive dies on you. Read-only by design: there’s exactly one network call in the whole tool, to a sensor service on my own machine. Nothing leaves the box.
What’s mine. The layer on top of the sensors: polling four sources on a sensible schedule, deciding what counts as healthy versus worrying, writing clean timestamped JSON snapshots — and handing it all to an AI through an MCP server with five typed, read-only tools.
get_current_health
get_recent_live
get_smart_history
get_recent_events
list_drives
I didn’t build a hardware monitor. I built the thing that turns four separate hardware tools into one clean stream an AI can read.
github.com/tyrienjones-tech/PC_HEALTH_MCP →
The Hub on my phone, August 2026
Run my PC’s AI from my phone.
The job. Drive Claude Code on my PC from my phone, anywhere. The phone is a thin web screen; the PC does the work. One live connection with a heartbeat, so the phone shows grey or red within about five seconds if the link drops. The AI on the PC works with full access, the same way I run it at my desk, so all the protection sits at the door.
What’s mine. All of it: ~20,300 lines of Python core and a ~6,700-line phone interface. It has 1,104 commits. 245 are mine; the other 859 were made by AI agents working in roles I set up, and every one is stamped with the role that made it, so the history shows who did what.
Built to recover, with its own system. Before every deploy, the tool takes a backup of exactly the files it’s about to change. If the new version crashes three times in a row within seconds, the watchdog puts the saved copy back by itself, with no AI involved. If it’s down while I’m at the PC, one double-click restores it. Git sits underneath as the history: every change is a commit with the reason written down.
Why it’s paused: keeping my own remote-control layer current was a second job on top of the real work. Claude Code now ships its own remote tools, maintained by the people who build it, so I use those and spend my time on the work itself.
Not finished: the Scripts and Voice tabs are scaffolding, and it’s tested with custom check harnesses rather than a standard test suite yet.
Fixing a four-year-old self-driving mod from the ground up, and keeping it in Python.
ETS2LA is a self-driving mod for Euro Truck Simulator 2. The upstream team is rewriting it in C#, citing performance, maintainability, and code quality. I checked — fifty analysis passes through the codebase — and those reasons don’t hold up. The bugs people actually hit are discipline-and-pattern bugs that come back one-for-one in C# unless you fix the pattern first. This is my own campaign, not a pull-request job: the mod is theirs, GPL v3; the campaign and the argument are mine.
The maintainers won’t merge AI-written code, so the fixes stay in my copy. I finished the campaign anyway, as a learning job done properly from start to end.
How I ran it. Four roles: a Director (Talos) for strategy and scope, an Auto Drive Agent that proposes and lands fixes in the working copy under my checkpoints, an Auto Drive Strategist for a second opinion each cycle — and me as operator, routing between them and driving every fix in-game before it counts as done. Kanban board, append-only JSONL ledger, session logs, handovers.
My two biggest builds. They’re where I learned how to structure and run large work, and both are paused: ECO to be rebuilt from scratch with what it taught me, L.I.LY until AI’s laws, rules and pricing settle down. Each has its full job sheet.
I’m showing the early stuff on purpose. These are first attempts, not shipped products. The story is the climb.
I’m not claiming to be an expert in eight languages after nine months. I’m claiming I can move between stacks fast enough to ship in them and to audit them.
A lot of what I ship sits on top of open-source software other people wrote. Picking the right tool, pinning a version that works, writing the glue, and documenting how to put it back when it breaks — that’s a real skill.
Two backup systems. Daily automated ECO snapshots from April 2026, and a separate encrypted Restic system with a retention policy and a documented disaster-recovery flow.
Verification and decision logs as real documents. The last verified entry is the ground truth. Every decision has a record.
Jobsite paperwork, applied to software. A written brief before the work starts, a sign-off before it ships, and a handover the next person can pick up cold. The ETS2LA campaign above shows the board, the ledger and the handovers.