33 karma · joined October 1, 2025
More nuanced take: you could say guardrails are important. However, "free" models will continue to exist. Abliteration is a thing with open weights.
Bad actors don't care about laws, especially with high stakes.
Impressed.
The gall of writing such a piece is really hard to digest.
The Houthis, of all involved, using actual AI to attack Saudi pipelines is satire at its best.
This period of time will be the stuff you tell your grandchildren, if you have any, and they'll just look at you in disbelief.
I personally like google over asking an AI. Esp. since something like google is a substrate without which an AI would be far more prone to hallucinations.
Either the next administration declares data-centers to be unimportant (which is unlikely, China etc.), or they would want to offload them as far as possible. If space is an option, it will be taken provided it's cost efficient.
Gets confused by permission prompts, cannot debug a failing test it caused (Opus 4.8 got it right after, without tens of rounds "thinking").
UX trumps everything, and is scarcer than ever.
I see where you're coming from, though.
I'm not sure this looks credible. 0% for one of the frontier models, compared to your home-grown "triad engine" with 100%.
Rust is the prime example - it uses affine types (linear logic) to track ownership and borrowing in imperative code. The type system prevents memory safety bugs at compile time without garbage collection.
C++ concepts (C++20) bring dependent typing to template metaprogramming. You can express "this function works for any type T that satisfies these type-level constraints."
Refinement types in languages like Dafny let you encode invariants directly in the type system for imperative code: int{x | x > 0} for positive integers.
The challenge isn't technical compatibility - it's that imperative programming often emphasizes mutation and side effects, while type theory shines at reasoning about pure transformations. But when you can encode the "shape" of your mutations in types (like Rust's ownership), you get incredible safety guarantees.
The real question might be: why don't more imperative languages adopt these ideas? Legacy compatibility and learning curves are probably the main barriers.