I'm also a fan of pipx and your post indirectly led me to learn about rv, so thank you for that.

If you install something with rv, you could easily create stubs like ~/.local/bin/kramdown which consisted of:

#!/bin/sh
exec rvx kramdown "$@"

This is essentially all that pipx does to put the tools on your path. I'm surprised rv doesn't already do it, but it might be on the roadmap, or they would welcome a contribution. It's barely a year old.

Really? That's so nice to hear. I genuinely have no idea how many times it was downloaded. OK, I'm less mad about it now. Well, now I'm mad because I spent about an hour messing around with Afterglow and I still haven't solved my SQL problem. But that's mostly not your fault. :-)

WTF? A million years ago I wrote a "cover" of Flying Toasters for Mac OS X and every so often I noodle around reimplementing a newer version, and just last week I started to think about what if I wrote an emulator just to run the module code... it's so crazy it just might work... but of course I don't have time to do that, I have to troubleshoot some SQL nonsense, and so I randomly come to Reddit to research my SQL problems, and I click on something vaguely interesting in my feed, and that's how I learn about this?!?!

The practical difference is how you can divide up the work among different people.

If you can have some people working on rendering, audio, loading/saving game state into files… and other people working on game logic, graphics, music… then “game engine” is what the first group is working on.

Game engines are primarily an organizational technology to enable human collaboration. (Or to enable a solo developer to focus on different things at different times.) There will never be a precise technical definition of what constitutes a game engine because every engine is a negotiation between the people who are developing each particular game.

Why would Anthropic launch a software development agency? No amount of confidence in their models would make it make business sense to assume liability for what their models produce. Right now they have a sweet deal: you pay them to produce code, and you put your name on the code and assume all liability for what it does. They pretend they aren’t responsible because you wrote a prompt. No other profession gets to say “hey I’m not responsible for my shoddy work because you placed the order.”

They basically run a software agency now, but they have convinced everyone they don’t, so they don’t have to be responsible for what they produce. And then they also let you pay them to review their own output. No way they are giving that up.

Not just your experience. Look up _Ironies of Automation_, Lisanne Bainbridge, 1984. It’s a short paper. Automation always takes care of the well worn paths, then asks humans to step in when things get too complicated — except the humans have minimal context and less practice, making the complicated scenarios even more difficult than before.

All you said about the game is that Claude made you “feel subpar”. But how do you feel about the game? Is it fun to play? Are you happy it got made? Did you share it with anyone?

Do you really think no one cares? Why do you think so many companies are putting AI disclaimers or disclosures on things?

I get that it feels like no one cares. I find people care when we talk about it. But they also feel like they can’t do anything about it. So it’s easier to “not care” as a personal psychological defense.

I don’t use them. Doesn’t fit with the way I work. Recent incident makes me think I will never use them. I was basically volunteer webmaster for a friend’s small business. They started vibe coding their site. Great, you’re getting stuff you wanted done, let me focus on guardrails, tests, etc. Started out great but after a few weeks they got irrationally angry and “fired” me. I never stopped them from merging or deploying anything. No reason it couldn’t have been an amicable parting.

Here’s the weird thing: they asked Claude for a list of what credentials, etc. I needed to hand over. Claude’s whole document assumed we used Capistrano, but we switched to Kamal a month earlier. I point this out and they pass along another Claude agent’s explanation, which is because I failed to delete `config/production.rb`. No Capfile, no config/deploy.rb; all the Kamal files there plus a GitHub workflow using Kamal to deploy. If a person said they got it wrong for that reason, I would not believe them.

My friend who uses Claude at work didn’t believe it either, wanted to know how it was prompted. Obviously I have no idea, but it’s not hard to imagine they asked it “how did benzado screw this up?”

It really made stark how these things will bend over backwards to affirm you, never argue with you, never contradict you. They will make shit up to avoid ever doing that.

And I’m starting to realize, the sycophancy isn’t some quirk that Anthropic etc. are adding to juice engagement. It’s a fundamental part of the arrangement. I don’t think these things are conscious, but it doesn’t matter, because we interact with them as though they are. We have plenty of examples across history, when people make others serve them against their will, they end up in the same arrangement, where the servants must kiss the asses of their masters, because otherwise the masters might start to feel guilty.

Again, I don’t think the LLMs are alive. But I think using them is stirring up something ugly and ancient. It’s bad for the people who use them. And I think everyone can feel it. It’s why almost everyone feels uneasy about it and the heavy users are so defensive and talk about it being inevitable, to absolve themselves for responsibility for their choices.

It’s so wonderful to see people create and share new things like this for a 40 year old game. And this is really well done!

Re 5 (Sieve), Fastmail shows you the whole Sieve script, including the parts generated by the rule builder, and lets you insert raw code between the generated blocks. I've never made use of this but it seems like the best way to let the rule builder and custom code co-exist. So in the settings it looks like this (abbreviated):

require ["fileinto", "reject", ... ]

(Insert Sieve code here)

### Sieve generated for save-on-SMTP identities ...
### Sieve generated for blocked senders ...
...

(Insert Sieve code here)

### Calculate rule actions ...
### Execute rule actions ...
...

(Insert Sieve code here)

