Flux159

"What Andy giveth, Bill taketh away" - https://en.wikipedia.org/wiki/Andy_and_Bill%27s_law

On a more serious note, I really only use Windows for games & I'm still always frustrated with how many updates (& restarts during updates) Windows needs. My fans are always constantly spinning on Windows too (laptop or desktop) whereas my Mac & Linux machines are generally silent outside of heavy load.

AI 2026 prediction from Anthropic cofounder

Nice, this is similar to what I was wondering about - it looks like it's pretty limited in capability right now (looks like it only supports canvas2d at the moment: https://nxjs.n8.io/runtime/rendering/canvas), but in theory it would allow you to make a layer to convert WebGPU or WebGL games for Switch (ignoring the huge performance drop going from v8 / jit JS engines to QuickJS).

Yeah, I saw the video about that earlier which is what led me to wonder if there was a native JS way now.

They used Kha in order to port only the console versions, the desktop versions remained JS from my understanding: https://github.com/Kode/Kha which is built on top of Haxe. This works, but it also means not having a single codebase anymore which would be one of the benefits of a JS based system.

There are other options here - something like using an AOT JS compiler like Porffor, but from my understanding it's never been tested (and would probably be missing a lot of support to get it working - like shimming canvas & providing a WebGPU context that the compiled JS could execute against).

The interesting part here is about AthenaEnv. It looks like it uses QuickJS for the Javascript interpreter and wraps around the native system libraries that the PS2 provides.

I'm wondering if there's a modern similar project that would allow writing Javascript Canvas games (WebGPU / WebGL) and publishing on Switch/2, PS5, and Xbox.

From my understanding, they explicitly disallow JITs so you can't just wrap your JS game with Electron / Node Webkit and use V8. I'm not sure if anyone has tried publishing a game using a V8-jitless electron fork - the sdks for consoles are under NDA so there's not really much written about it publicly & most games using Unreal or Unity don't deal with these things themselves.

PC, Mac, and even mobile are surprisingly easier here because you can just run the JS via electron or in a webview on mobile.

Was able to sign up for the Max plan & start using it via opencode. It does a way better job than Qwen3 Coder in my opinion. Still extremely fast, but in less than 1 hour I was able to use 7M input tokens, so with a single agent running I would be able easily to pass that 120M daily token limit. The speed difference between Claude Code is significant though - to the point where I'm not waiting for generation most of the time, I'm waiting for my tests to run.

For reference, each new request needs to send all previous messages - tool calls force new requests too. So it's essentially cumulative when you're chatting with an agent - my opencode agent's context window is only 50% used at 72k tokens, but Cerebra's tracking online shows that I've used 1M input tokens and 10k output tokens already.

Is this built with JS / something like Fabric JS? There are some things that feel very similar to a web app that I worked on before. Wondering if there's plans to have a plugin API at some point if it is.

I have a plus subscription & was able to get it to work on X. It shows you what it's doing on the tab as it's moving around.

One interesting thing here is that the chat side panel is agentic - it can read tab contents, open links in the existing tab or create new tabs, and do most of the standard "summarize", etc. things too.

This might be the first time that I move off of Chrome for an extended period of time.

I was able to add ublock origin lite as an extension & it seems to work the same as Chrome.

I wonder how this works with mcpb (renamed from dxt Desktop extensions): https://github.com/anthropics/mcpb

Specifically, it looks like skills are a different structure than mcp, but overlap in what they provide? Skills seem to be just markdown file & then scripts (instead of prompts & tool calls defined in MCP?).

Question I have is why would I use one over the other?

Nothing in particular - when I wrote / used the jupyter 'runbooks', they were most helpful when a SEV (site event / severe error) was happening or if a new person on the team needed to handle oncall the first time.

This looks great! At a previous job we had a fork of Jupyter notebooks that were used this way by some teams. I see that remote execution is on the roadmap, but was also wondering if you'll have some form of parallel remote execution as well (ie one runbook run across 10 or 100 VMs similar to parallel ssh). Definitely more complicated than single execution, but potentially very powerful for debugging fleets where you don't have Chef or Ansible. I guess the alternative is to just have the runbook run locally but run pssh in some commands to get a similar result.

This is helpful when I don't want to use AI.

Any chance you could add "extract clips" in addition to extract frames? Specifically I had to split a video into x-second clips recently & had to use AI to get the right command for that.

