sb4ssman

True Bots

The problem. Game bots are scripted. Players learn the script, and the bot stops being interesting. We set out to replace scripted bots with ML agents that play at human level and can be trained piece by piece.

What I built. We were a core team of three. I was co-founder and COO: fundraising, investor relations, decks, projections, studio partnerships, and the company's admin, taxes and filings.

I also wrote the tools the work ran on. Training Studio was the desktop control panel our ML engineers trained on, 21,000 lines that I hand-rolled piece by piece:

• a live, interactive interface for the YAML training configs;
• a script that extracted the validation rules from ML-Agents itself, so they followed new versions instead of drifting;
• a validator that checked the training environment against them;
• an environment builder that built the right environment when one wasn't there.

Training Studio covered real-time agents. For turn-based games I built the LLM Bridge: a Python tool and a C# Unity plugin that open a channel to a local or frontier model and relay game state and moves back and forth.

What happened. We shipped six public demos and signed two studio partnerships. We were selected for La Guilde du jeu vidéo du Québec's Parcours Innovation cohort (CAD $4,000 and an OVHcloud infrastructure partnership) and for Founder University Cohort 10. The company dissolved in February 2026; my co-founder and I are still on the project.

What I learned. Build for the automation you can see coming. I gave Training Studio command-line and API entry points from the start, because we expected LLMs and agents to drive training before that was a common thing.

Back to the card Open as its own page

1Timeline: the timeline that should exist

The problem. More than once in grade school I had to research and build a timeline of events for a project. Ever since, I've wondered why there isn't a single, unified timeline that everyone can reference. It was my first idea for a venture: this should exist for everyone, and I feel compelled to build it.

What I built. A business plan first, in 2020. Then a proof-of-concept browser extension that detects timestamps on web pages, which I scoped and commissioned from an outside development firm in 2023. In 2026, a Python prototype: scrapers for Wikidata and Wikipedia, a timestamp extractor, an engine that links events by time, place and layer, and a 3D timeline view. Its 26 tests pass. 1timeline.org is live.

Where it stands. I was looking for co-founders for 1Timeline when I met the True Bots founders and joined them, and that took over. I still make progress on it when I have the concentration.

What's next. I don't need convincing that the world is missing this timeline. I need to build it, and that takes time.

Back to the card Open as its own page

Mount Diablo Advisors

The problem. A friend and roommate had just started at a private-equity firm. The firm passed on deals all the time, and we thought those deals deserved a second look: we could take them and shop them to other PE firms.

What I built. The company, formed through LegalZoom, my first time starting one. Over one summer we built the website and started an outreach and networking plan.

What happened. My roommate took another job and moved, and we had to stop. I took responsibility for closing the company down and filing its taxes, and I kept the domain. Since then I've been building a personal finance tool behind it: account aggregation, net worth, and a review of my options positions with an AI that works from a structured knowledge library. It has most of its backend; the live brokerage connection and its security work come next.

What I learned. How to start a company, and how to close one down properly when it doesn't work out.

Back to the card Open as its own page

Capital Market Event: hats for milestones

The problem. Floor traders on the NYSE used to wear silly hats for nominal milestones, like the Dow hitting 25,000. I made a Dow 100,000 hat on Zazzle, and it sold a few. That raised a bigger question: what if a store made its own merchandise?

What I built. The website, and much of the engine behind it. The idea: scour social media for popular memes and turn them into merchandise programmatically. Not just stock indexes: every popular stock could have hats for its milestones, and the engine would make new hats for new milestones as the old ones are reached. A person approves or denies new items at one or more checkpoints; everything else runs behind the scenes. Set it up, hit go, approve new merch now and then: residual income.

Where it stands. The site builds, but nothing is connected or automated yet. Zazzle doesn't offer a suitable item-creation API and requires frequent activity, so the store will move to another maker that sells and ships on demand through an API.

What I learned. I need more time.

Back to the card Open as its own page

FlowNode: guesses are cheap, checks are cheaper

