I wrap most node-isms and use deno as the runtime. Works well. If a project is pure typescript I just have deno run it. Extra options for security are great, installation scripts disabled by default, etc.
If you're using node directly, please stop. At a minimum use Bun.
With agentic work, there is little reason to use anything besides Rust and Typescript in any case. Room to disagree but type safety, memory safety, and a large corpus of work is critical. Agents need difficult errors and baked in patterns they navigate it easily. For UI, Typescript makes the most sense just because of the mass of design examples.
Nice. In the right track. I made something similar, but focused on local agents, but we both have issue tracking for managing multiple project and agents in parallel. It works, I think people will be surprised when they start using systems like this.
It is very different from current editors and the direction they are going in. In a way, it undermines the direction they are going. Current editors aim to make engineers 10x or 100x. These editors aim at a different target than the engineers. I will leave it to the imagination on who.
AI watermarks empower elite / those with resources and disempowers the common person.
Only people with resources will be allowed to make content that is AI generated passed off as real.
Pandora's box is open. Instead of making a multi-tiered privileged society, we need to fundamentally restructure society to adapt.
Before that restructuring occurs it is critical to keep the playing field level. These are not tools that should be controlled by a minority authority, they are far too dangerous.
That’s a reasonable argument. But why should we tolerate the two tier system? Why not enforce a restriction on all images? Why do we have to accept someone is above the law?
Because it is technologically impossible to enforce this on the owner class. The people who control compute control the rules. Without proper audit trails it becomes impossible to prove or enforce.
The only ones, then, who could afford to break the law are also the ones who make the law and own the law. Everyone else is subordinate in that model.
That's why technology like watermarking doesn't work and will never work. Implicitly it creates a minimum of a two-tiered society and no amount of "law" will change the technological reality of this.
The people with compute only control the rules society allows them to control. It isn’t law of physics. We have export restrictions on hardware. The government could put restrictions on image generation just like the Movie, TV and music rating system or the water marks in printers that prevent counterfeit money printing.
All the things you mentioned were massive creative endeavors demanding the talents of countless humans with real-world stakes, moral compasses, and sovereign autonomy. These creatives had rights, they had families, they had parents, and they had a place in society.
Now the things they produce can be done in a fraction of the time without any of the stakes, nor any of the moral society-integrating foundational encoding.
Instead, a single billionaire with an army of GPUs can ask for a thing, and that thing will be produced near instantaneously.
The old way of regulating depended on PEOPLE creating things at PEOPLE speeds in order for the laws to work. That simply is not the case any more.
I patched my local radicle to remove the default seeds, and I can put my own seeds as default. It is pretty easy to script some commands that auto add your local nodes when init a repo.
I also added some network rules to block non-local network access to radicle. Not needed but I really wanted it to work only on my lan.
Works great. I setup several skills for agent harnesses and they use radicle + jj + git perfectly. It is fun watching issues pop up and monitoring progress via the flow.
I am building more tools around this workflow because it is so effective. Radicle acts as the long term project memory bank and management. I can write issues and they can automatically be picked up.
What I'm adding is making the issues more searchable and an agent proxy that integrates radicle into calls. among other things.
This is all pretty straight forward to do, I really recommend it.
I use this metric now, and I suggest you change it per your imagination:
"Make a single-page HTML file using threejs from a CDN. Render a scene of a flying dinosaur orbiting a planet. There are clouds with thunder and lightning, and the background is a beautiful starscape with twinkling stars and a colorful nebula"
This allows me to evaluate several factors across models. It is novel and creative. I generally run it multiple times, though now that I have shared it here, I will come up with new scenes personally to evaluate.
I also consider how well it one shots, errors generated, response to errors being corrected, and velocity of iteration to improvement.
Generally speaking, Claude Sonnet has done the best, Qwen3.5 122B does second, and I have nice results from Qwen3.5 35B.
ChatGPT does not do well. It can complete the task without errors but the creativity is atrocious.
A AMD Ryzen AI Max Pro 396 will get 50t/s with Qwen3.5 35B.
In addition, the these local models are very, very, very sensitive to the template used. Make sure it is correct. I was using the wrong template and it would answer but felt like it had a brain worm.
The parameters must also be what is recommended, otherwise they go off the rails.
I get great results now after messing with it for a while. I prefer the 35B model because I enjoy how fast tokens appear at 50t/s, but at around 20-25t/s with the 122B model, it is also completely usable. And that one is very smart.
I have been running nearly the same experiments for the same reasons. It has been a lot of tweaking and patching because I am on a Strix Halo system with amd gfx1191, but the LLM component is working nicely.
The evaluation I use is having it one shot a 3d scene using threejs. After everything, the output was comparable to Claude Sonnet (Opus actually does worse on this task strangely).
For my local setup, I have settled on the qwen3.5 family after testing most of the local usable models. Here are the models I use ranked by intelligence:
The 122B model is actually very, very smart. But I have found that token speed is more important, and 35B is smart enough. At 50t/s I can get a lot more done, and I am going to build a mechanism for it to escalate intelligence if needed.
GPT-OSS119B failed at my evals.
MistralSmall4 is too buggy to use (I believe it is too new, the templating is messed up, and agentic use has too many issues). That said I evaluated it directly via copy and paste and the results were not comparable to Qwen. But it is very very fast.
I am running a patched build of llamacpp to get these results. There are a few changes that need to be made to increase prompt processing speeds (about a 30% increase) and be able to use rocm. It took a lot of setup but my flake in nixos is stable now.
Long story short, I can confirm a lot of what was shared in his blog.
*this was written at 4:30am on my phone when I wake up, apologies for typos.
Are you running NixOS on the Strix as a main OS? Would be interesting to read how that's working and what your config is like. Any containers involved or hand building outside of Nix?
I am using nixos unstable pkgs. The published rocmPackages were recently updated and now include kernels for gfx1151, which I surprisingly found out this morning. Before, you would have to set a flag to use the older kernels because they were not available.
My flake modules with rocm config are a bit messy, but maybe I can find time to throw a repo up with it. It contains all necessary packages, flags, boot options, llamacpp patches, and some hacks to get pytorch working smoothly with rocm.
What this means: no, I do not need containers anymore for replicating working configs. The flake configures the system with appropriate libs. I build llamacpp with patches for rocm, and I can run comfyui for generative processes. I have generative image and video working as of today, and next I will get generative 3d modeling working. I'd like to have Trellis2 running this week.
None of this would be possible for me without NixOS, as an aside. It keeps track of configuration for me so I do not have scatter shell scripts and unpredictable deps anymore. I used to build Zed from source with scripts, for example. Now it is a module with patches. Llamacpp is the same. Very clean and requires no working memory, when something needs adjusting I just go refresh myself with the module in one place.
Sounds very neat. Thanks for the explanation. I'm not too familiar with Nix, though I've done a few installs. This sounds like a very interesting setup.
Use of an app is not necessarily the problem. Requiring Google Play or the App Store is. We should be able to use apps without being in walled gardens.
Recursive self-questioning predates external tools and is already well known. What is new is broad access to a low cost, non retaliatory dialogic interface that removes many social, sexual, and status pressures. LLMs do not make people think. They reduce interpersonal distortions that often interfere with thinking. That reduction in specific social biases (while introducing model encoded priors) is what can materially improve cognition for reflective and exploratory tasks.
Simply, when thinking hits a wall, we can now consult a machine via conversation interface lacking conventional human social biases. That is a new superpower.
If you're using node directly, please stop. At a minimum use Bun.
With agentic work, there is little reason to use anything besides Rust and Typescript in any case. Room to disagree but type safety, memory safety, and a large corpus of work is critical. Agents need difficult errors and baked in patterns they navigate it easily. For UI, Typescript makes the most sense just because of the mass of design examples.
reply