Thanks! Reading some of your other comments, it seems like runit or nitro may not have been a good choice for my usecase? (I'm using dependencies between services so there is a specific order enforced & also logging for 3 different services as well).

You seem to know quite a bit about init systems - for containers in particular do you have some heuristics on which init system would work best for specific usecases?

How does this compare to s6? I recently used it to setup an init system in docker containers & was wondering if nitro would be a good alternative (there's a lot of files I had to setup via s6-overlay that wasn't as intuitive as I would've hoped).

Yeah just saw the 502 - probably hug of death.

Getting a CORS error from the API - is the demo at https://search.wilsonl.in/ working for anyone else?

The lack of caching causes the price to increase for each message or tool call in a chat because you need to send the entire history back after every tool call. Because there isn’t any discount for cached tokens you’re looking at very expensive chat threads.

Tried this out with Cline using my own API key (Cerebras is also available as a provider for Qwen3 Coder via via openrouter here: https://openrouter.ai/qwen/qwen3-coder) and realized that without caching, this becomes very expensive very quickly. Specifically, after each new tool call, you're sending the entire previous message history as input tokens - which are priced at $2/1M via the API just like output tokens.

The quality is also not quite what Claude Code gave me, but the speed is definitely way faster. If Cerebras supported caching & reduced token pricing for using the cache I think I would run this more, but right now it's too expensive per agent run.

So this seems to be a build definition and some form of attestation system? Does this require builds are done via CI systems instead of on adhoc developer machines?

I find that for many npm packages, I don't know how builds were actually published to the registry and for some projects that I rebuilt myself in docker, I got vastly different sizes of distribution artifacts.

Also, it seems like this is targeting pypi, npm, and crates at first - what about packages in linux distro repositories (debian, etc.)?

From the article it mentions that they use a single chat thread but randomly choose between 2 different models (w/ best results from Gemini 2.5 / Sonnet 4.0 right now).

Are there any library helpers for managing this with tool call support or is it just closed source / dependent on someone else to make open source inside a different library?

A bloomberg archive.ph article about the same topic - https://archive.ph/9qB0t

I'm not sure I would say this is solved - having used CNPG with GKE, I ended up moving off of hosting Postgres inside of Kubernetes & moving to Cloud SQL and Spanner for storing state in my apps.

Few issues I found was that having stateful sets caused GKE to be unable to automatically update in my cluster setup. I had a read-write and read replica for a few postgres databases & the operator wasn't consistent with what pod id was read-writeable (you were able to retrieve this info from metadata though, so could script around it). Then having to setup backups to GCS manually & needing to ensure that they would work correctly to restore - easier to just pay GCP to deal with all of this with Cloud SQL.

Thanks! Took a very quick look. It seems like the extension exposes tools for all domains that support mcp-b looking at DomainToolManager - does this mean if I have two tabs for a single domain you'll have duplicate tools per tab?

Haven't had enough time to look through all the code there - interesting problem I guess since a single domain could have multiple accounts connected (ex: gmail w/ account 0 vs account 1 in different tabs) or just a single account (ex: HN).

This is an interesting take since web developers could add mcp tools into their apps rather than having browser agents having to figure out how to perform actions manually.

Is the extension itself open source? Or only the extension-tools?

In theory I should be able to write a chrome extension for any website to expose my own custom tools on that site right (with some reverse engineering of their APIs I assume)?

This is pretty interesting - how has your experience been with R3F? I've built a small game level with it before and I'm wondering if I want to go all the way and build something larger.

Also, are you planning on making this open source at some point? Fabric is nice in that it manages 2D canvas objects for you & you can build things like an editor on top, in this case as a library what would you consider the primitives on top of Three objects are? Could it be used to make an editor for a 3d level?

This definitely tracks with my experience in big tech - managing large scale build systems ends up taking a team that works on the build system itself. The underlying repo technology itself needs to work at scale & that was with a virtual file system that downloaded source files on demand when you needed to access them.

One thing that this article didn't mention is that most development was done either on your development server running a datacenter (think ~50-100 cores) - or on an "on demand" machine that was like a short lived container that generally stayed up to date with known good commits every few hours. IDE was integrated with devservers / machines & generally language servers, other services were prewarmed or automatically setup via chef/ansible, etc. Rarely would you want to run the larger monorepos on your laptop client (exception would generally be mobile apps, Mac OS apps, etc.).

I've gone through a few AI IDEs / agents and CLI tools now, currently on Cline with Gemini 2.5 Pro which is doing a pretty good job at my web app code with a decent .clinerules file in the repo.

To answer why I don't use chat at all for coding anymore, some benefits of IDE / CLI agents: Copy pasting into chat apps don't allow for agentic runs (ie run bash commands, edit code, validate with linting / testing before marking task as 'complete'). I can mostly just write my descriptive task (usually with code references if they aren't already there in clinerules / claude.md, etc.) and come back after a short walk or drinking some tea and check the code or just check at runtime to ask it to fix up the code. This is honestly very similar to "waiting for code to compile."

For reference, I've used the following to make production code changes:

- Cursor: which when Claude 3.5 was out seemed to be the best AI IDE, but the changes they've made around agent mode and 3.7 haven't really worked super well for me. Migrated to claude code after 3.7 came out.

- Claude Code: Very good, I generally just ran it in dangerous mode and it could accomplish tasks fairly well. Wrote a decent Claude.md file as well. Only con is that it got expensive quickly. On the order of $3-5 per session which would accomplish a single task.

- Cline with Gemini 2.5 Pro: Moved to it yesterday, it's been doing a good job and is effectively free right now using my own API key for Gemini. Seems a bit verbose at times although that might just be Cline's prompts.

I haven't tried Aider or Windsurf, but have heard good things about Windsurf's agentic mode. Although I might not move to Windsurf at all since Cline with Gemini works pretty well & is free to use.