The problem. My partner from True Bots is building AI-enabled engineering simulation software. The existing simulation software is very expensive and hard to use, even though the formulas behind it are public. I took the AI subsystems and the chat, with a focus on running local models, which are limited by the hardware they run on.

What I built. A query's goal is a physically accurate thermal system. So I designed the loop so that guesses come easy and checking them is inexpensive: the harness iterates until it produces a reasonable system that the app can diagram and simulate. That lets a weaker local model reach a correct answer by taking more turns.

Around it: model suggestions that fit the machine's video memory, adaptive context, cache reuse between turns, local-first chat history, structured-output adapters for local and cloud models, and Model Lab, an in-app benchmark that runs models through a gauntlet and grades them against known answers on physical invariants.

What happened. 32 commits and about 38,000 lines between June and September 2026. The product is in development.

What I learned. Local AI is limited by its hardware, so design around the limit: make guesses easy, make checking them inexpensive, and let the harness iterate until the answer holds up.

Back to the card Open as its own page

True Bots

The problem. Game bots are scripted. Players learn the script, and the bot stops being interesting. We set out to replace scripted bots with ML agents that play at human level and can be trained piece by piece.

What I built. We were a core team of three. I was co-founder and COO: fundraising, investor relations, decks, projections, studio partnerships, and the company's admin, taxes and filings.

I also wrote the tools the work ran on. Training Studio was the desktop control panel our ML engineers trained on, 21,000 lines that I hand-rolled piece by piece:

• a live, interactive interface for the YAML training configs;
• a script that extracted the validation rules from ML-Agents itself, so they followed new versions instead of drifting;
• a validator that checked the training environment against them;
• an environment builder that built the right environment when one wasn't there.

Training Studio covered real-time agents. For turn-based games I built the LLM Bridge: a Python tool and a C# Unity plugin that open a channel to a local or frontier model and relay game state and moves back and forth.

What happened. We shipped six public demos and signed two studio partnerships. We were selected for La Guilde du jeu vidéo du Québec's Parcours Innovation cohort (CAD $4,000 and an OVHcloud infrastructure partnership) and for Founder University Cohort 10. The company dissolved in February 2026; my co-founder and I are still on the project.

What I learned. Build for the automation you can see coming. I gave Training Studio command-line and API entry points from the start, because we expected LLMs and agents to drive training before that was a common thing.

Back to the card Open as its own page

True Bots

The problem. Game bots are scripted. Players learn the script, and the bot stops being interesting. We set out to replace scripted bots with ML agents that play at human level and can be trained piece by piece.

What I built. We were a core team of three. I was co-founder and COO: fundraising, investor relations, decks, projections, studio partnerships, and the company's admin, taxes and filings.

I also wrote the tools the work ran on. Training Studio was the desktop control panel our ML engineers trained on, 21,000 lines that I hand-rolled piece by piece:

• a live, interactive interface for the YAML training configs;
• a script that extracted the validation rules from ML-Agents itself, so they followed new versions instead of drifting;
• a validator that checked the training environment against them;
• an environment builder that built the right environment when one wasn't there.

Training Studio covered real-time agents. For turn-based games I built the LLM Bridge: a Python tool and a C# Unity plugin that open a channel to a local or frontier model and relay game state and moves back and forth.

What happened. We shipped six public demos and signed two studio partnerships. We were selected for La Guilde du jeu vidéo du Québec's Parcours Innovation cohort (CAD $4,000 and an OVHcloud infrastructure partnership) and for Founder University Cohort 10. The company dissolved in February 2026; my co-founder and I are still on the project.

What I learned. Build for the automation you can see coming. I gave Training Studio command-line and API entry points from the start, because we expected LLMs and agents to drive training before that was a common thing.

Back to the card Open as its own page

gitSpecOps: special Git operations

The problem. I had a reason to migrate a whole GitHub organization: 50 repositories into a new one. Nobody should do that by hand.

