Armanc Keser_

A few days ago Subnautica 2 was running at 2 FPS on my laptop, and about an hour later it was back at 60, without a restart, a driver update or a single graphics setting changed. Three things did it: we turned off the subtitles on my wife's iPad, killed an NVIDIA process that was sitting on 12.7 GB of memory, and stopped two Razer services that were holding on to 32,709 processes that had already exited.

Normally I would have restarted, which would have fixed two of those three and taught me nothing, and that is pretty much how I have dealt with slow computers my whole life. This time I couldn't, so I ended up learning how to actually look, and this post is everything I picked up along the way, in the order I picked it up. The laptop you see next to the text is a simulation: it always shows the same scene, redrawn at whatever frame rate I had at that point, and the readouts on its screen show up as I learned to read them. Where it says ??, I had no idea what my frame rate was.

It started with wanting to self-host a few things (Jellyfin, mostly). I don't have a server with a good GPU, but I do have a Legion 5 with a 3070 in it, so the laptop went on top of the TV unit, plugged into the TV, and has been on ever since.

I don't have a Twitter account I use and I don't want the app, but Bluesky never took hold as the place the tech conversation happens, so people I know keep sending me x.com links anyway, from Slack and Signal and everywhere else. My method until now has been to tap the link, go up to the address bar, and add cancel after the x, which turns x.com into xcancel.com and gives me the tweet with no account and no app. It works fine. Doing it by hand a few times a week for a year is also exactly the sort of small friction that eventually annoys you into automating it, so I sent Claude off on a research mission.

What I wanted was the network-level version, one change on the Pi that already runs AdGuard, fixing every device in the house at once. That turned out to be considerably harder than I expected, and the reason it is hard is interesting enough to write down.

If you have not run into it, xcancel is a fork of Nitter, the old open-source Twitter frontend. It renders tweets as plain pages, no login, no app prompt, and it takes the same URL paths X does, which is why swapping the domain in the address bar just works.

I have been trying to get a feature into Jellyfin web for over a year. Opened three PRs, even got two approvals, but zero merges. The feature is relatively isolated and small. When you are adjusting subtitle offset in the player, it adds a timeline that shows you exactly which subtitle will appear when, so you can see what you are doing instead of guessing.

A reviewer gave detailed feedback on the first day. I split the work into smaller pieces when they asked, responded same day, changed the code style to match the project. The refactor PR got two approvals and is just sitting there. The smallest PR, 49 lines added, 0 deleted, has never gotten a single human review.

I brought this up in the Jellyfin community and someone joked that a year is not even that long for Jellyfin PRs. The main maintainer said the backlog "sucks... for everyone" and that every second he is not reviewing makes it worse. I asked if PR size limits, proposal requirements, different processes could help. The answer was mostly "there is only one maintainer."

I think there is more to it than that.

This is not unusual, most popular open source projects have the same problem.

I predict that in a year or so, the way people interact with and think about Skills will be vastly different, in that we will barely know or think about them. Skills are the latest buzz in the world of AI trend catchers, preceded by prompt libraries and multi-agents, and they solve a really important problem, which is progressive disclosure of know-how, letting agents dynamically load context based on the task at hand. But just like their predecessors, they fail some basic first principles in the long run.

Take prompt libraries, or GPTs as they used to be called, why did they fail? No one wants to write prompts, let alone maintain and improve them. We just want the agent we are talking to do the thing we want it to do, the way we want it to do it (preferably even better than what we imagine). Same thing with multi-agents, who wants to sit there thinking about whether a task should spawn a sub-agent or not? I just want the agent I am talking to, to do the task I give it as quickly and as thoroughly as possible.

Skills have the same fundamental problem. If we look at what they get used for, it's a handful of categories: sometimes they are a cache for anything an agent could find if it did some research (best practices for a React framework, how an API works, some source code analysis of a library), many times they hold user preferences on how they would like the agent to act, and most valuably they can capture some repeatable proprietary workflow that holds institutional knowledge (your company's deploy process, the exact sequence of Jira transitions your team decided on). The first two are mostly filling gaps that better models won't have, though there is still taste involved, choosing which best practices you subscribe to among many options isn't something a model can assume on your behalf. But that's exactly the kind of thing a good memory system should learn from working with you. I have Skills for different types of codebases, frontend and backend, and within those how I like the code to be for different languages, and that information fundamentally belongs in memory, not in files I have to manually curate. A model that has worked with me long enough to notice I always rewrite every resp to response and always reject inheritance for code reuse should just *learn that*, taste and all.

A long time ago, when I first saw the AlphaGo documentary I was blown away by how fast DeepMind went from AlphaGo to AlphaZero. As impressive as AlphaGo was, it was still trained on human played games and it would evaluate itself against whether it thought a professional human would make a play it was thinking of. This did lead to great, actually competitive matches with Lee Sedol, but AlphaGo lost a game. AlphaZero, however, was built from scratch with just the rules of the game and an ability to play itself and learn from it. To get to capacities humans just can't.

With LLMs all being trained on a massive corpus of human written content, and adding the fact that they are literally prediction machines built to please, I can't help but draw parallels between AlphaGo and AlphaZero. I know they are not the same technology, but what would entail "giving the rules of the game" to an LLM to train it? How would one even evaluate performance and be able to retrain based on these results? Is RL after a model is already trained the only way to go or can we train a model to learn to speak and create thoughts by just teaching it the language and its rules as opposed to showing examples?