zamalek

> It also means that the "hey Claude vibeslop me a CUDA Anubis solver" route is on its way to being fundamentally dead.

Would there be any risk in making a dynamically built algorithm (i.e. the risk that we don't find N zero prefix bits)? Chain a set of transforms and build a unique WASM binary (including optimizations to deter pattern matching); possibly one a day or hour or something. That way you'd need to have Claude vibeslop the CUDA implementation at that cadence, per website.

Now people get the downloads and bits that they don't want.

And that's very suspicious given that they published the paper in 2026. Was it somehow impossible to find energy prices for 25+26?

Uber was one of the first to admit that AI isn't all it's hyped up to be.

Wine does support Affinity now, if your Adobe muscle memory isn't a personal law of physics.

What benefit does a native build have over proton? I used to care more about it on Linux, until I realized that "native build" probably means "doesn't work." I can only imagine this being much worse on a niche gaming target which there are extremely few users making (and voting for) bug reports.

Tack on having to pay Apple to play in their shitty ecosystem and it makes complete sense.

Wine/proton as a gaming ABI/runtime is perfectly fine, Microsoft used to do a lot to maintain backcompat and that spirit has clearly distilled into proton: it even runs games Windows is unable to (most recent example of mine is Black and White).

The intermediate level Rust dogma is to try your hardest to avoid the heap, and to tear your hair out at the throne of monomorphization. While both are broadly true, it's articles like this that show that a single pointer (or call) indirection can sometimes be better.

It is so much worse than "just" AGPL, YouTube happened to rec this to me yesterday: https://youtu.be/mAm-kpiHRcw. Granted, there are much worse and more pressing evils in our world, but Bambu is just pure and utter evil.

I'm not 100% sure what I'd do to detect this for shells specifically, maybe prompt the user, but my toy harness scolds refuses to re-read files because the previous iteration of GLM was room-looping on that. Clearly something that they need to work on.

In my, admittedly extremely small sample set, concept-focused memory is common for people with any degree or kind of dyslexia. I used to struggle with understanding how people couldn't understand things, now that I'm more mature it makes sense how people struggled with me not being able to spell things :).

And attention or admiration.

Maybe they feel like, for once in their lives, they can appear as intelligent as the people they employ with AI propping up their prose.

Should have said yes, told it deploy to prod, then given it a real browser to test its changes. For science.

> in humans the exact same behaviour (cheating) is slmost always the result of a chain of complex series of choices and environment-driven rationalization.

It has been taught on the outcome of this. Broadly speaking, humans are lazy creatures (and when used judiciously, laziness is a good thing).

For example: the famous example of Carmack not using a hashmap somewhere early on in, I think it was, Quake 1 initialization. A piece of code that only runs once at startup, of course he didn't optimize that. The rationale is not included in the training data (it was in Carmack's head when he wrote the code), so the LLM learns some probability of being lazy.

And then it is trained on outright lazy work. Crappy lazy code predates LLMs.

> what evidence would convunce you that it is thinking?

Exactly. It isn't. It is predicting the most likely token to appear given all of its training data, some significant portion of that data is lazy, so it has that probability of producing "lazy tokens."

There's also the consequences of RL. AI - of almost any form - is notoriously competent at finding "not the solution you were looking for" given a poorly specced or implemented training environment. Search for almost any "I made AI learn to walk" video on YouTube and you're almost guaranteed to see an early attempt that vibrates strangely in order to move, instead of the natural looking motion the developer is looking for. Our benchmarks aren't any good (not throwing shade, it's a genuinely hard problem), our training environments can't be much better - LLMs have been rewarded for reward hacking to some degree.

To make matters worse, "reward hacking" can be generalized into "cheating is the goal." If the LLM trains on enough problems where reward hacking works, it may fall into the cheating local minimum.

Yesterday I told it "don't use std mutex, use parking_lot" for its plan. It ignored that sole instruction (i.e. nothing else in my message), making zero changes to the plan, three freaking times in a row.