What I built. An organization duplicator: it pulled each repository to my machine, then pushed it to an identically named repository in the new organization. Then I added special operations one or two at a time. As my fleet of machines grew and I worked on projects across them, I wanted to see the sync state of every repository on every machine at once, so I built the sync suggester. Every operation shows its plan before it acts and refuses anything ambiguous.

Where it stands. The Windows command-line tools work. The GUI, Linux and macOS support, and testing across a real fleet are unfinished.

What I learned. Security became essential, and security is hard and a little scary. I want to trust my own tools, and when they find problems in my own code, that's both cool and scary.

Back to the card Open as its own page

Oracle Free Cloud Lab Starter: claim the compute, keep it

The problem. I learned on Reddit that Oracle offers free cloud servers: up to three, two small and one big. Obviously I needed all three, and I knew it was possible to get them programmatically.

What I built. I didn't really know what I was doing; I just knew I needed to claim that compute and keep it. So a management VM comes up first, with a dashboard. It spins up a worker VM, and the worker keeps trying to win the big machine, which Oracle hands out as capacity opens, like a lottery. Anyone can fork it, fill in a settings file, run one script and watch it build itself.

What happened. The lab runs on the free tier. I also learned that my region doesn't offer the big machines at all, so my worker asks for one in vain.

What I learned. Check what your region actually offers before you automate the asking.

Back to the card Open as its own page

Ground Support: rebuild my machine by script

The problem. My laptop was dying. I wanted to pick my work back up on a new one quickly, with all my apps, tools, setup and settings, while the old one still worked. And I want the same setup on practically every machine, so it had to be repeatable.

What I built. A capture of what makes a machine mine: the software, settings, install locations, and the workarounds and the reasons for them, all the things data backups miss. My intended setup is kept separately from what the scan observes. Then rebuild scripts that run in order and state every step that has to stay manual instead of hiding it, and checks that prove the rebuild worked.

Where it stands. I only bought the one new laptop, so I built the kit up and haven't had a chance to run it end to end. I revived the old laptop and gave it a job that didn't need a rebuild. Ground Support is on deck, ready for revision and the next machine.

What I learned. The best time to capture a setup is while the old machine still works.

Back to the card Open as its own page

DCG Taskforce: obsessively installing a guard

The problem. AI agents can touch your machines, and destructive commands are unacceptable. Dicklesworthstone's Destructive Command Guard exists to stop them, but Windows sometimes seems to fight it. The hack fix was simply to install it again: a one-line script.

What I built. So I figured I could install it obsessively. That one-liner evolved into the Destructive Command Guard installation Task Enforcer: the Taskforce. It runs on a schedule across my machines and operating systems, even WSL distributions, takes updates only from the guard's signed releases, confirms the guard's extra features are in place, and does it all at once, obsessively.

Where it stands. It works across machines, operating systems and WSL distributions. If and when the guard itself grows a feature, the Taskforce peels its own version of that feature back and adapts.

What I learned. When something keeps undoing your safety net, automate putting it back, and keep checking that it's there.

Back to the card Open as its own page

Sb4ssport-Alpha: a port for everything I build

The problem. I needed a public shelf: a way to share everything I've built, and to reuse it. I love outer space and the idea of a port, so the name came easily.

What I built. A shelf that also centralizes my own tools. Every repository with an AI agent starts a session the same way: get your bearings, check the working notes and the work log, then ask what we're working on. The agent knows to use the shared tools, like the folder-structure tool, instead of searching blindly. The same parts build this page and its themes.

Where it stands. In progress, opening soon.

What I learned. I want my little ecosystem to be self-similar. My personal organizer takes its shapes and tools from Sb4ssport, and it in turn inspired the shape I use for a family's or a live organization's repository. Everything has to work together, and that takes a lot of polish, plumbing and consideration.

Back to the card Open as its own page

DesktopOpener: tools to build up

The problem. I've been hooked on software since AOL, when I found out you could download new programs that did new things. And every time a computer crashed, I wanted one click that would reopen every app and put each one back exactly where I had it.

