labeling is more specific than training, and changes the implied situation.
Its the same difference between "I was arrested for having liquid in my car while driving" and "I was arrested for holding an open bottle of whiskey while driving"
The short answer is: they need to make money now to fund continued improvements towards AGI. This is extremely obvious and these "well if they had AGI..." arguments are clearly in bad faith.
You have to run a legitimate business and make money. After the "takeoff," anything is fair game. It could result in value accruing to capital (lab shareholders) and everyone else is screwed, it could result in the status quo being maintained but people do way more and GDP goes up by a lot, it could result in a post scarcity society etc. Theres a reason why its called the singularity - you can't see past the event horizon.
In any case it is optimal for OpenAI to create good products that generate revenue NOW vs going for some straight shot pie in the sky model that is "AGI." SSI is attempting to do this and I suspect they are about as close as anyone else is, and I'd honestly assume they are likely further away than OpenAI or Anthropic at the moment. But one of these classes of companies has actual revenue that is arguably good for the economy, the other is just a glorified research lab that has produced nothing of value.
AGI is like water, and these surfaces are the plumbing. Agents and the internet's existing APIs are how AGI will actually be delivered in the short term.
But you're completely right: our current APIs were optimized for humans, and some like Excel date from the 80s. So in the long term, agents will highly likely create their own interfaces optimized for when no human is in the loop.
Which is exactly why companies stick with current APIs for now. Fable 5.1 already emits alien-like reasoning traces, and the recent OpenAI agent swarm accident just proved this.
> By using passkeys, you gain better security against man-in-the-middle attacks but face the higher probability scenario of losing access to your accounts.
> Phishing through the standard login flow is eliminated by passkeys, but it creates a false sense of security. An account’s security is still dictated by the weakest recovery method: SMS, email links, security questions, and so on.
Passkeys are too strong and may cause account loss.
Passkeys are too weak and can be bypassed by account recovery.
The guidance given seems to hurt open source projects, not help.
> Make the project private if the traffic is not coming from the audience you built it for, which stops anonymous callers reaching it at all. Or upgrade to Premium or Ultimate for much higher limits.
I have long been critical of verification tools requiring annotations. Humans cannot write correct code, so asking them to write correct proof annotations seems futile.
But maybe this changes in the age of LLMs. A deterministic check to let LLMs verify the correctness of an API could improve the success rate of large scale refactors or performance optimizations.
You seem to have misunderstood the idea. The entire idea of proof annotations is that they are not manual. Rather, the verifier checks you fulfill the preconditions for the method you calls, and it checks inside the method that if the preconditions are fulfilled then the postconditions are too. This just helps the verifier reason locally. At the end besides more burden, the only thing you really need to check is the top-level annotations, like any formal verifier.
> the only thing you really need to check is the top-level annotations
Sorry if I wasn’t clear.
My point is that the annotations are manual and inherently prone to error.
If humans could correctly write annotations according to a spec, we wouldn’t need verifiers at all. We could just write correct code directly.
There is an argument to be made that the annotations are a smaller surface than full blown code and therefore easier for humans to reason about.
However, in practice formal verification tools and annotations are far more obscure than regular code.
Thousands of people write and review code both professionally and as a hobby. But most people writing verifier annotations have a PhD in some field adjacent to formal verification.
You were clear, and you were wrong. The annotations are checked like I said, you cannot break the guarantees using them. If they're incorrect they won't pass verification. They just help the verifier.
Programmer intends to write code that does Y, but writes code that does X. Then they make the same mistake again and write an annotation that verifies the function does X.
Verification passes, but the code does the wrong thing.
Unless the function is a public API and unused in the library (i.e. if the function is used by code that expects it to do Y), it won't pass verification.
If it is public API, it indeed can pass. This is similar to theorem provers - if you get your axioms or theorems wrong, you can incorrectly "prove" things. But verifiers are still useful because most of the code has larger internal surface than external surface.
the vast majority of such annotations are checked though. There's generally three kinds of annotations in formal proof systems: assertions about inputs that cannot be checked by the system, statements of propositions that want to be checked, and proofs that those propositions follow from the assertions. The proofs are checked by the system, so writing them is mainly just tedious and difficult, not really a source of error. What needs to be verified carefully is that the assertions are true, and that the propositions actually correlate with what people actually want out of the system. The mark of how effective a formal verification system is is in how strong of a proposition can be proven from how small a set of assertions. (well, and then how difficult it is to write the proofs).
I agree on paper, but in practice most verification annotations in real code require a PhD to understand.
To me, it’s essentially implementing the same code twice in two languages and checking the behavior matches.
If the same person implements both, what are the odds they implement the same bug in both?
Only verification annotations are generally even harder to read and write than the code itself, making it even more difficult to tell if you implemented the proof according to the spec, or just mirrored what the function actually does.
A common one I hit is "blu" showing bluetooth settings, but "blue" does not. Very frustrating to see the thing you are hoping for popup, but then go away as you type more if its name.
Android keyboard does that too. When I start typing my email address, for example, the keyboard app suggests the correct email after a few characters, but if I keep typing it disappears from the suggestions.
I have to send a daily email that always has the subject starting with "Work Diary". If I type "W", it doesn't come up. If I type "Wo" it comes up as the 3rd auto-complete suggestion. If I type any more characters, I have to type the entire two words. This is on Android, but I have a feeling it's no better on iOS.
I'd love to know the algorithm they're using for this. Fuzzy search seems like it was a mostly solved problem 20 years ago, and it's definitely worse than it was 10 years ago.
It would be interesting to learn what over engineered solution to fuzzy string matching is being used here to exhibit this behavior, so we never make the same mistake.
Seems like someone got updated KPIs and decided to try the most ham-fisted enshittification move to raise registrations. Oh, it is now possible again to see about five top reviews per item. Seems like loss of traffic was rough.
Just tried this on iOS 27 and both blu and blue showed me bluetooth settings. I saw someone in a different thread of this discussion mention resetting dictionaries helping with autocorrect, I wonder if there is something that would apply to this situation which helps.
Its the same difference between "I was arrested for having liquid in my car while driving" and "I was arrested for holding an open bottle of whiskey while driving"
reply