frio

Even well-supported, well-documented projects. I'm in the middle of a Spring Boot upgrade, which includes a collection of Hibernate updates. These are well-supported projects with -- theoretically -- fantastic documentation. But when something goes wrong, trawling them for what's happened is tedious and doesn't teach me much; you end up chasing down uncommon threads. The death of StackOverflow doesn't help much either. Previously, web searches might have found a commiserator, but that's all gone now.

A concrete example: during one of the updates, previously working code started throwing an OptimisticLockingException. Only in one place, annoyingly. My thought was that Hibernate was more strict about something it had previously been lenient about. I went down two or three false threads in the docs; I debugged the old version and the new version and read the guts of Hibernate but couldn't figure out why the persistence path had changed so significantly (or why it'd throw an OptimisticLock, it was saving a brand new row!). I was really struggling.

I set Opus on it, and it found the relevant section of the docs and zeroed in on the issue in the code: we were generating and setting an ID on a class that had an annotated @GeneratedValue. Old Hibernate said "whatever"; new Hibernate changed the persistence code so in this situation it calls `merge` instead of `save` (update rather than create AFAICT); there was no existing entity with the generated ID (of course, it's a new entity!); it fails.

While my hypothesis was broadly right, that _particular_ issue would've taken me days to chase down -- but the LLM correctly diagnosed in minutes with links to relevant documentation.

I vaguely hate LLMs, but this one saved me from a days long side quest that would've held up delivering the actual value of the project. I hope this doesn't sound like my brain is no longer functioning.

(edit -- reading it back I'm starting to write like one of the fucking things, which is probably the part of them I hate the absolute most)

I love my Forma. The only thing about it that makes me sad is the micro-USB port. I skipped the Sage because it was a side-grade (USB-C but worse battery), and now they've discontinued it with no clear future for the format.

I really hope they bring back a similar format ereader in the future, I don't really want to go back to a smaller scale device when this one dies.

Yeah. I guess what I'm saying is that I feel like we're all still stuck debating these things on technical merits alone. The `bun` rewrite and `pgrust` both expose something -- I find, at least! -- uncomfortable about how we understand the technical side of our profession, but I think the social side remains the same.

Thanks, I'll take a look!

I think what folks want, but aren't quite able to articulate, is an ongoing community and effort that indicate a project will be healthy and maintained. We want to be able to rely upon the software that we are choosing to use.

Regardless of the technical choices, whether Rust is better or worse, whatever -- pgrust popped into existence thanks to one person driving an LLM through 7000 commits in ~2 weeks. It produced something that passes the regression tests. Even as an LLM-sceptic, I think that's amazing.

From that point, though, it appears to have been completely abandoned. There hasn't been a commit in a month, other than a brief tweak and a note that an as-yet unpublished version that's even betterer is in the works. IDK. I don't think we've acclimated to the shock of the change LLMs create, but if the outcome is a forest of exciting new projects that have a bus factor of 1 and little to no collaboration, I think that's a disservice to this profession.

Exciting, but I’d give a lot for an equivalent to Django. There are very few problems I need to solve that are fixed by htmx style “full stack” apps, but many that are solved by the generated admin, authentication framework, caching, eventing etc.

Unfortunately, you end up bound to Python’s poor performance and poor typing stories, which Rust solves in spades.

I keep coming back to this https://tombedor.dev/human-attention-and-human-effort/

The number of things that make it to the top of HN/Reddit/wherever now that are devoid a human's touch is exhausting. Whether it's a site that's got that Claude frontend smell, or a repo that's got a burst of 10 claude commits before getting shared and abandoned, or a series of blog posts that were written by LLMs... it's all, at this point, a flag for me that the human behind the LLM doesn't really want to engage with others or share; in some ways it dehumanises their entire (supposed) audience.

IDK. Maybe having Claude contribute writing about something novel to the general blogosphere is useful in some dimension, but it usually gives me no confidence in the truth of the post.

Of all the things LLMs do, one of the most fun is that they help you get over that hump of activation energy for an idea. We all have limited spare time, and going from "hey this might be cool" to a working prototype in minutes instead of days is intoxicating.

Much like my own heaving ~/prototypes folder, there is an avalanche of small projects other people are building in their own spare time (with LLMs), and there is a subsequent avalanche of "check out my cool project" posts. This is cool! However, unfortunately, almost universally, there is very little follow through. If you come back to those projects after a month, most are abandoned.

The creators of the ones that tend to last, at least in my brief experience so far, _do_ write useful blog posts by hand, or put a bit of human effort into sharing what they've built. I guess when I encounter someone sharing their work by way of blog post, it feels to me like they don't really care about actually sharing that work.

Also -- and this is much more a me thing -- I'm just fucking tired of reading Claude's writing. I have to work with Claude most days, and seeing it take over the whole internet is suffocating. Inflicting more of it on others just sucks.

I am bone tired of slop. This looks like a useful thing to build (the cameras in existing closed source robo vacuums creep me out), but when people don't even write their announcement blog post by hand it gives me zero confidence in the project getting anywhere meaningful.

Perhaps not the place to share this, but it's depressing. I hope this proves me wrong.

16GiB Raspberry Pi 5s in my country are now going for ~$450USD, so I've gotta say that's out of reach for me now :(.

A lot of unit conversions are just built into Kagi (and Google!). "Searching" for "10nzd in usd" gives me a price, "10kg in lb" gives me a converted unit, etc.

The harness clamps what the agent can do. `bash` allows full code execution; a dedicated `mvn` tool might only allow `mvn compile` but not `mvn spring-boot:run`. You could probably implement this with an `allow` list attached to your `bash` tool, but by doing it this way, you can enhance the outputs or perform mandatory checks too.

For instance, Claude likes to run little Python scripts; reviewing them is tedious. Removing `bash` and adding a `python` tool would allow the harness to pre-review and grep for common harmful patterns, or run the `python` script in a `krunvm` or `muvm` to isolate it, etc. This review/isolation would be handled programatically as it's part of the harness; leaving the agent to choose what to do as a skill means the agent can conveniently forget to enforce its own checks.

Mine hasn't actually arrived yet! I'm still waiting for it in the mail. I don't think I'll tweak that much, all I really want to do is flash the published open source firmware, attach it to my tailnet and use it to control a little server I keep in the crawl space under the house (because crawling under there whenever it needs a reboot + entering disk encryption keys is distinctly unpleasant).

Possibly, I'm not really interested in learning Zig though (or learning to embed it in Rust). I'm sure that'd be a cool project for someone else to try :).

Unfamiliarity and I believe it requires a compile step. I’m at least familiar with Typescript and Deno so being able to embed them was an appealing idea :)

Yeah, it's been a bit of a dead end. I didn't want the heavy runtime but felt it was worth disproving after experimenting rather than ruling out off the bat. Even before getting it running, the dependency list alone was pretty discouraging, especially given the storm of supply chain attacks these days.

Rhai looks nice, I'll take a look, thanks! And good luck with Zerostack.

I've been trying to use `Deno` underneath `Rust` so that the tools can still be written in Typescript and thus self-mutated without the compilation step (but I can still try to do clever things with V8 Isolates or similar). It's been an ugly experiment so far; I'm vaguely thinking a simpler model would be to just define a binary "API" and run tools by exec-ing binaries.

Yes, that aggravates me too. I noted recently, Claude had a phase where it would write little one-off Python scripts to aid it in analysis -- which is super useful! But when it's written ten scripts in a row, each of which I've had to review and each of which I've had to approve by hand, it gets pretty annoying. If I could bless it with "if it only uses these Python libraries, pre-approve the script", that would've made life a lot simpler, but of course, that's not possible. Sigh.

Thanks, I've been tooling away in my spare time on my own version of this -- both to get a deeper understanding of agents (everyone suggests writing your own) and to help learn Rust. I'd like to retain `pi`'s configurability though, the ability to self-mutate and generate new tools is incredibly useful, particularly because I don't think any of these things should have access to arbitrary code execution through `bash` (of course, if they have access to, say, `edit` and `cargo run` they still have arbitrary code exec, but...) (so I tend to generate tools on the fly when I encounter something the no-bash agent needs to do).

I feel this a lot too these days. The only place the fun seems to remain for me is in Linux and in devices out of China, that you can hack and experiment with — like the Anbernic consoles, or the Xteink X4, or the little mp3 player DAP things, or the Sipeed NanoKVM devices, or the Supernote. The Steam Deck probably sits in this niche too, now I think about it.

Alongside the purpose they serve, all of them can be trivially broken into and re-tooled however you like — and for me at least, that’s where a lot of fun lies in computers. When it comes to mainline desktops now, everything is incredibly expensive and deflating.

The harnesses we have are almost stunningly incomplete IMHO. I've been trying `pi` recently, and quite like that it comes with a minimal set of tools by default -- and that I can easily override or replace the ones that it ships.

I've only just started working with it, but clamping `read/write/edit` to only allow editing files in the current directory, banning `bash` and mandating I write tools for the specific commands I want it to execute, has made me much happier. Running Claude inside a VM or similar to sandbox it is nuclear overkill; I've always been surprised that that's seemed like the state of the art.

With a better harness, the model can't choose to rename things with search and replace; if it wants to rename things, it _must_ call the LSP to do it. If it's going to write code, as you suggest, the harness _forces_ linting/formatting to run.

(Reading my own comment back, I am worried that the fucking AI writing style is infecting me :()

I've always thought of it as lightweight, but checking it now, wow.

I also disliked that and discovered you can toggle it with config now :).

I use the television task described here (https://zed.dev/blog/hidden-gems-part-2) for that experience :)

If you want an e-ink type screen, the Supernotes (or Remarkables, or Viwoods) are all very good at this. Personally I hate trying to read things on iPads.

A good way to think of it is that jj new is an empty git staging area. There's still a `jj commit` command that allows you to desc then jj new.

This always made me feel uncomfy using `jj`. Something that I didn't realise for a while is that `jj` automatically cleans up/garbage collects empty commits. I don't write as much code as I used to, but I still have to interact with, debug and test our product a _lot_ in order to support other engineers, so my workflow was effectively:

    git checkout master
    git fetch
    git rebase # can be just git pull but I've always preferred doing this independently
    _work_/investigate
    git checkout HEAD ./the-project # cleanup the things I changed while investigating

Running `jj new master@origin` felt odd because I was creating a commit, but... when I realised that those commits don't last, things felt better. When I then realised that if I made a change or two while investigating, that these were basically stashed for free, it actually improved my workflow. I don't often have to go back to them, but knowing that they're there has been nice!

All of our expectations for control over our phones are completely out of whack compared to other computers.

I would, sadly, challenge this. If anything, our desktops and laptops are the exception now. Phones, TVs, game consoles, set top boxes, cars, Amazon echos, ebook readers, tablets, security cameras, autonomous devices like vacuum cleaners — when I think of the myriad devices we interact with that have a computer in them, they are all as stringently locked down as possible.

Nuclear fusion?

“PHP was so easy and fast that they’ve built such a successful startup they now have scaling problems” is, as far as I can tell, an endorsement of PHP and not a criticism of it.

I do wonder if LLMs will see tools like immudb (https://immudb.io/) or Datomic (https://www.datomic.com/) receive a bit more attention. The capacity to easily rollback the state to a previous immutably preserved state has always seemed like a fantastic addition to databases to me, but in the era of LLMs, even more important.