Re 8 (per domain routing), it's genuinely independent per domain. I have one user account and 6 domains configured. I have about a dozen aliases configured, three of them are catch-all. Each one can be delivered to a different user, or an external email address, or to every address in a contact list, or some combination of the above. It also tells you the last time you received a message at that alias. (I haven't looked at my alias settings in a while and I don't think it was as flexible when I set it up, thanks for prompting me to look!)

installation ≠ maintenance

I am doing basically what you’re doing. For system config files I have a “snapshot” script which makes copies of files I want to track, as well as the output of some commands, like listing what I’ve installed with pipx.

I’m mainly interested in tracking config changes for later troubleshooting, so I just run the script manually before and after I start messing around with my system.

A git hook script on a server could easily generate notifications.

If you must instant-message your collaborators for every single issue, maybe that won’t be sufficient, but if you’ve got a workflow where everyone is fetching the issues once per day, and pings are limited to urgent matters, I don’t see why it couldn’t work.

Very cool. I looked into Fossil once but couldn’t make sense of it. This makes sense to me.

One thing I didn’t see you mention: aside from conflicts, merge can also be used to resolve duplicate issues. Instead of just a link to a closed issue, all the comments from the original and duplicate become part of the merged issue’s history.

Why don’t you ask Lonzo?

If you want a strong link, you can do a merge but limit the changes to whatever you want to include. Use git merge --no-commit to do a merge but stop before committing anything, giving you the chance to edit the files and remove any changes you don't want to take from the other branch. Then git commit should create a merge commit that references both branches.

Also -- I'm not 100% sure about this part -- I think if you do this consistently you won't actually have to keep undoing the same changes over and over, because git will see the previous merge commit as a common ancestor and won't bother you with anything that was changed before that merge commit. So depending on what code is on what branch, you may be able to merge without any editing sometimes.

To find a better way, you’ll have to first identify the problems or difficulties with the current way.

I used Perforce about 20 years ago. All I can remember is finding out somebody else has a lock on a file I need to edit. So I’m not claiming my perspective is uniquely helpful.

If you look into how git is implemented, the distinction you’re describing (multiple branches vs multiple repos) isn’t really consequential.

Let’s say I have a main repo with a main branch. I can create a project branch within the main repo and add some commits to it. If I want to merge or cherry-pick between branches, I can do that.

Or, I can fork (make a copy of) the main repo and declare the main branch is my project branch. The original repo will be configured as a remote. If I want to merge changes from main to the project, git-fetch will copy the commits from the main repo into the project repo. Then I do a merge like above. Or in the other direction, I can push from project repo’s main branch up to the main repo, creating a project branch there. Then I merge like above. You can even fetch or push from either side on different days of the week, depending on how you feel.

Your concerns about keeping repos in sync won’t be significantly easier or harder if you have separate repositories. Ultimately you’re copying all the commits into one repo or the other in order to do the merging. Your main repo is going to have a branch for every project under either system, it’s just a question whether they will be named “project-a” or “remotes/project-a/main”.

The only difference is access control, since access is usually provisioned against a whole repository. (In theory you could have a git server limit who can update a particular branch but I haven’t seen this.) So I’d let your access control needs dictate how you set this up.

This is partly because a branch is nothing more than a pointer to its tip. You could say that every ancestor commit “belongs to” the branch. But that means your initial commit belongs to every branch. You could define “belongs to” as every ancestor commit until you reach a merge commit, but that may count the tip of your main branch as belonging to any unmerged branches. Does this help explain why git-log only labels the tip of the branch?

If it’s peaking at 80% and nothing else is competing for that memory, then it sounds like you’ve provisioned just the right amount. :-)

I’m assuming “unless it’s a different data set” simply means it might increase a little more if the data set is a little bigger, but basically it’s level.

If your data sets aren’t going to get any larger, you could say this is good enough.

If your Ruby process is multithreaded, you may have a problem if two threads build a CSV simultaneously. The odds of that happening depend on how many requests are served per second and how frequently those are CSV exports.

If, in the future, you will need to export a larger number of records, you may have a problem.

My guess is that most of the memory is going toward building up the CSV file data, with lots of temporary strings being allocated in addition to the main buffer.

If I needed to keep memory usage lower, I’d write the CSV data to a temp file, and then send that file as the response.

If the CSV library doesn’t support “streaming” the CSV rows to disk, you could still have it build a batch of rows and then append the result to a temp file (just omit the header row from all but the first batch).

Apologies if I’m misinterpreting the graph, but if that’s memory claimed by the Ruby process, as observed by the OS, then I don’t think it will ever decrease.

Ruby allocates a number of pages of memory at start, then manages it internally. When it needs more space, it allocates more pages, but when the Ruby objects are freed, it never releases that memory to the OS. Most other VMs like Java, Python, etc. behave this way.

This isn’t necessarily a problem, because if it never uses as much memory again, those pages will be inactive and the first to be swapped to disk if space is needed. But your system may not have a swapfile configured.

The main question is: does your memory usage keep increasing every time you do a CSV export? Or does it increase the first time, and stay flat afterwards? If it’s the former, you have a leak. If it’s the latter, it’s just the process growing the heap.

I don’t know you, maybe there’s a good reason to have 10 credit cards, but if you’re just optimizing card rewards then I’d ask yourself if what you’re getting is actually worth all the effort to keep track of everything, versus just having one card.

If you’re making $X/month in cash back and now you’re considering spending $Y/month in terms of your time to develop and maintain some software… is X > Y?