manx

Which evals would you be interested in specifically? And what are you missing in the readme?

valid question. I thought a lot about this. The prefix before every fold stays intact (cache hit). But for the messages after the fold there is always a cache miss. Folds don't happen too often, so in practice this turned out to be worth it, because the cache miss comes with a big token reduction in general. I don't have a solid cost analysis for this yet, though.

Yes, you need an extension that uses the claude code credentials from the file system, like this: https://github.com/fdietze/pi-claude-auth

Works pretty well for me, even with latest opus-5-5

We probably want to compare the cartesian product of model+harness.

Agreed. Which other software does society need badly?

What matters more is if there is good QA.

Also, you can have NixOS instead of debian: https://github.com/nix-community/nixos-avf

Wouldn't it make sense to have these wikipedias created by different llms, and compare them to expose their biases?

It's not only the amount of code but also the quality of the available code. If a language has a low barrier to entry (e.g. python, javascript), there will be a lot of beginner code. If a language has good static analysis and type checking, the available code is free of certain error classes (e.g. Rust, Scala, Haskell).

I see that difference in llm generated code when switching languages. Generated rust code has a much higher quality than python code for example.

I fully agree with this approach! 5 years ago I built a prototype to execute that same concept of language covering. But instead of just using words, I used n-grams. It ii trained on subtitles to model spoken language. Combined with sqlite in the browser to get the next sentence with the most impact.

github here: https://github.com/fdietze/ravioli

prototype deployed here: https://raviolio.web.app/

I think memory safety is a weak argument for rust and only works against C/C++, as you mention. For me, the strongest arguments against GCed languages are static analysis goodies that other languages don't have. Like checked immutably by the compiler, the borrow checker which forces you into a certain architecture, fearless concurrency etc. All those lead to fearless refactoring, which is a very strong point for me.

This pre-AI article makes a very similar argument: https://mortoray.com/programming-wont-be-automated-or-it-alr...

Once we realize that what we actually want is turning specifications into software, I think that English will become the base for a new, high level specification language.

Search for "bridging based ranking". The X community notes algorithm does that. I think it should be applied to all content.

Sounds like type-classes from haskell/scala? Or is that a different thing?

Similar simplicity but in rust: https://github.com/fdietze/alors

I'm also in the process of creating a general purpose agent cli+library in rust: https://github.com/fdietze/alors

Still work in progress, but I'm already using it to code itself. Feedback welcome.

I also created my own. Frontend-only, no signup, based on openrouter, written in rust+leptos (wasm):

https://github.com/fdietze/tomatic

https://tomatic.app

Project Frottage: An automated constant stream of high quality AI wallpapers for mobile and desktop. We manually curate a list of ~150 prompts. Every 6h a random prompt is selected, a picture generated and uploaded to static hosting, free to use:

https://frottage.app/static/wallpaper-mobile-latest.jpg

https://frottage.app/static/wallpaper-desktop-latest.jpg

https://frottage.app/static/wallpaper-desktop-light-latest.j...

We just finished an android app, to set the wallpaper automatically on mobile: https://play.google.com/store/apps/details?id=com.frottage

I think we could build something on top of nix that is as easy to use and powerful as earthly, but gets all the nice stuff from nix: reproducibility, caching, just use any command from any nix package, etc

Is there a way to cache the derivation evaluation?

To align AI with humans, it might make sense to align humans first.

Haha, yes. Ist was a great time. document.all etc

The tool should probably suggest which clinical tests should be conducted next.

Why not directly pay what you use? Similar to how LLM Apis are billed these days.

I recommend to try earthfiles: https://earthly.dev/earthfile

This basically brings docker layer caching to CI. Only Things that changed are rebuilt and tested.

I recommend reading: https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-va...

Some kind of community notes consensus system could make sense here to find common ground. When a diverse set of people agree that a site should belong to the list, only then it is added.

This. I think, well curated web directories (by humans and machines) deserve a comeback.

Interesting. I'll give it another try.

I loved qutebrowser, but many pages didn't work because of the rendering engine. That made me go back to Firefox.