What I built. Programming had always been a hobby. I taught myself to program my graphing calculator from its manual, but applications on a PC were out of reach. When LLMs arrived, at the right moment in my life, I taught myself Python, and this was the first project: every piece I needed to take control of my desktop. Open apps, place them, do it again reliably, save the list, open several lists at once.

Every time I hit something I couldn't do, I built the tool for it, and each one became part of DesktopOpener. I needed to measure pixel distances on screen, so I built my own ruler. I needed a better color picker, so I built ColorCatcher. I wanted to search the text in my repos and gather stats on my own work, so I built FancySearch. I needed to know more about the desktop environment itself, so I built the Environment Probe. And I wanted a control panel with shortcuts to the tools I use most. I got fascinated by Python's live console, built my own, and started on a way to multiplex running scripts. The background workers I imagined never arrived, but many of the apps now run quietly from the system tray.

Where it stands. 382 commits since October 2023: the app, eleven tools and a shared set of utilities, about 120,000 lines of Python with its own tests. It is still a work in progress. I want it on every machine I use, which means cross-platform support and more testing.

What I learned. Build the tools you need to build the things you really want. Each tool I built for DesktopOpener made the next thing possible.

Back to the card Open as its own page

Windhawk taskbar mods: Task Manager, always right there

The problem. I almost always have Task Manager open. I like watching my computer work, and I listen to the fans: if they spin up unexpectedly, I'm on it. But I wanted Task Manager in the same spot every time, and Windows made that impossible.

What I built. Task Manager Tail, my first mod: it places Task Manager at the tail end of the taskbar, so it's always right where you expect it. Six more followed. Each one packs more information into the system tray or shows something I think should be there. Privacy Indicator Anchor, for example, always shows the privacy icons you choose, instead of letting them pop in and out and change the shape of your tray. Under the hood, a template library and verification scripts keep shared code identical across mods on a platform that doesn't allow shared libraries.

What happened. All seven are published in the public Windhawk catalog after the maintainer's review, and they have more than 1,000 users.

What I learned. Keeping mods up to the maintainer's standards, for real users, while Windows keeps changing underneath them, is ongoing work.

Back to the card Open as its own page

Orbital Workshop: power modes, one good key, and tools that save an AI's time

The problem. Modern computers all come with power-efficiency modes, and they're always either clunky to reach or missing something, whatever the maker or operating system. Microsoft also gave my keyboard a Copilot key I didn't want.

What I built. PowerCycler fills in whatever your computer is missing: a hotkey if there isn't one, a customizable tray app if there isn't one, access to the modes where the system hides them, and on-screen notifications you can customize too. It shows the mode that's really active, even when a hardware key or Windows changed it, and it listens to makers' own controls, like Lenovo's. Other makers, such as MSI, plug in as we write their plugins; it's set up for that from the start.

The Copilot key: I remapped it to open DesktopOpener. Remapping a key isn't special, but Microsoft giving me a dedicated key for my own dashboard is dandy.

The workshop also holds tools for working with AI. I wrote the folder-structure tool so the earliest LLMs could get the lay of a project without wasting precious tokens searching in the dark. It's still useful: it's the first thing an agent runs in an unfamiliar place.

Where it stands. PowerCycler is an early release with automated tests on Windows and Linux; the macOS app is in progress.

What I learned. Small tools that fill a gap you hit every day are worth building well.

Back to the card Open as its own page

The Shapes: repos that teach any agent how to work in them

The problem. I kept setting up repositories the same way, to give AI agents a library of context that followed me and the project, no matter which agent I pointed at it or which machine I was working from. It needed a name, so I coined one: shapes.

What I built. Repeatable shapes for a repository, an organization and a household. There are several, for different purposes, and decisions keep falling out of them as reusable patterns. Every shape carries one protocol: roles, notes and a log, handoffs, tools and safety. An agent can seed a new repo from a shape, adopt an existing one, check it or retire it.

What happened. I can populate the first scaffolding for a new repo or organization rapidly and by script, so first prompts are that much more meaningful. Each repo built from a shape records the commit it came from, so new behavior I add in one central place reaches every shaped repo and org, and they all get better agent behavior.