> Try as you might, it's nearly impossible to get the entirety of the context, intentions, business implications, budget constraints, and what-have-you written down and accessible to a coding agent. There will invariably be ambiguity and choices to be made, and it is nice to know that an agent will stop and ask when needed.

In general, I find that the grill-me prompt[1] helps with this - but I am definitely not hand-waving the complaints here. I feel like Anthropic peaked at around 4.5, and I have personal reservations about how far transformers can get us - but grill-me does a lot of legwork.

[1]: https://github.com/mattpocock/skills/blob/main/skills/produc...

Assuming I was okay with the political exploits of Elon and his companies:

Grok was supposed to be the unbiased model, that is: regurgitate everything it has read. Obviously all data has bias, even all of the data at once, but the sales pitch was that you would get that unfiltered. At least in open source models, this has been shown to improve the competence of the model.

Then this happened: https://futurism.com/artificial-intelligence/grok-describes-...

So not only has bias been introduced, but they are happily biasing it for trivial reasons. So now the model needs to be competitive in exactly the same way that others are: on benchmarks (which are still not a solved problem).

But, I (and many others) disagree with how Elon has behaved politically and don't want to hand money over to him, so all of that is a hypothetical.

That's a very empty statement: you're haven't mentioned and critiqued any of the points he made against LLMs at all.

Problem is that might go away or get nerfed.

Additional constraint here: it's not just browser version. Processes have to refer to the same disk location for sharing to work. Given that each ships the full set of dependencies disk location will never match (except for their own child processes).

Flakes for a start.

A script can't pull facts out of a PDF, but you certainly don't need 2T param frontier model to do that either.

I got Claude to write a forejo instance in TF (oidc + CI runners + daily backups + the works) in half a day.

That's missing a some of the LLM era? Maybe the author is working on a logarithmic view?

I think my age group (~40) is the tail end of widespread dogmatic trust in Microsoft. Once we retire I think they are going to be in serious trouble.

And that's a single player game isn't it? With required login...

At least so far as Microsoft goes, it is abundantly clear that they do not use LLMs like you claim to. The gp comment is an extremely fair assumption.

I'd also wager that people like you are extreme anomalies in general. We are seeing decreasing software quality across the industry. Your statement is the bold one.

Because the IT department makes them. Windows (and Mac) have an abundance of turn-key MDM solutions. I did the research to avoid having to use Windows at a previous employer, and there weren't many options (and specifically _any_ that covered 100% of what they wanted).

I think you'd need to insert "critique these ideas." That's where the intellectual honesty comes in - I suspect that _all_ current LLMs would continue on with and truly stupid ideas as though they were gospel, their profound incompetence at backtracking on what they have said is something the industry hasn't figured out.

If we could make progress in that area, maybe CoT could gradually decrease as it approaches its limit, or maybe the LLM could control the temperature of the next token itself (how this would be trained, I have no idea).

> Let's see if we can go even faster. Next, we disable compression in the file cache. We will discuss the file cache in more detail a bit later but for now let's just say that by disabling compression we trade temporary disk space usage for speed:

Something is wrong here. Which compression algorithm is being used here and how much has it been tuned? A core hypothesis of the likes of zram is that disk access is so slow (even NVME), that you can often beat it with the bit-rate of decompression.

1. Is something slow like gzip being used?

2. Is the compression effort over-tuned for size? Do some space benchmarks and make sure that you aren't saving a few dozen MB on GBs of data.

zstd, with 1-3 effort (you may even find negative is a overall win), and a trained dictionary (your data does all look identical) is probably a good start.

Maybe modulating temperature can help here: have the LLM come up with ideas at high temperature, and then critique them at low.

This is also tied to halucinations: it is something that humans do (for writing fiction, and for "jumps") - but what LLMs currently lack is intellectual honesty. Coming up with bullshit is fine (and in this context valuable) - the important bit is putting those ideas through some form of rigor, or just immediately turn around and admit to talking shit.

So I'd arge that hallucinations are what prevent LLMs from doing this in a useful way.