13,612 karma · joined October 27, 2009
All opinions expressed are entirely my own.
https://www.linkedin.com/in/mike-purvis-6166a42/
https://meet.hn/city/ca-Kitchener
[1]: https://www.alltrails.com/trail/canada/ontario/harrison-trai...
A lat/lon/zoom/start?/dest? is kind of what a Google Maps share currently is, but it's neither an interoperable standard nor a reliable capture of the current state, so really the worst of both worlds.
(Also, hi AB! Nice to see you on here)
If I'm sending a screenshot it's because I want to send exactly what I see on my screen and not have my recipient's gmaps instance happily recompute a route it thinks is better or leave out the routing information I included, or switch from biking to driving directions, or whatever else.
I feel like this is kind of subagents, but it doesn't have the clear task -> work -> return result -> die model, rather it's more closely aligned to how I myself multitask, maintaining several long-lived threads of execution, and having to intentionally "forget" about the other ones when it's time to lock in and do real work on the most important one.
I don't think I want a gastown-style "just yolo everything" approach, in fact I really want more control over how decisions are made and with what info. Does this exist?
And in the morning, I have patches for the new version that pass the test suite.
Like, problems that I would previously dig into on my own, poking at this and that log file to try to understand what happened to get a system into a particular state, now claude is mediating most of those kinds of interactions and it is the one doing the first pass surfacing of "okay I discovered X, Y, and Z things that are hinky, and I'm not totally sure yet what this all means, but let's look together."
Nowadays I feel almost naked looking at a terminal where I'm typing each character myself. A lot of the old instincts around tab completion and grepping through the --help output of every tool, all that stuff has atrophied somewhat. Maybe that is genuine skill decline?
Or it's something about your own connection. Maybe an ad blocker? For me, the redirect works:
$ curl -IL logitech.com/mx 2>/dev/null | grep http
Location: https://logitech.com:443/mx
location: https://www.logitech.com:443/mx
location: https://www.logitech.com/en-ca/mx.html
(I have the Mechanical Mini keyboard and the 3S Anywhere mouse; I like the MX product line.) $ curl -I https://www.nsf.gov/pubs/1998/nsf9814/nsf9814.htm
HTTP/2 404
content-type: text/html; charset=UTF-8
content-length: 54737
date: Sun, 09 Aug 2026 17:58:44 GMT
strict-transport-security: max-age=31536000; includeSubdomains; preload
server: ApacheI'm using a PCIe expansion card to get double NVMe drives for the cache disk, and then three (up to five) 3.5" spinning 8TB drives for long term.
I tried really hard to get it on 32GB but sadly the motherboard only has two slots and only supports 8GB DDR3 modules. I literally ordered some of the rare late-generation 16GB ones and it refused to boot, with no firmware updates available from the vendor (Advantech, board is an AIMB-274).
As a result of that, in "production" we still actually delivered full rootfs images just to be absolutely certain, and the delta upgrades were for smaller test fleets that could updated hourly just via simple push tooling.
If I was building it from scratch though, I'd probably just do NixOS + colmena, and do a push model forever. It's not worth the saved SSH connection to not have those logs and status messages coming back to the central coordinator immediately.
At the time of that talk we threw up a lightly sanitized version of the tooling on github. The basic idea was that there were these two repos:
https://github.com/clearpathrobotics/nix-ros-base
https://github.com/clearpathrobotics/nix-ros
The first was the "toolkit" repo that had all the manual maintained dependencies and functions, while the second was a managed repo which would have tags pushed to it by the pipeline.
So basically all the repos had a push hook attached to them that would run this centralized dispatch workflow (on Jenkins, but it could be anything). The dispatch job would sanitize the branch name like joey-b/fancy-feature and attach it to the most recent "released version" + devel timestamp, so you'd end up with like 2.25+20260808-12345+joey-b-fancy-feature, and that would be pushed as a floating tag to the nix-ros repo with all the sources from the hundreds of participating repos either locked to the versions set in the top level 2.25 devel branches or to the specified feature branch, so that a given build could pull together multiple same-named branches from across repos. That would be sent off to Hydra, and nix2container outputs were also built that went to simulator based validation.
But the end UI was pretty nice, basically a nix configuration mapped the names to the those repos so after the build was done you could just pull it and "enter the workspace" environment like:
nix build ros/2.25+2026080-12345+joey-b-fancy-feature#setup
source output/setup.sh
And if you were hacking on the "base" repo itself, it was very easy to pass flags like --override-input base=ros-base#some-ref or path/to/local for quick iteration.Anyway, as I say, I'm obviously proud of what was achieved, particularly in a pre-LLM world, and the experience of building this has given me many of pg's blub experiences over the years, where I look at the ways that other build and packaging systems solve these problems and think yes, yes I can see how that works, but also, I have experienced a world where in exchange for some relatively minor strictness tradeoffs, the set of problems that that is solving never had to exist in the first place.
For that work project though, the final closure was thousands of store paths, with hundreds of source repos being brought together across a multiple of languages and build systems. A lot of that was/is essential complexity, just the reality that robotics is hard, the tools aren't as mature as in other domains, and so you have to be able to develop features and bugfixes all over a huge software stack simultaneously. Doing that with conventional tooling basically gets you a rigid world where you have to tag/release intermediate packages all the time just to get changes into testing, or you have to build the world on every push (lol docker).
With input addressing and hermetic building of the intermediate stages, Nix and Bazel are systems that don't make you make that choice.
In my mind, Nix was unstoppable, and I particularly loved how empowered I imagined developers would feel. No mystery-meat CI scripts pushing packages to distant infrastructure that no one understands or even has the permissions to interact with, just the entire build system in one repo, trivially cloneable and hackable... add patches or build steps to anything and it's the same build as always, build it locally or send it to Hydra, it doesn't matter.
A devs "got" it and did leverage those things, used PRs to do safe evaluation of bumps to core dependencies, but I think on the whole it was regarded as cool but not tractable, and a few years after leaving, it sounds like plans are being laid to replace it all with something containers or whatever.
Very frustrating, particularly in a world where it should be trivial to identify the 5-10 typical tasks that people want to do with the nix code, and set up Claude skills to handle those. Given how easy and self-contained the build-test loop is, it feels like an almost perfect fit for agent-led development.
This tension has arguably been a contributing factor in the collapse of the ARC Raiders playerbase, with a huge population who joined primarily to shoot and loot the robots eventually confronting the realities of a pvpve game, and peacing out for good after getting shot in the back or ambushed too many times.
It doesn't look like you're building directly on openclaw, so is that coming from a place of different goals or philosophy, or what?
I assumed that's what openclaw basically was, but is Orb different from that? And is it fundamentally a different model from the request/response, or is it just request/response in an autonomous loop?
No transcoding, no weird codec issues, just the raw files direct streamed from the underpowered Unraid box, into the back of the AVR where the audio is handled correctly and the video is sent to the screen.
Here's a recent example: https://www.etsy.com/ca/listing/4509158065/corner-wall-shelf...
Ironically, ChatGPT is decently good at ferreting these out. Like I sent it a screenshot of that listing and it not only helped me find where the original item was for sale, but also pointed out how the dimensioned diagram shows it as being just 49" tall, whereas the "in real life" image looks like it's at least six feet, based on it coming up over the top of the picture frame.
I ended up engaging a local woodworker to make me a piece like it instead. Obviously an order of magnitude difference in price, but it will actually be real solid walnut and finished to match my dining table.