zamalek

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.

The things work, albeit with a full page load. As one of the ancestor comments said: progressive enhancement.

Back in the day I was writing a liero clone, and came up with a neat scheme for pixel-perfect collisions (probably serendipitously, no claims it's unique). A 64bit integer can be seen as an 8x8 mask. You can pixel shift it up and down by simply bitshift left or right by 8n bits. Pixel shift left and right required more instructions; if I was to write it today I would probably store an additional rotated version instead (as that would then effectively pixel shift left and right with bit shifts).

You then have the terrain chopped up into these 8x8s too, and can then do a collision test with at most 4 of them with the 1 character/entity mask.

China was behind the frontier before they suddenly weren't (K3). Just using American models would never have achieved that (not that they could have anyway, but the point still stands).

And FWIW, KDE probably make the most effort with their compositor. They have historically been well ahead of the curve for things that might affect this (e.g. VRR).

In Linux you generally have two types of desktops: DEs, which are full featured (KDE, GNOME, Cosmic, Cinnamon, etc.), and window managers. Window managers do only what they say on the tin, if you used one with genuinely no config (they usually have minor defaults to prevent this) you would be completely soft-locked: an empty desktop just a cursor to play with, no way to launch apps, nothing.

They have a special layer into which apps can spawn windows that typically do things like adding a launcher, or an app switcher, notifications, or whatever else you want. It's the unix philosophy brought to the UI domain. Usually you have a separate app for each, but DMS brings in a full suite: allowing you to use the window manager without having to spend hours ricing your system.

UID mapping is how rootless docker works, so tons of people are using it

One option would be to have an input replay alongside captured outputs (audio visual), at some fixed framerate. Capturing intermediates (scene graph etc.) would probably also be valuable, as that could help nail down why something is failing.

Or you could do it [as I recall the project being called] the scientist way. You still have the old code, so you could replay inputs against each and compare. Probably more realistic because uncompressed video would be a ridiculously huge dataset. This would be more resilient in the face of testing hardware and driver drift.

Historically game engines are the worst offenders when it comes to unit testing. I'm not sure if that's still the case - but that's why I erred on the side of integration tests.

Game engines are typically in two languages, one for the engine itself and one for scripting. That even goes for Unity: in Unity, C# is a significantly more powerful than average scripting language (for lack of a better term), but the engine itself is still C++.

That's not to say that you couldn't write a commercial game engine with something like C# that stands shoulder-to-shoulder with unity and unreal, but it doesn't seem like anyone has attempted to do so. Maybe it's the decompilation fear.

Also, it would continue to make sense to use a scripting language alongside Rust.

That router uses OpenWRT, but only official firmware can be installed. The Asus ZenWifi BT7 is currently widely recommended if you want to go OpenWRT Wifi7.

The Claude harness effectively summarizes the discovery into a plan document, clears, and starts with just that summary - so you'd be clearing context regardless.

Fireworks don't need to be intentionally aimed at a house for a forest, or a city, to ignite one.

Stealing electricity is already illegal. Driving a truck into your home could be a genuine accident, but it's more likely that alcohol was involved first (which is illegal with driving).

Yes, because what I was doing was objectively dangerous. Dueling used to be a commonly accepted practice, yes even killing - pity that ladder was pulled up! What about the children's chemistry sets that included uranium, mercury, and cyanide?

I loved playing with fireworks as a kid, and surprisingly have all appendages and senses intact, I even considered pyro as a job - so I definitely get the appeal.

I just think it's time that we left it to the professionals. Unless you are engaging in science or physics, I don't see the value in letting them off yourself.

~~It's also weird that America's birthday is celebrated using a Chinese invention.~~ Edit: bad point, I stand corrected.

From what I can tell, the "established wisdom" is to get Fable to plan and Opus to implement (for cost purposes). The problem there is that Opus could ignore whatever it likes from Fable's plan.

> Basically, when you have a long session, you can see this by saying, ok, now moving onto another thing, blah blah blah

I try to avoid > 200k contexts, as the 1M context is where I first saw the massive decrease in reliability.

And my AGENTS is really short, and I said it was ignoring decisions in the prompt.

Wouldn't have helped, sibling comment: https://news.ycombinator.com/item?id=48797883

Architectural decisions are not lintable.

So would that solve (most recent example):

The agreed architecture is to use signing between two micros, so that a third can orchestrate between them in zero trust way (and to prevent a distributed monolith). It just decides that we can trust the third and skips the signing.

> Can you just give an agent a desired outcome and let it work, unsupervised? Absolutely not.

Ignoring instructions - whether in AGENTS.md or my prompt - is the worst of it, and it routinely happens. It just waives things that I explicitly told it to do as part of the design.

Vibe coders (in the true sense, zero oversight) claim that you just need to prompt it carefully. That's completely untrue when faced with your careful prompt being ignored.

I even have "don't overrule me without asking" in my global AGENTS.md, and it simply doesn't do that.

> a splat is static iff a single quantized value

What is up with LLMs and "iff"?

> For example, running ten programs at once with only a single CPU. Concurrency is effectively CPU scheduling with maybe some other concepts of communication between processes for coordination.

This is called preemptive multitasking. This is like declaring that "sorting a list is quicksort." This can realize concurrency.

The reason that this is important is that cooperative multitasking (async/cps/fibers/safe points) is also concurrency. And I'm sure there are other exotic forms of concurrency that I'm not aware of beyond multitasking.

Concurrency is a property of a program/system, not a mechanism.

You misunderstood my comment. My hypothesis is that it did _neither:_ it accelerated along an axis, and American SOTA/frontier is now laggard (efficiency).

Deepseek and Kimi are writing paper after paper with substantial architecture improvements for efficiency, because they can't just throw more hardware at the problem.

And China is now doing something on the hardware axis; which it may have never explored were it not for the sanctions.

Also, don't forget that we're only here because the clown-in-chief cut them off from GPUs - forcing them to make do with inferior hardware (and hence superior ideas). I have no doubt that any controls would only make China stronger.

I recently had to functionally migrate away from a codebase that had a ton of YAGNI. _Even with_ an agent it was a herculean task: how do you know if something is really used in a distributed system. I missed things, the agent missed things, it all took way longer than it should have.

(FWIW, I wasn't simply doing a 1:1 port, I took the opportunity to simplify - which meant completely understanding how the old system worked, including things that were _never_ used if I failed to identify them as such)

You can't make a clean-room implementation of an open source project using a frontier LLM because it has the original code in its weights.

It has fixes and features not in the official proton, but most importantly, proprietary codecs.

Alternatively:

Step 1: 30 minute conversation with AI on how to use AI. Step 2: fire everyone.

Unrelated to code, but along the same lines. I've been keeping track of the Reckless Ben case to fuel my unhealthy indignation, and we just had a like-for-like comparison between a human and an LLM.

Human: well-scoped argument that does just enough to get the job done with minimal risk.

AI: Extremely clever and correct legal argument that almost any lawyer would have said not to file (at least as written). It tries to burn the world and seriously risks pissing off the judge.

https://www.youtube.com/watch?v=YRXJnKP6Tu0

Ghat's exactly what i have, did you read my comment correctly?