August was the month I stopped pretending I could hold my project portfolio in my head.
Roughly 1,900 commits landed across 35 repos in five GitHub orgs. About 1,050 of them were mine. I published a stack of posts, three of them course launches. I could not have told you any of that from memory two weeks ago, and that turned out to be the actual story of the month.
That chart is generated, not recalled. More on why that matters at the end.
🚀 The headline: the courses went live
My research dumping ground finally turned into product. Three free courses launched in a single week, with a fourth waiting in the wings:
- Port a Classic Java App to Rust (Aug 12): JPetStore rebuilt on Axum and SQLx, through deployment with Litestream and Caddy.
- Build a Chess Game with Rust and WebAssembly (Aug 13): a wasm engine, a Lit board, and Playwright proving it in a real browser.
- Two DuckDB WASM courses (Aug 15): a real SQL engine in a browser tab, from worker contract to end-to-end tests.
- Build HuddleWire (coming soon): production web meetings in Rust and mediasoup. It’ll be my first paid course, and the only one of the batch I’d call advanced.
All of them come out of the same pattern, and it’s the only one I’ve found that doesn’t produce a fake tutorial. I build the tinkering repo first. I write tests until I’d defend the thing in a code review. Only then do I go back and pull the lessons out of the commit history.
The commits are the curriculum. I don’t write the lesson and then invent code to match it.
HuddleWire is the one I’ve been circling longest, and the one that will finally make me charge for something. The premise: a meeting app is two systems that happen to share a screen: a control plane that decides who may do what, and a media plane where browsers push encrypted RTP to an SFU over a network path your reverse proxy never sees. Most WebRTC tutorials blur those two together, which is exactly why most WebRTC tutorials stop working the moment you deploy them. This course refuses to blur them, and it ends on a real deployment, not a localhost demo.
That’s all I’ll say for now. If Rust, WebRTC, and shipping things that survive contact with real networks is your corner of the world, it’s coming soon.
🏭 A software factory, in Rust
The biggest pile of new code this month is one that wasn’t anywhere in my July plan: software-factory-rs, 182 commits. Give it a plan; get back a verified, merged codebase.
Here’s the problem it exists to solve. Coding agents are good at tasks and bad at projects. Left alone on a project they drift, over-scope, and report success they haven’t earned. The usual fixes reintroduce the bottleneck the agents were supposed to remove: an orchestrator agent to babysit them, permission prompts, a human reviewing every diff. The factory bets on three inversions instead.
No orchestrator. Work is a dependency graph in a Beads ledger. Stateless workers pull whatever is ready and hold a lease while they hold it. A dead worker’s lease expires and the task goes back in the pool. Nothing babysits, and nothing is a single point of failure.
Done means verified. Every task gets an executable check written before any code exists. A Verifier with no LLM in it runs those checks verbatim in a clean worktree. An Integrator, also LLM-free, rebases onto main, runs the project’s own checks, and is the only thing allowed to push. Models propose; verification disposes.
Full autonomy, but only inside the rig. Agents get unrestricted tool access, because that’s where their productivity comes from, but only inside a rootless Docker container with default-deny egress and no host credentials. The container is the blast radius. The git worktree is the unit of concurrency.
The whole thing is typed, railway-oriented Rust: five roles (Planner, Worker, Verifier, Integrator, Steward) around one total state machine, where every failure is a typed value that says what to do next, so an incident is something an agent or a person can act on rather than a log to read. Workers run Claude Code, Codex, or OpenCode against any OpenAI-compatible provider, and a browser console shows live epics, incidents with evidence, and one-click retry, re-plan, or stop across rigs. The repo also holds itself to the standard it enforces on its targets: an 85% coverage gate, a 90% mutation score, and docs that are the system of record.
By the end of the month I’d started pointing it at real targets. Every BlueClaw repo picked up a .factory/runtime.toml rig config and a web-e2e runtime that runs component tests in Chromium. The factory building my products stopped being a thing I only talk about.
🧠 Beads went from a tool to the substrate
I wrote about Beads on Aug 19 as the memory layer coding agents are missing. What I didn’t say, because I hadn’t finished proving it, is that by then it had quietly become the layer everything else sits on.
The software factory doesn’t have its own task model; agents pull from a Beads ledger. My new project-management system doesn’t have its own task model either; every project is an epic in Beads. Livepeer Modules closed an 18-child epic through it. Nusend, crdt-bind, and Ziply Games all run their backlogs in it. I also published a Beads agent skill, verified against bd 1.2.2, so my agents stop rediscovering the conventions every session.
This is the first tool in a while that got more useful the more places I put it. Most don’t.
🎬 Livepeer: simplifying the stack
231 of my commits went into the Livepeer Modules rewrite, most of them on the tasks/lpm-v2 branch.
The goal is narrower than the commit count suggests: make it genuinely easy for an operator to deploy apps and capabilities onto the Livepeer network. Right now there’s more stack between an operator and a running capability than there needs to be. Plan 0043 was the big cut: the registry daemon moved to the protocol envelope, and the broker dropped describe-polling, quarantine, and offering-metadata hydration it no longer needs. The open clearinghouse got lossless payment route snapshots and proactive work-ID rotation.
Deleting the render/apply path felt better than any feature I shipped this month.
On the entity side, the Cloud SPE’s engagement with Livepeer’s Network Engineering SPE kicked off Aug 25, with milestone planning done and a Build Track architecture package under joint review through December. I also rewrote the demand-generation proposal around the Easy to Build track, which is the same instinct as the branch above: fewer things, aimed better.
🦞 BlueClaw stirred
BlueClaw had been quiet since July. Late August woke it up: Alibaba Cloud reached out about enabling their recent models on the platform.
Worth restating what BlueClaw is, because it’s about to matter more. You pay in USD and run AI jobs (LLM, image generation, audio transcription, text to speech, rerank) against OpenAI-compatible endpoints. Underneath, the compute comes from an open pool of GPU supply, purpose-built to put commercial GPUs to work on AI inference, which is what lets it undercut the big clouds without burning venture money to do it.
The timing conviction got a lot less theoretical this month: Stripe agreed to acquire OpenRouter. When a payments company buys an inference router, it’s telling you the routing layer between apps and models is real infrastructure with real enterprise value. That market will be crowded and brutal, and I’m building in it anyway, because BlueClaw’s niche (an open supply pool, USD billing, no lock-in) is a corner of it the big providers structurally can’t occupy. My hope for BlueClaw is exactly the OpenRouter arc: carve out the niche, earn the volume, and build something an acquirer eventually has to take seriously.
The strategy from here is simple to state and slow to execute: build the software, make it scalable, and keep growing users and usage. No announcement moments, just a platform that works for more people every month until the numbers make the argument for me.
📱 SpeedyBird and Dayflo: the research posts came due
Early August I published four research posts in six days: AT Protocol, A2UI, A2A, and the Microsoft Agent Framework. Writing them was the point, but they weren’t supposed to stay theory.
They didn’t. Most of my SpeedyBird work on Dayflo this month was UI, and A2UI is now in it rather than in a blog post. Agents emit a declarative UI description instead of markup, and it renders natively. Alongside that: progressive web app work, browser notifications, and badges, which is the unglamorous half of making something feel like an app people actually open.
It’s the same argument as The Platform Is the Framework, applied where it costs something. Notifications and badges are platform APIs. Shipping them properly beat shipping a framework that wraps them.
The rest of Dayflo was correctness, not polish: calendar-feed ETag behavior that was auto-bumping when it shouldn’t, a stale-feed remedy, one tap issuing two calendar links, and a WebKit test project that immediately found two real bugs.
👨👦 M2Z Design starts calling, and one more campus
In July I said I’d write about M2Z Design once the launch sprint hit a gate. It hit one.
The business my son and I started builds custom websites for trade businesses. That was vague in July. It isn’t now, because he went and did the research: which trades actually have websites, and which don’t. The answer pointed at plumbers, so that’s where we’re aiming. We built a template, stood up m2zdesign.com and a phone line, and verified the contact form end to end including the honeypot and the failure paths.
Then he audited real businesses and came back with a list of 20 leads: businesses with no site at all, or a site doing them active harm. Two got disqualified on review. The rest are who we’re calling.
The part I care about isn’t the leads. It’s that he produced them. I didn’t hand him a market; he found one, and he can explain why. We also built a sales role-play kit (scripts, objection handling, and five character cards drawn from actual leads), because I’d rather he hear “we already have a guy” from me first than from a stranger.
We also made one more college visit, back to East Stroudsburg, the last of the summer. Every campus we’d seen was empty. This one had classes in session and students on it, and it turns out that’s the entire difference. He saw the place working instead of the place staged.
🧵 Everything else, honestly
- The Zoop Troop: thezooptroop.com launched, with search-led service pages and paint-performance work. No customers yet. The pipeline exists now, which is not the same thing, and I’m not going to pretend it is.
- crdt-bind: 38 commits of local-first framework work, five example apps, and a POSITIONING.md that finally says who it’s for.
- Ziply Games: multiplayer hardening closed out, an all-games catalog page, and PeerJS ICE configuration.
- namesmith: a brand-name generator that probes registries before trusting their 404s.
- html-tags-com: sitemap lastmod derived from each page’s real git history, and a refusal to trust shallow-clone dates instead of silently using the wrong one.
- Livepeer protocol explorer and network bot: two small fixes, both the same lesson: a 404 from a profile endpoint is not a reason to drop an orchestrator or kill a digest.
🧭 The meta-project: a system of record
Twelve concurrent projects is well past the point where attention allocates itself sensibly. I’d been telling myself I had a handle on it. I didn’t.
So August’s last week went into a private project-management repo, and it’s the most opinionated thing I built all month. Two systems with strictly separate jobs. Beads owns every unit of work (projects as epics, tasks, blockers, what’s ready next) and never holds narrative. A docs/ tree owns the why (briefs, priorities, decision records, ritual outputs) and never holds task state. They cross-link by ID, and a lint script enforces the link in both directions so the two can’t drift apart quietly.
Attention is modeled as horizons rather than priorities: surge (daily progress expected), active (touched every two weeks), simmer (parked on purpose). Surge is capped, and an active project that goes 14 days untouched gets flagged as starving; I then have to touch it, demote it, or drop it with a written reason. The whole design is aimed at one failure mode: a project stalling by accident rather than by decision, and nobody noticing for a month.
Reporting scripts sweep every repo in every org, on every branch, deduped by SHA. That last part matters more than it sounds. The sweep caught work living only on feature branches that default-branch stats never see, and two sizable repos that weren’t attached to any tracked project at all. That second one bothered me more than I expected. I’d written a fair amount of code I couldn’t have named on demand.
The structure follows OpenAI’s harness-engineering writeup, the same source I leaned on for the blog repo’s docs in July. Agents only know what’s in context, and what isn’t in the repo effectively doesn’t exist. That’s true of me too, apparently.
Four decisions are on the record already, including one I didn’t expect to write: the surge cap went from two to three. Not because I got more capable. Because two was a number I’d made up, and the system caught me routinely violating it.
🚧 September, in one line
Turn the Alibaba models live on BlueClaw, keep the Network Engineering SPE engagement on schedule, get Ship the Port written now that all nine checkpoints are verified, and let the factory earn its keep.
The first of those is the one I’d underline. If the OpenRouter acquisition means what I think it means, BlueClaw is the project on this list with the biggest future, and it’s where the surge attention lands this fall.
Ask me in thirty days whether “let the factory earn its keep” meant anything.
That’s August. Three courses out the door and a fourth teased, a lot of infrastructure I built because I got tired of guessing, my son finding his own first 20 leads, and the first month I can account for instead of summarize.
Find me on X, in the Livepeer Discord (#orchestrating, @mike_zoop), or at [email protected].
Mike