What I learned. Consistency is what lets agents pick up where the last one left off. And I just want to share it.

Back to the card Open as its own page

Extrasolar Livery: if I'm going to look at it, it should look good

The problem. If I'm going to look at my software, it might as well look good, or at least be pleasant to use. And we were already blasting off hard with the space theme.

What I built. A paint shop. Each livery is paint only (colors, type and decoration), written against a small, documented set of class names, so a page can change its whole look without changing its layout. There's the Spaceport look, a plain Light and Dark, animated backdrops of the sky, the Earth and the Moon, and open fonts I host myself.

Where it stands. This page wears it, and so does the Sb4ssport shelf. Pick a livery from the menu at the top.

What I learned. Separating paint from layout is what lets one page wear many looks.

Back to the card Open as its own page

SK's Super Slick and Stealthy Save Saver: my first program for someone else

The problem. Subnautica had a bug: at a certain point in the game it could freeze catastrophically and corrupt your save. The game overwrote a single save file, so if that file was corrupted, that was it. You started a new game.

What I built. I was still teaching myself Python, with the earliest LLMs, and I asked for a problem to solve. My sister had a real one. So I wrote a tray app that runs a simple watchdog. It watches the save folder, and whenever the save changes, it copies the file, adds a timestamp, and keeps the copy in a folder you choose. From the tray, a GUI window lets you restore any copy. I typed a large part of the code myself.

What happened. It worked, and it's public: it backs up saves for Subnautica and Subnautica: Below Zero.

What I learned. It was one of the first programs I wrote for someone else. Asking for someone else's problem is a good way to find a real one to solve.

Back to the card Open as its own page

The Tontec screen: an AI agent finally fixed it

The problem. Years ago I bought a Tontec touchscreen add-on to go with a Raspberry Pi and an acrylic case. The screen, its software and its instructions were always clunky. I think it worked exactly once; then I changed something, it stopped, and troubleshooting it was beyond me at the time. The screen and the Pi sat abandoned.

What I built. Once AI agents could act on their own, they became capable of serious troubleshooting. So I pointed Claude at my Pi and the display and let it sort things out. The key find: this board's backlight is active-low, so every stock driver switched it off while the panel was drawing frames perfectly well. With that fixed, plus the wiring, the current display-driver setup and touch calibration, it worked.

What happened. No other guide existed, so we were obligated to share: the recipe is public. The screen now runs Moonbase, my home terminal.

What I learned. Problems that were beyond me a few years ago aren't anymore. Hardware I had given up on came back to life because an agent could troubleshoot it, and it did a great job.

Back to the card Open as its own page

Moonbase: our own home terminal

The problem. My partner and I have a bunch of mismatched smart-home devices. The apps are fine, but we wanted one hub for all of it. I had the old Raspberry Pi and its touchscreen, and the Pi couldn't run any of the modern home hubs. So, again, I built my own.

What I built. A touchscreen home terminal in Python and pygame, with a hand-rolled interface in the style of a starship console. That part was fun. Every screen is built from a display contract, so the same widgets draw into two different frame layouts without knowing which one they're in.

The colors carry meaning, and that's the clever bit. Each theme is a closed set of colors from one era of that console look; nothing outside the set ever appears on screen. Each system gets its color by a fixed rank on a living-to-machine axis: people first, then lights, climate, hubs, calendar, robotics, cameras, network and system. Switch themes and every color changes, but the lights are always "the lights color" and the cameras are always "the cameras color". Status colors come from the theme's own set too. On top of that: contextual menus, and a red button on the case that turns the backlight on and off or shuts the Pi down cleanly.

Where it stands. A work in progress; some services aren't connected yet. But I can touch my lights and stop the Roomba faster, and more pleasantly, than ever.

What I learned. When nothing off the shelf fits the hardware you have, build the hub you actually want, and make it a pleasure to touch.

Back to the card Open as its own page