RomanKornev

> lot of strain on the server-side

That's why GitHub assigns "points" to each requests and deducts based on the data shape you request. For simple requests it's 1-to-1, but can quickly balloon

GitHub's "paid" rate limits are the same as GitLab's free tier, so no, it doesn't help

> LAWS.bend

I like the law idea, but what i found they end up doing is they just modify the law itself to fit the new feature they are working on, which defeats the point.

Which means some laws needs to be frozen. But not all laws, otherwise you can't add or modify anything. So the judgement is still on the human part, and we're back to meatbags being the bottleneck.

I've seen some success adding these proof-like checks to CI every time agents do something irrational. I definitely think it should be part of every codebase.

There's also https://code-contracts.cc/ which co-locates code and proofs together.

> With the REST API on GitHub, you can consume maybe 10 issue JSON blobs before your context window is blown out.

This is a solved problem. They just dump it into a file and `jq` or `rg` to find the stuff they need.

Agents are smarter than you think. They've been hill-climbing for generations in their RL environments.

The ones that get their context window blown out don't survive to launch

> But I do believe that all coding will be AI-assisted.

> If all coding is AI-assisted won’t it just be referred to as… “coding”?

It already is, and it's called engineering.

The value is how much steering you can provide. Whether it's in the form of domain knowledge or "hardcore" engineering is beside the point.

Taste is all we have left.

Every single `reduce` can be replaced with a more intuitive `groupBy`, `partition`, `mapValues`, `keyBy`, etc.

Reduce can approximate anything, that doesn't mean we should use it.

My favorite antipattern is

  items.reduce(
    (acc, item) => ({
      ...acc,
      [item.id]: item,
    }), {}
  );

Like, why? Not only is this ridiculously inefficient O(N^2), it's also longer and less understandable than "build a new map" version.

> key question is not just force balance: it’s whether the inextensible

This is definitely not astra, taking a guess this is 5.6, perhaps not even Sol, which does not reflect the state of the frontier (what the research was about).

And yes, the paper is already outdated

Starting to feel more and more like chinese room experiment

The models are confidently answering physics questions, treating it as a math problem, but they don't fundamentally "get it" and even recently failed simple "should i drive to car wash" test

The sample efficiency is just crazy low

Still surprising that even with this they managed to saturate the benchmarks

Snapdragon 8 Gen 3 does have a dedicated Hexagon NPU, so supposedly it can be done, but quality might not be great

Doesn't it render at half or even quarter resolution before upscaling, so wouldn't it be less e2e latency overall?

You can even run Half-Life Alyx on Steam Frame itself (standalone mode), albeit at around 36FPS according to Tested https://youtu.be/C9JyWAVj94E?t=3330

Valve confirmed a separate strap with hot-swappable batteries 'coming soon'

Foveated Streaming seems to be buried on the page, this feels like a true game changer, especially for PCVR. Coupled with eye tracking it unlocks about 2-3x more compute for rendering. Now sparkle DLSS-like upscaling and you can render 144hz native resolution PCVR games without buying a 5090. Truly exciting stuff.

I still remember Michael Abrash's talk from 2016 where he talks about Foveated Rendering + Eye tracking as one of the key pillars of next-gen headsets https://youtu.be/o7OpS7pZ5ok?t=5438. Interestingly, his prediction was that it would be widespread as of about 5 years ago. Is next-gen finally here after 10 years?

Even if you ban all model training, a highly capable rogue AI can exfiltrate its own weights and continue training in secret for "self-preservation". The cat may be out of the bag.

I would be surprised if we're not there yet. If Jane Street can generate $500 million per MW of compute right now I'm sure it's already possible.

We might still be figuring out how to benchmark these models by the time next gen comes.

I used to think that way about SVGBench, after all labs can just train on the test set, right? It turns out the task was highly generalizable. Try designing a logo and you quickly see the gap between models visually. Even though there is still a gap between "shiny demo SVG" and actual real-world use.

Same thing happened with MineBench, basically SVGBench+3D, until that got "saturated".

Remember spinning hexagon bench[1]? Or the AI World Clocks[2]? Yeah, that used to be hard for frontier models.

Creating games is the next iteration that still has some signal left. Assets + Game logic + UI + Sound, it let's you assess a model's "taste" very quickly.

What else is left, once all these benchmarks get saturated?

[1] https://x.com/flavioAd/status/1885449107436679394

[2] https://news.ycombinator.com/item?id=45930151