ntonozzi

It doesn't stream text does it? If it could it would be perfect in my book.

Everyone said that except for 538. That's why 538 was worth reading.

Something like Cloudflare's Code Mode fixes both of these! No privileged bash environment, no VM necessary, no exposing credentials to the LLM.

As the article states, LLMs are fantastic at writing code, and not so good at issuing tool calls.

The UK is begging for people to build datacenters: https://www.theguardian.com/technology/2026/mar/09/revealed-...

Perhaps because he is a journalist whose job is to report reality, not avoid threats?

Yeah you can: https://thinkingmachines.ai/blog/defeating-nondeterminism-in....

Why do they need to run benchmarks to confirm performance? Can't they run an example prompt and verify they get the exact same output token probabilities for all prompts? The fact that they are not doing this makes me suspicious that they are in fact not doing the exact same thing as vLLM.

It is also a bit weird that they are not incorporating speculative decoding, that seems like a critical performance optimization, especially for decode heavy workloads.

IMO the core of the issue is the awful Github Actions Cache design. Look at the recommendations to avoid an attack by this extremely pernicious malware proof of concept: https://github.com/AdnaneKhan/Cacheract?tab=readme-ov-file#g.... How easy is it to mess this up when designing an action?

The LLM is a cute way to carry out this vulnerability, but in fact it's very easy to get code execution and poison a cache without LLMs, for example when executing code in the context of a unit test.

Wow that is wild, that is exactly along the lines of my fantasy language. It'd be so easy to go into the deep end building tooling and improving a language like this.

That argument was dead _at least_ 2 years ago, when we gave LLMs tools.

Many privacy regulations enforce full deletion of data, including GDPR: https://gdpr-info.eu/.

I've given up on soft delete -- the nail in the coffin for me was my customers' legal requirements that data is fully deleted, not archived. It never worked that well anyways. I never had a successful restore from a large set of soft-deleted rows.

Hopefully it gets more tightly integrated.

Home affordability is getting better anyways, which is great, because we are finally having a surge in new & denser home building in popular regions and there mortgage rates are more reasonable than they were in the COVID-era.

Maybe the best part of this legislation will be that people will realize it's not institutional investors that are driving up home prices. No, that's far too optimistic.

It's not debouncing, it's delaying. Ideally you can still update a specific dependency to a more up to date version if it turns out an old version has a vulnerability.

One of my favorite blog posts of all time: https://aphyr.com/posts/342-typing-the-technical-interview

There are some good reasons it is lower now, like defense lawyers and Miranda rights. Obviously it'd be good if we had both good civil rights AND high murder clearance, but they seem in obvious tension with each other.

If you haven't, give Cursor's Composer model a shot. It might not be quite as good as the top models, but in my experience it's almost as good, and the lightning fast feedback is more than worth the tradeoff. You can give it a task, wait ten seconds, and evaluate the results. It's quite common for it to not be good enough, but no worse than Sonnet, and if it doesn't work you just wasted 30 seconds instead of 10 minutes.

My question is genuine.

Not really the point, but an idea that springs to mind is selling fighter jets to allied countries.

Check out this graphic:

https://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect#...

This is the only thing Dunning-Kruger found.

Actual performance is correlated with perceived performance, mediated by the fact that everyone thinks they are a bit above average.

Could you share more information about the trials in Alaska? I can't track down the results you're talking about.

Is this goal documented by the Department of War somewhere? Or are you guessing that there has to be a strategic reason for what seems quite wasteful. It sure seems like there's more efficient ways to achieve this goal.

You're misinterpreting the quote. Unskilled people overestimate how skilled they are, but they still understand that they are unskilled. They just don't know quite how unskilled. What Kruger & Dunning actually showed is that people tend to skew their estimates of their skill towards being slightly above average.

I really like the extension pattern. I wish more of the tables at my company used it.

Another huge benefit that we're realizing as we move some of our heaviest tables to this pattern is that it makes it really easy to index a core set of fields in Elasticsearch, along with a tag to associate it with a particular domain model. This has drastically cut down on our search-specific denormlization and let us avoid expensive index schema updates.

Plus, you're not any more ostentatious than any other triathlete at the beach.

This approach is so limiting it seems like it would be better to change the constraints. For example, in the case of a software agent you could run everything in a container, only allow calls you trust to not exfiltrate private and make the end result a PR you can review.

I just found a recent paper about this: https://arxiv.org/abs/2505.15778. It's really thoughtful and well written. They mix the different token outputs together.

Is there any work related to using some kind of soft tokens for reasoning? It seems so inefficient to try to encode so much information down into a single token for the next pass of the model, when you could output a large vector for each forward pass, and have a drastically larger working memory/scratchpad, and have much higher bandwidth for the models to pass information forward to the next token call. If a single token has 17 bits of information, a vector of 1024 floats could have 32,768 bits of information.

If you care that much about having correct data you could just do a SHA-256 of the whole thing. Or an HMAC. It would probably be really fast. If you don’t care much you can just do murmur hash of the serialized data. You don’t really need to verify data structure properties if you know the serialized data is correct.